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

full_name: CategoryTheory.Limits.instDecidableEqWalkingPair
code: /-- The type of objects for the diagram indexing a binary (co)product. -/
inductive WalkingPair : Type
  | left
  | right
  deriving DecidableEq, Inhabited
goal: DecidableEq CategoryTheory.Limits.WalkingPair

full_name: CategoryTheory.Limits.WalkingPair.right
code: /-- The type of objects for the diagram indexing a binary (co)product. -/
inductive WalkingPair : Type
  | left
  | right
  deriving DecidableEq, Inhabited
goal: CategoryTheory.Limits.WalkingPair

full_name: CategoryTheory.Limits.WalkingPair
code: /-- The type of objects for the diagram indexing a binary (co)product. -/
inductive WalkingPair : Type
  | left
  | right
  deriving DecidableEq, Inhabited
goal: Type

full_name: CategoryTheory.Limits.instInhabitedWalkingPair
code: /-- The type of objects for the diagram indexing a binary (co)product. -/
inductive WalkingPair : Type
  | left
  | right
  deriving DecidableEq, Inhabited
goal: Inhabited CategoryTheory.Limits.WalkingPair

full_name: CategoryTheory.Limits.WalkingPair.left
code: /-- The type of objects for the diagram indexing a binary (co)product. -/
inductive WalkingPair : Type
  | left
  | right
  deriving DecidableEq, Inhabited
goal: CategoryTheory.Limits.WalkingPair

full_name: CategoryTheory.Limits.WalkingPair.swap
code: /-- The equivalence swapping left and right.
-/
def WalkingPair.swap : WalkingPair ≃ WalkingPair 
goal: CategoryTheory.Limits.WalkingPair ≃ CategoryTheory.Limits.WalkingPair

full_name: CategoryTheory.Limits.WalkingPair.swap_apply_left
code: @[simp]
theorem WalkingPair.swap_apply_left : WalkingPair.swap left = right 
goal: CategoryTheory.Limits.WalkingPair.swap CategoryTheory.Limits.WalkingPair.left = CategoryTheory.Limits.WalkingPair.right

full_name: CategoryTheory.Limits.WalkingPair.swap_apply_right
code: @[simp]
theorem WalkingPair.swap_apply_right : WalkingPair.swap right = left 
goal: CategoryTheory.Limits.WalkingPair.swap CategoryTheory.Limits.WalkingPair.right = CategoryTheory.Limits.WalkingPair.left

full_name: CategoryTheory.Limits.WalkingPair.swap_symm_apply_tt
code: @[simp]
theorem WalkingPair.swap_symm_apply_tt : WalkingPair.swap.symm left = right 
goal: CategoryTheory.Limits.WalkingPair.swap.symm CategoryTheory.Limits.WalkingPair.left =
  CategoryTheory.Limits.WalkingPair.right

full_name: CategoryTheory.Limits.WalkingPair.swap_symm_apply_ff
code: @[simp]
theorem WalkingPair.swap_symm_apply_ff : WalkingPair.swap.symm right = left 
goal: CategoryTheory.Limits.WalkingPair.swap.symm CategoryTheory.Limits.WalkingPair.right =
  CategoryTheory.Limits.WalkingPair.left

full_name: CategoryTheory.Limits.WalkingPair.equivBool
code: /-- An equivalence from `WalkingPair` to `Bool`, sometimes useful when reindexing limits.
-/
def WalkingPair.equivBool : WalkingPair ≃ Bool 
goal: CategoryTheory.Limits.WalkingPair ≃ Bool

full_name: CategoryTheory.Limits.WalkingPair.equivBool_apply_left
code: @[simp]
theorem WalkingPair.equivBool_apply_left : WalkingPair.equivBool left = true 
goal: CategoryTheory.Limits.WalkingPair.equivBool CategoryTheory.Limits.WalkingPair.left = true

full_name: CategoryTheory.Limits.WalkingPair.equivBool_apply_right
code: @[simp]
theorem WalkingPair.equivBool_apply_right : WalkingPair.equivBool right = false 
goal: CategoryTheory.Limits.WalkingPair.equivBool CategoryTheory.Limits.WalkingPair.right = false

full_name: CategoryTheory.Limits.WalkingPair.equivBool_symm_apply_true
code: @[simp]
theorem WalkingPair.equivBool_symm_apply_true : WalkingPair.equivBool.symm true = left 
goal: CategoryTheory.Limits.WalkingPair.equivBool.symm true = CategoryTheory.Limits.WalkingPair.left

full_name: CategoryTheory.Limits.WalkingPair.equivBool_symm_apply_false
code: @[simp]
theorem WalkingPair.equivBool_symm_apply_false : WalkingPair.equivBool.symm false = right 
goal: CategoryTheory.Limits.WalkingPair.equivBool.symm false = CategoryTheory.Limits.WalkingPair.right

full_name: CategoryTheory.Limits.pairFunction
code: /-- The function on the walking pair, sending the two points to `X` and `Y`. -/
def pairFunction (X Y : C) : WalkingPair → C 
goal: CategoryTheory.Limits.WalkingPair → C

full_name: CategoryTheory.Limits.pairFunction_left
code: @[simp]
theorem pairFunction_left (X Y : C) : pairFunction X Y left = X 
goal: CategoryTheory.Limits.pairFunction X Y CategoryTheory.Limits.WalkingPair.left = X

full_name: CategoryTheory.Limits.pairFunction_right
code: @[simp]
theorem pairFunction_right (X Y : C) : pairFunction X Y right = Y 
goal: CategoryTheory.Limits.pairFunction X Y CategoryTheory.Limits.WalkingPair.right = Y

full_name: CategoryTheory.Limits.pair
code: /-- The diagram on the walking pair, sending the two points to `X` and `Y`. -/
def pair (X Y : C) : Discrete WalkingPair ⥤ C 
goal: CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C

full_name: CategoryTheory.Limits.pair_obj_left
code: @[simp]
theorem pair_obj_left (X Y : C) : (pair X Y).obj ⟨left⟩ = X 
goal: (CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.left } = X

full_name: CategoryTheory.Limits.pair_obj_right
code: @[simp]
theorem pair_obj_right (X Y : C) : (pair X Y).obj ⟨right⟩ = Y 
goal: (CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.right } = Y

full_name: CategoryTheory.Limits.mapPair
code: /-- The natural transformation between two functors out of the
 walking pair, specified by its components. -/
def mapPair : F ⟶ G 
goal: F ⟶ G

full_name: CategoryTheory.Limits.mapPair_left
code: @[simp]
theorem mapPair_left : (mapPair f g).app ⟨left⟩ = f 
goal: (CategoryTheory.Limits.mapPair f g).app { as := CategoryTheory.Limits.WalkingPair.left } = f

full_name: CategoryTheory.Limits.mapPair_right
code: @[simp]
theorem mapPair_right : (mapPair f g).app ⟨right⟩ = g 
goal: (CategoryTheory.Limits.mapPair f g).app { as := CategoryTheory.Limits.WalkingPair.right } = g

full_name: CategoryTheory.Limits.mapPairIso
code: /-- The natural isomorphism between two functors out of the walking pair, specified by its
components. -/
@[simps!]
def mapPairIso (f : F.obj ⟨left⟩ ≅ G.obj ⟨left⟩) (g : F.obj ⟨right⟩ ≅ G.obj ⟨right⟩) : F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.Limits.mapPairIso_hom_app
code: /-- The natural isomorphism between two functors out of the walking pair, specified by its
components. -/
@[simps!]
def mapPairIso (f : F.obj ⟨left⟩ ≅ G.obj ⟨left⟩) (g : F.obj ⟨right⟩ ≅ G.obj ⟨right⟩) : F ≅ G 
goal: (CategoryTheory.Limits.mapPairIso f g).hom.app X = (CategoryTheory.Limits.WalkingPair.rec f g X.as).hom

full_name: CategoryTheory.Limits.mapPairIso_inv_app
code: /-- The natural isomorphism between two functors out of the walking pair, specified by its
components. -/
@[simps!]
def mapPairIso (f : F.obj ⟨left⟩ ≅ G.obj ⟨left⟩) (g : F.obj ⟨right⟩ ≅ G.obj ⟨right⟩) : F ≅ G 
goal: (CategoryTheory.Limits.mapPairIso f g).inv.app X = (CategoryTheory.Limits.WalkingPair.rec f g X.as).inv

full_name: CategoryTheory.Limits.diagramIsoPair
code: /-- Every functor out of the walking pair is naturally isomorphic (actually, equal) to a `pair` -/
@[simps!]
def diagramIsoPair (F : Discrete WalkingPair ⥤ C) :
    F ≅ pair (F.obj ⟨WalkingPair.left⟩) (F.obj ⟨WalkingPair.right⟩) 
goal: F ≅
  CategoryTheory.Limits.pair (F.obj { as := CategoryTheory.Limits.WalkingPair.left })
    (F.obj { as := CategoryTheory.Limits.WalkingPair.right })

full_name: CategoryTheory.Limits.diagramIsoPair_hom_app
code: /-- Every functor out of the walking pair is naturally isomorphic (actually, equal) to a `pair` -/
@[simps!]
def diagramIsoPair (F : Discrete WalkingPair ⥤ C) :
    F ≅ pair (F.obj ⟨WalkingPair.left⟩) (F.obj ⟨WalkingPair.right⟩) 
goal: (CategoryTheory.Limits.diagramIsoPair F).hom.app X =
  (CategoryTheory.Limits.WalkingPair.rec
      (CategoryTheory.Iso.refl (F.obj { as := CategoryTheory.Limits.WalkingPair.left }))
      (CategoryTheory.Iso.refl (F.obj { as := CategoryTheory.Limits.WalkingPair.right })) X.as).hom

full_name: CategoryTheory.Limits.diagramIsoPair_inv_app
code: /-- Every functor out of the walking pair is naturally isomorphic (actually, equal) to a `pair` -/
@[simps!]
def diagramIsoPair (F : Discrete WalkingPair ⥤ C) :
    F ≅ pair (F.obj ⟨WalkingPair.left⟩) (F.obj ⟨WalkingPair.right⟩) 
goal: (CategoryTheory.Limits.diagramIsoPair F).inv.app X =
  (CategoryTheory.Limits.WalkingPair.rec
      (CategoryTheory.Iso.refl (F.obj { as := CategoryTheory.Limits.WalkingPair.left }))
      (CategoryTheory.Iso.refl (F.obj { as := CategoryTheory.Limits.WalkingPair.right })) X.as).inv

full_name: CategoryTheory.Limits.pairComp
code: /-- The natural isomorphism between `pair X Y ⋙ F` and `pair (F.obj X) (F.obj Y)`. -/
def pairComp (X Y : C) (F : C ⥤ D) : pair X Y ⋙ F ≅ pair (F.obj X) (F.obj Y) 
goal: CategoryTheory.Limits.pair X Y ⋙ F ≅ CategoryTheory.Limits.pair (F.obj X) (F.obj Y)

full_name: CategoryTheory.Limits.BinaryFan
code: /-- A binary fan is just a cone on a diagram indexing a product. -/
abbrev BinaryFan (X Y : C) 
goal: Type (max u v)

full_name: CategoryTheory.Limits.BinaryFan.fst
code: /-- The first projection of a binary fan. -/
abbrev BinaryFan.fst {X Y : C} (s : BinaryFan X Y) 
goal: ((CategoryTheory.Functor.const (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)).obj s.pt).obj
    { as := CategoryTheory.Limits.WalkingPair.left } ⟶
  (CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.left }

full_name: CategoryTheory.Limits.BinaryFan.snd
code: /-- The second projection of a binary fan. -/
abbrev BinaryFan.snd {X Y : C} (s : BinaryFan X Y) 
goal: ((CategoryTheory.Functor.const (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)).obj s.pt).obj
    { as := CategoryTheory.Limits.WalkingPair.right } ⟶
  (CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.right }

full_name: CategoryTheory.Limits.BinaryFan.π_app_left
code: @[simp]
theorem BinaryFan.π_app_left {X Y : C} (s : BinaryFan X Y) : s.π.app ⟨WalkingPair.left⟩ = s.fst 
goal: s.π.app { as := CategoryTheory.Limits.WalkingPair.left } = s.fst

full_name: CategoryTheory.Limits.BinaryFan.π_app_right
code: @[simp]
theorem BinaryFan.π_app_right {X Y : C} (s : BinaryFan X Y) : s.π.app ⟨WalkingPair.right⟩ = s.snd 
goal: s.π.app { as := CategoryTheory.Limits.WalkingPair.right } = s.snd

full_name: CategoryTheory.Limits.BinaryFan.IsLimit.mk
code: /-- A convenient way to show that a binary fan is a limit. -/
def BinaryFan.IsLimit.mk {X Y : C} (s : BinaryFan X Y)
    (lift : ∀ {T : C} (_ : T ⟶ X) (_ : T ⟶ Y), T ⟶ s.pt)
    (hl₁ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.fst = f)
    (hl₂ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.snd = g)
    (uniq :
      ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y) (m : T ⟶ s.pt) (_ : m ≫ s.fst = f) (_ : m ≫ s.snd = g),
        m = lift f g) :
    IsLimit s 
goal: CategoryTheory.Limits.IsLimit s

full_name: CategoryTheory.Limits.BinaryFan.IsLimit.hom_ext
code: theorem BinaryFan.IsLimit.hom_ext {W X Y : C} {s : BinaryFan X Y} (h : IsLimit s) {f g : W ⟶ s.pt}
    (h₁ : f ≫ s.fst = g ≫ s.fst) (h₂ : f ≫ s.snd = g ≫ s.snd) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.BinaryCofan
code: /-- A binary cofan is just a cocone on a diagram indexing a coproduct. -/
abbrev BinaryCofan (X Y : C) 
goal: Type (max u v)

full_name: CategoryTheory.Limits.BinaryCofan.inl
code: /-- The first inclusion of a binary cofan. -/
abbrev BinaryCofan.inl {X Y : C} (s : BinaryCofan X Y) 
goal: (CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.left } ⟶
  ((CategoryTheory.Functor.const (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)).obj s.pt).obj
    { as := CategoryTheory.Limits.WalkingPair.left }

full_name: CategoryTheory.Limits.BinaryCofan.inr
code: /-- The second inclusion of a binary cofan. -/
abbrev BinaryCofan.inr {X Y : C} (s : BinaryCofan X Y) 
goal: (CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.right } ⟶
  ((CategoryTheory.Functor.const (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)).obj s.pt).obj
    { as := CategoryTheory.Limits.WalkingPair.right }

full_name: CategoryTheory.Limits.BinaryCofan.ι_app_left
code: @[simp]
theorem BinaryCofan.ι_app_left {X Y : C} (s : BinaryCofan X Y) :
    s.ι.app ⟨WalkingPair.left⟩ = s.inl 
goal: s.ι.app { as := CategoryTheory.Limits.WalkingPair.left } = s.inl

full_name: CategoryTheory.Limits.BinaryCofan.ι_app_right
code: @[simp]
theorem BinaryCofan.ι_app_right {X Y : C} (s : BinaryCofan X Y) :
    s.ι.app ⟨WalkingPair.right⟩ = s.inr 
goal: s.ι.app { as := CategoryTheory.Limits.WalkingPair.right } = s.inr

full_name: CategoryTheory.Limits.BinaryCofan.IsColimit.mk
code: /-- A convenient way to show that a binary cofan is a colimit. -/
def BinaryCofan.IsColimit.mk {X Y : C} (s : BinaryCofan X Y)
    (desc : ∀ {T : C} (_ : X ⟶ T) (_ : Y ⟶ T), s.pt ⟶ T)
    (hd₁ : ∀ {T : C} (f : X ⟶ T) (g : Y ⟶ T), s.inl ≫ desc f g = f)
    (hd₂ : ∀ {T : C} (f : X ⟶ T) (g : Y ⟶ T), s.inr ≫ desc f g = g)
    (uniq :
      ∀ {T : C} (f : X ⟶ T) (g : Y ⟶ T) (m : s.pt ⟶ T) (_ : s.inl ≫ m = f) (_ : s.inr ≫ m = g),
        m = desc f g) :
    IsColimit s 
goal: CategoryTheory.Limits.IsColimit s

full_name: CategoryTheory.Limits.BinaryCofan.IsColimit.hom_ext
code: theorem BinaryCofan.IsColimit.hom_ext {W X Y : C} {s : BinaryCofan X Y} (h : IsColimit s)
    {f g : s.pt ⟶ W} (h₁ : s.inl ≫ f = s.inl ≫ g) (h₂ : s.inr ≫ f = s.inr ≫ g) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.BinaryFan.mk_pt
code: /-- A binary fan with vertex `P` consists of the two projections `π₁ : P ⟶ X` and `π₂ : P ⟶ Y`. -/
@[simps pt]
def BinaryFan.mk {P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y) : BinaryFan X Y 
goal: (CategoryTheory.Limits.BinaryFan.mk π₁ π₂).pt = P

full_name: CategoryTheory.Limits.BinaryFan.mk
code: /-- A binary fan with vertex `P` consists of the two projections `π₁ : P ⟶ X` and `π₂ : P ⟶ Y`. -/
@[simps pt]
def BinaryFan.mk {P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y) : BinaryFan X Y 
goal: CategoryTheory.Limits.BinaryFan X Y

full_name: CategoryTheory.Limits.BinaryCofan.mk
code: /-- A binary cofan with vertex `P` consists of the two inclusions `ι₁ : X ⟶ P` and `ι₂ : Y ⟶ P`. -/
@[simps pt]
def BinaryCofan.mk {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : BinaryCofan X Y 
goal: CategoryTheory.Limits.BinaryCofan X Y

full_name: CategoryTheory.Limits.BinaryCofan.mk_pt
code: /-- A binary cofan with vertex `P` consists of the two inclusions `ι₁ : X ⟶ P` and `ι₂ : Y ⟶ P`. -/
@[simps pt]
def BinaryCofan.mk {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : BinaryCofan X Y 
goal: (CategoryTheory.Limits.BinaryCofan.mk ι₁ ι₂).pt = P

full_name: CategoryTheory.Limits.BinaryFan.mk_fst
code: @[simp]
theorem BinaryFan.mk_fst {P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y) : (BinaryFan.mk π₁ π₂).fst = π₁ 
goal: (CategoryTheory.Limits.BinaryFan.mk π₁ π₂).fst = π₁

full_name: CategoryTheory.Limits.BinaryFan.mk_snd
code: @[simp]
theorem BinaryFan.mk_snd {P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y) : (BinaryFan.mk π₁ π₂).snd = π₂ 
goal: (CategoryTheory.Limits.BinaryFan.mk π₁ π₂).snd = π₂

full_name: CategoryTheory.Limits.BinaryCofan.mk_inl
code: @[simp]
theorem BinaryCofan.mk_inl {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : (BinaryCofan.mk ι₁ ι₂).inl = ι₁ 
goal: (CategoryTheory.Limits.BinaryCofan.mk ι₁ ι₂).inl = ι₁

full_name: CategoryTheory.Limits.BinaryCofan.mk_inr
code: @[simp]
theorem BinaryCofan.mk_inr {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : (BinaryCofan.mk ι₁ ι₂).inr = ι₂ 
goal: (CategoryTheory.Limits.BinaryCofan.mk ι₁ ι₂).inr = ι₂

full_name: CategoryTheory.Limits.isoBinaryFanMk
code: /-- Every `BinaryFan` is isomorphic to an application of `BinaryFan.mk`. -/
def isoBinaryFanMk {X Y : C} (c : BinaryFan X Y) : c ≅ BinaryFan.mk c.fst c.snd 
goal: c ≅ CategoryTheory.Limits.BinaryFan.mk c.fst c.snd

full_name: CategoryTheory.Limits.isoBinaryCofanMk
code: /-- Every `BinaryFan` is isomorphic to an application of `BinaryFan.mk`. -/
def isoBinaryCofanMk {X Y : C} (c : BinaryCofan X Y) : c ≅ BinaryCofan.mk c.inl c.inr 
goal: c ≅ CategoryTheory.Limits.BinaryCofan.mk c.inl c.inr

full_name: CategoryTheory.Limits.BinaryFan.isLimitMk
code: /-- This is a more convenient formulation to show that a `BinaryFan` constructed using
`BinaryFan.mk` is a limit cone.
-/
def BinaryFan.isLimitMk {W : C} {fst : W ⟶ X} {snd : W ⟶ Y} (lift : ∀ s : BinaryFan X Y, s.pt ⟶ W)
    (fac_left : ∀ s : BinaryFan X Y, lift s ≫ fst = s.fst)
    (fac_right : ∀ s : BinaryFan X Y, lift s ≫ snd = s.snd)
    (uniq :
      ∀ (s : BinaryFan X Y) (m : s.pt ⟶ W) (_ : m ≫ fst = s.fst) (_ : m ≫ snd = s.snd),
        m = lift s) :
    IsLimit (BinaryFan.mk fst snd) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk fst snd)

full_name: CategoryTheory.Limits.BinaryCofan.isColimitMk
code: /-- This is a more convenient formulation to show that a `BinaryCofan` constructed using
`BinaryCofan.mk` is a colimit cocone.
-/
def BinaryCofan.isColimitMk {W : C} {inl : X ⟶ W} {inr : Y ⟶ W}
    (desc : ∀ s : BinaryCofan X Y, W ⟶ s.pt)
    (fac_left : ∀ s : BinaryCofan X Y, inl ≫ desc s = s.inl)
    (fac_right : ∀ s : BinaryCofan X Y, inr ≫ desc s = s.inr)
    (uniq :
      ∀ (s : BinaryCofan X Y) (m : W ⟶ s.pt) (_ : inl ≫ m = s.inl) (_ : inr ≫ m = s.inr),
        m = desc s) :
    IsColimit (BinaryCofan.mk inl inr) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk inl inr)

full_name: CategoryTheory.Limits.BinaryFan.IsLimit.lift'_coe
code: /-- If `s` is a limit binary fan over `X` and `Y`, then every pair of morphisms `f : W ⟶ X` and
    `g : W ⟶ Y` induces a morphism `l : W ⟶ s.pt` satisfying `l ≫ s.fst = f` and `l ≫ s.snd = g`.
    -/
@[simps]
def BinaryFan.IsLimit.lift' {W X Y : C} {s : BinaryFan X Y} (h : IsLimit s) (f : W ⟶ X)
    (g : W ⟶ Y) : { l : W ⟶ s.pt // l ≫ s.fst = f ∧ l ≫ s.snd = g } 
goal: ↑(CategoryTheory.Limits.BinaryFan.IsLimit.lift' h f g) = h.lift (CategoryTheory.Limits.BinaryFan.mk f g)

full_name: CategoryTheory.Limits.BinaryFan.IsLimit.lift'
code: /-- If `s` is a limit binary fan over `X` and `Y`, then every pair of morphisms `f : W ⟶ X` and
    `g : W ⟶ Y` induces a morphism `l : W ⟶ s.pt` satisfying `l ≫ s.fst = f` and `l ≫ s.snd = g`.
    -/
@[simps]
def BinaryFan.IsLimit.lift' {W X Y : C} {s : BinaryFan X Y} (h : IsLimit s) (f : W ⟶ X)
    (g : W ⟶ Y) : { l : W ⟶ s.pt // l ≫ s.fst = f ∧ l ≫ s.snd = g } 
goal: { l // l ≫ s.fst = f ∧ l ≫ s.snd = g }

full_name: CategoryTheory.Limits.BinaryCofan.IsColimit.desc'_coe
code: /-- If `s` is a colimit binary cofan over `X` and `Y`,, then every pair of morphisms `f : X ⟶ W` and
    `g : Y ⟶ W` induces a morphism `l : s.pt ⟶ W` satisfying `s.inl ≫ l = f` and `s.inr ≫ l = g`.
    -/
@[simps]
def BinaryCofan.IsColimit.desc' {W X Y : C} {s : BinaryCofan X Y} (h : IsColimit s) (f : X ⟶ W)
    (g : Y ⟶ W) : { l : s.pt ⟶ W // s.inl ≫ l = f ∧ s.inr ≫ l = g } 
goal: ↑(CategoryTheory.Limits.BinaryCofan.IsColimit.desc' h f g) = h.desc (CategoryTheory.Limits.BinaryCofan.mk f g)

full_name: CategoryTheory.Limits.BinaryCofan.IsColimit.desc'
code: /-- If `s` is a colimit binary cofan over `X` and `Y`,, then every pair of morphisms `f : X ⟶ W` and
    `g : Y ⟶ W` induces a morphism `l : s.pt ⟶ W` satisfying `s.inl ≫ l = f` and `s.inr ≫ l = g`.
    -/
@[simps]
def BinaryCofan.IsColimit.desc' {W X Y : C} {s : BinaryCofan X Y} (h : IsColimit s) (f : X ⟶ W)
    (g : Y ⟶ W) : { l : s.pt ⟶ W // s.inl ≫ l = f ∧ s.inr ≫ l = g } 
goal: { l // s.inl ≫ l = f ∧ s.inr ≫ l = g }

full_name: CategoryTheory.Limits.BinaryFan.isLimitFlip
code: /-- Binary products are symmetric. -/
def BinaryFan.isLimitFlip {X Y : C} {c : BinaryFan X Y} (hc : IsLimit c) :
    IsLimit (BinaryFan.mk c.snd c.fst) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk c.snd c.fst)

full_name: CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_fst
code: theorem BinaryFan.isLimit_iff_isIso_fst {X Y : C} (h : IsTerminal Y) (c : BinaryFan X Y) :
    Nonempty (IsLimit c) ↔ IsIso c.fst 
goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.fst

full_name: CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_snd
code: theorem BinaryFan.isLimit_iff_isIso_snd {X Y : C} (h : IsTerminal X) (c : BinaryFan X Y) :
    Nonempty (IsLimit c) ↔ IsIso c.snd 
goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.snd

full_name: CategoryTheory.Limits.BinaryFan.isLimitCompLeftIso
code: /-- If `X' ≅ X`, then `X × Y` also is the product of `X'` and `Y`. -/
noncomputable def BinaryFan.isLimitCompLeftIso {X Y X' : C} (c : BinaryFan X Y) (f : X ⟶ X')
    [IsIso f] (h : IsLimit c) : IsLimit (BinaryFan.mk (c.fst ≫ f) c.snd) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk (c.fst ≫ f) c.snd)

full_name: CategoryTheory.Limits.BinaryFan.isLimitCompRightIso
code: /-- If `Y' ≅ Y`, then `X x Y` also is the product of `X` and `Y'`. -/
noncomputable def BinaryFan.isLimitCompRightIso {X Y Y' : C} (c : BinaryFan X Y) (f : Y ⟶ Y')
    [IsIso f] (h : IsLimit c) : IsLimit (BinaryFan.mk c.fst (c.snd ≫ f)) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk c.fst (c.snd ≫ f))

full_name: CategoryTheory.Limits.BinaryCofan.isColimitFlip
code: /-- Binary coproducts are symmetric. -/
def BinaryCofan.isColimitFlip {X Y : C} {c : BinaryCofan X Y} (hc : IsColimit c) :
    IsColimit (BinaryCofan.mk c.inr c.inl) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk c.inr c.inl)

full_name: CategoryTheory.Limits.BinaryCofan.isColimit_iff_isIso_inl
code: theorem BinaryCofan.isColimit_iff_isIso_inl {X Y : C} (h : IsInitial Y) (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔ IsIso c.inl 
goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔ CategoryTheory.IsIso c.inl

full_name: CategoryTheory.Limits.BinaryCofan.isColimit_iff_isIso_inr
code: theorem BinaryCofan.isColimit_iff_isIso_inr {X Y : C} (h : IsInitial X) (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔ IsIso c.inr 
goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔ CategoryTheory.IsIso c.inr

full_name: CategoryTheory.Limits.BinaryCofan.isColimitCompLeftIso
code: /-- If `X' ≅ X`, then `X ⨿ Y` also is the coproduct of `X'` and `Y`. -/
noncomputable def BinaryCofan.isColimitCompLeftIso {X Y X' : C} (c : BinaryCofan X Y) (f : X' ⟶ X)
    [IsIso f] (h : IsColimit c) : IsColimit (BinaryCofan.mk (f ≫ c.inl) c.inr) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk (f ≫ c.inl) c.inr)

full_name: CategoryTheory.Limits.BinaryCofan.isColimitCompRightIso
code: /-- If `Y' ≅ Y`, then `X ⨿ Y` also is the coproduct of `X` and `Y'`. -/
noncomputable def BinaryCofan.isColimitCompRightIso {X Y Y' : C} (c : BinaryCofan X Y) (f : Y' ⟶ Y)
    [IsIso f] (h : IsColimit c) : IsColimit (BinaryCofan.mk c.inl (f ≫ c.inr)) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk c.inl (f ≫ c.inr))

full_name: CategoryTheory.Limits.HasBinaryProduct
code: /-- An abbreviation for `HasLimit (pair X Y)`. -/
abbrev HasBinaryProduct (X Y : C) 
goal: Prop

full_name: CategoryTheory.Limits.HasBinaryCoproduct
code: /-- An abbreviation for `HasColimit (pair X Y)`. -/
abbrev HasBinaryCoproduct (X Y : C) 
goal: Prop

full_name: CategoryTheory.Limits.prod
code: /-- If we have a product of `X` and `Y`, we can access it using `prod X Y` or
    `X ⨯ Y`. -/
abbrev prod (X Y : C) [HasBinaryProduct X Y] 
goal: C

full_name: CategoryTheory.Limits.coprod
code: /-- If we have a coproduct of `X` and `Y`, we can access it using `coprod X Y` or
    `X ⨿ Y`. -/
abbrev coprod (X Y : C) [HasBinaryCoproduct X Y] 
goal: C

full_name: CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_BinaryProducts___unexpand_CategoryTheory_Limits_prod_1
code: /-- Notation for the product -/
notation:20 X " ⨯ " Y:20 => prod X Y
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_BinaryProducts___macroRules_CategoryTheory_Limits_term_⨯__1»
code: /-- Notation for the product -/
notation:20 X " ⨯ " Y:20 => prod X Y
goal: Lean.Macro

full_name: CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_BinaryProducts___unexpand_CategoryTheory_Limits_coprod_1
code: /-- Notation for the coproduct -/
notation:20 X " ⨿ " Y:20 => coprod X Y
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_BinaryProducts___macroRules_CategoryTheory_Limits_term_⨿__1»
code: /-- Notation for the coproduct -/
notation:20 X " ⨿ " Y:20 => coprod X Y
goal: Lean.Macro

full_name: CategoryTheory.Limits.prod.fst
code: /-- The projection map to the first component of the product. -/
abbrev prod.fst {X Y : C} [HasBinaryProduct X Y] : X ⨯ Y ⟶ X 
goal: X ⨯ Y ⟶ X

full_name: CategoryTheory.Limits.prod.snd
code: /-- The projection map to the second component of the product. -/
abbrev prod.snd {X Y : C} [HasBinaryProduct X Y] : X ⨯ Y ⟶ Y 
goal: X ⨯ Y ⟶ Y

full_name: CategoryTheory.Limits.coprod.inl
code: /-- The inclusion map from the first component of the coproduct. -/
abbrev coprod.inl {X Y : C} [HasBinaryCoproduct X Y] : X ⟶ X ⨿ Y 
goal: X ⟶ X ⨿ Y

full_name: CategoryTheory.Limits.coprod.inr
code: /-- The inclusion map from the second component of the coproduct. -/
abbrev coprod.inr {X Y : C} [HasBinaryCoproduct X Y] : Y ⟶ X ⨿ Y 
goal: Y ⟶ X ⨿ Y

full_name: CategoryTheory.Limits.prodIsProd
code: /-- The binary fan constructed from the projection maps is a limit. -/
def prodIsProd (X Y : C) [HasBinaryProduct X Y] :
    IsLimit (BinaryFan.mk (prod.fst : X ⨯ Y ⟶ X) prod.snd) 
goal: CategoryTheory.Limits.IsLimit
  (CategoryTheory.Limits.BinaryFan.mk CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd)

full_name: CategoryTheory.Limits.coprodIsCoprod
code: /-- The binary cofan constructed from the coprojection maps is a colimit. -/
def coprodIsCoprod (X Y : C) [HasBinaryCoproduct X Y] :
    IsColimit (BinaryCofan.mk (coprod.inl : X ⟶ X ⨿ Y) coprod.inr) 
goal: CategoryTheory.Limits.IsColimit
  (CategoryTheory.Limits.BinaryCofan.mk CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr)

full_name: CategoryTheory.Limits.prod.hom_ext
code: @[ext 1100]
theorem prod.hom_ext {W X Y : C} [HasBinaryProduct X Y] {f g : W ⟶ X ⨯ Y}
    (h₁ : f ≫ prod.fst = g ≫ prod.fst) (h₂ : f ≫ prod.snd = g ≫ prod.snd) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.coprod.hom_ext
code: @[ext 1100]
theorem coprod.hom_ext {W X Y : C} [HasBinaryCoproduct X Y] {f g : X ⨿ Y ⟶ W}
    (h₁ : coprod.inl ≫ f = coprod.inl ≫ g) (h₂ : coprod.inr ≫ f = coprod.inr ≫ g) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.prod.lift
code: /-- If the product of `X` and `Y` exists, then every pair of morphisms `f : W ⟶ X` and `g : W ⟶ Y`
    induces a morphism `prod.lift f g : W ⟶ X ⨯ Y`. -/
abbrev prod.lift {W X Y : C} [HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y) : W ⟶ X ⨯ Y 
goal: W ⟶ X ⨯ Y

full_name: CategoryTheory.Limits.diag
code: /-- diagonal arrow of the binary product in the category `fam I` -/
abbrev diag (X : C) [HasBinaryProduct X X] : X ⟶ X ⨯ X 
goal: X ⟶ X ⨯ X

full_name: CategoryTheory.Limits.coprod.desc
code: /-- If the coproduct of `X` and `Y` exists, then every pair of morphisms `f : X ⟶ W` and
    `g : Y ⟶ W` induces a morphism `coprod.desc f g : X ⨿ Y ⟶ W`. -/
abbrev coprod.desc {W X Y : C} [HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) : X ⨿ Y ⟶ W 
goal: X ⨿ Y ⟶ W

full_name: CategoryTheory.Limits.codiag
code: /-- codiagonal arrow of the binary coproduct -/
abbrev codiag (X : C) [HasBinaryCoproduct X X] : X ⨿ X ⟶ X 
goal: X ⨿ X ⟶ X

full_name: CategoryTheory.Limits.prod.lift_fst
code: @[reassoc]
theorem prod.lift_fst {W X Y : C} [HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y) :
    prod.lift f g ≫ prod.fst = f 
goal: CategoryTheory.Limits.prod.lift f g ≫ CategoryTheory.Limits.prod.fst = f

full_name: CategoryTheory.Limits.prod.lift_snd
code: @[reassoc]
theorem prod.lift_snd {W X Y : C} [HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y) :
    prod.lift f g ≫ prod.snd = g 
goal: CategoryTheory.Limits.prod.lift f g ≫ CategoryTheory.Limits.prod.snd = g

full_name: CategoryTheory.Limits.coprod.inl_desc
code: @[reassoc]
theorem coprod.inl_desc {W X Y : C} [HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) :
    coprod.inl ≫ coprod.desc f g = f 
goal: CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.Limits.coprod.desc f g = f

full_name: CategoryTheory.Limits.coprod.inr_desc
code: @[reassoc]
theorem coprod.inr_desc {W X Y : C} [HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) :
    coprod.inr ≫ coprod.desc f g = g 
goal: CategoryTheory.Limits.coprod.inr ≫ CategoryTheory.Limits.coprod.desc f g = g

full_name: CategoryTheory.Limits.prod.mono_lift_of_mono_left
code: instance prod.mono_lift_of_mono_left {W X Y : C} [HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y)
    [Mono f] : Mono (prod.lift f g) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.prod.lift f g)

full_name: CategoryTheory.Limits.prod.mono_lift_of_mono_right
code: instance prod.mono_lift_of_mono_right {W X Y : C} [HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y)
    [Mono g] : Mono (prod.lift f g) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.prod.lift f g)

full_name: CategoryTheory.Limits.coprod.epi_desc_of_epi_left
code: instance coprod.epi_desc_of_epi_left {W X Y : C} [HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W)
    [Epi f] : Epi (coprod.desc f g) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.coprod.desc f g)

full_name: CategoryTheory.Limits.coprod.epi_desc_of_epi_right
code: instance coprod.epi_desc_of_epi_right {W X Y : C} [HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W)
    [Epi g] : Epi (coprod.desc f g) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.coprod.desc f g)

full_name: CategoryTheory.Limits.prod.lift'
code: /-- If the product of `X` and `Y` exists, then every pair of morphisms `f : W ⟶ X` and `g : W ⟶ Y`
    induces a morphism `l : W ⟶ X ⨯ Y` satisfying `l ≫ Prod.fst = f` and `l ≫ Prod.snd = g`. -/
def prod.lift' {W X Y : C} [HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y) :
    { l : W ⟶ X ⨯ Y // l ≫ prod.fst = f ∧ l ≫ prod.snd = g } 
goal: { l // l ≫ CategoryTheory.Limits.prod.fst = f ∧ l ≫ CategoryTheory.Limits.prod.snd = g }

full_name: CategoryTheory.Limits.coprod.desc'
code: /-- If the coproduct of `X` and `Y` exists, then every pair of morphisms `f : X ⟶ W` and
    `g : Y ⟶ W` induces a morphism `l : X ⨿ Y ⟶ W` satisfying `coprod.inl ≫ l = f` and
    `coprod.inr ≫ l = g`. -/
def coprod.desc' {W X Y : C} [HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) :
    { l : X ⨿ Y ⟶ W // coprod.inl ≫ l = f ∧ coprod.inr ≫ l = g } 
goal: { l // CategoryTheory.Limits.coprod.inl ≫ l = f ∧ CategoryTheory.Limits.coprod.inr ≫ l = g }

full_name: CategoryTheory.Limits.prod.map
code: /-- If the products `W ⨯ X` and `Y ⨯ Z` exist, then every pair of morphisms `f : W ⟶ Y` and
    `g : X ⟶ Z` induces a morphism `prod.map f g : W ⨯ X ⟶ Y ⨯ Z`. -/
def prod.map {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z) :
    W ⨯ X ⟶ Y ⨯ Z 
goal: W ⨯ X ⟶ Y ⨯ Z

full_name: CategoryTheory.Limits.coprod.map
code: /-- If the coproducts `W ⨿ X` and `Y ⨿ Z` exist, then every pair of morphisms `f : W ⟶ Y` and
    `g : W ⟶ Z` induces a morphism `coprod.map f g : W ⨿ X ⟶ Y ⨿ Z`. -/
def coprod.map {W X Y Z : C} [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : W ⨿ X ⟶ Y ⨿ Z 
goal: W ⨿ X ⟶ Y ⨿ Z

full_name: CategoryTheory.Limits.prod.comp_lift
code: @[reassoc, simp]
theorem prod.comp_lift {V W X Y : C} [HasBinaryProduct X Y] (f : V ⟶ W) (g : W ⟶ X) (h : W ⟶ Y) :
    f ≫ prod.lift g h = prod.lift (f ≫ g) (f ≫ h) 
goal: f ≫ CategoryTheory.Limits.prod.lift g h = CategoryTheory.Limits.prod.lift (f ≫ g) (f ≫ h)

full_name: CategoryTheory.Limits.prod.comp_diag
code: theorem prod.comp_diag {X Y : C} [HasBinaryProduct Y Y] (f : X ⟶ Y) :
    f ≫ diag Y = prod.lift f f 
goal: f ≫ CategoryTheory.Limits.diag Y = CategoryTheory.Limits.prod.lift f f

full_name: CategoryTheory.Limits.prod.map_fst
code: @[reassoc (attr := simp)]
theorem prod.map_fst {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : prod.map f g ≫ prod.fst = prod.fst ≫ f 
goal: CategoryTheory.Limits.prod.map f g ≫ CategoryTheory.Limits.prod.fst = CategoryTheory.Limits.prod.fst ≫ f

full_name: CategoryTheory.Limits.prod.map_snd
code: @[reassoc (attr := simp)]
theorem prod.map_snd {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : prod.map f g ≫ prod.snd = prod.snd ≫ g 
goal: CategoryTheory.Limits.prod.map f g ≫ CategoryTheory.Limits.prod.snd = CategoryTheory.Limits.prod.snd ≫ g

full_name: CategoryTheory.Limits.prod.map_id_id
code: @[simp]
theorem prod.map_id_id {X Y : C} [HasBinaryProduct X Y] : prod.map (𝟙 X) (𝟙 Y) = 𝟙 _ 
goal: CategoryTheory.Limits.prod.map (𝟙 X) (𝟙 Y) = 𝟙 (X ⨯ Y)

full_name: CategoryTheory.Limits.prod.lift_fst_snd
code: @[simp]
theorem prod.lift_fst_snd {X Y : C} [HasBinaryProduct X Y] :
    prod.lift prod.fst prod.snd = 𝟙 (X ⨯ Y) 
goal: CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd = 𝟙 (X ⨯ Y)

full_name: CategoryTheory.Limits.prod.lift_map
code: @[reassoc (attr := simp)]
theorem prod.lift_map {V W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : V ⟶ W)
    (g : V ⟶ X) (h : W ⟶ Y) (k : X ⟶ Z) :
    prod.lift f g ≫ prod.map h k = prod.lift (f ≫ h) (g ≫ k) 
goal: CategoryTheory.Limits.prod.lift f g ≫ CategoryTheory.Limits.prod.map h k =
  CategoryTheory.Limits.prod.lift (f ≫ h) (g ≫ k)

full_name: CategoryTheory.Limits.prod.lift_fst_comp_snd_comp
code: @[simp]
theorem prod.lift_fst_comp_snd_comp {W X Y Z : C} [HasBinaryProduct W Y] [HasBinaryProduct X Z]
    (g : W ⟶ X) (g' : Y ⟶ Z) : prod.lift (prod.fst ≫ g) (prod.snd ≫ g') = prod.map g g' 
goal: CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.prod.fst ≫ g) (CategoryTheory.Limits.prod.snd ≫ g') =
  CategoryTheory.Limits.prod.map g g'

full_name: CategoryTheory.Limits.prod.map_map
code: @[reassoc (attr := simp)]
theorem prod.map_map {A₁ A₂ A₃ B₁ B₂ B₃ : C} [HasBinaryProduct A₁ B₁] [HasBinaryProduct A₂ B₂]
    [HasBinaryProduct A₃ B₃] (f : A₁ ⟶ A₂) (g : B₁ ⟶ B₂) (h : A₂ ⟶ A₃) (k : B₂ ⟶ B₃) :
    prod.map f g ≫ prod.map h k = prod.map (f ≫ h) (g ≫ k) 
goal: CategoryTheory.Limits.prod.map f g ≫ CategoryTheory.Limits.prod.map h k = CategoryTheory.Limits.prod.map (f ≫ h) (g ≫ k)

full_name: CategoryTheory.Limits.prod.map_swap
code: @[reassoc]
theorem prod.map_swap {A B X Y : C} (f : A ⟶ B) (g : X ⟶ Y)
    [HasLimitsOfShape (Discrete WalkingPair) C] :
    prod.map (𝟙 X) f ≫ prod.map g (𝟙 B) = prod.map g (𝟙 A) ≫ prod.map (𝟙 Y) f 
goal: CategoryTheory.Limits.prod.map (𝟙 X) f ≫ CategoryTheory.Limits.prod.map g (𝟙 B) =
  CategoryTheory.Limits.prod.map g (𝟙 A) ≫ CategoryTheory.Limits.prod.map (𝟙 Y) f

full_name: CategoryTheory.Limits.prod.map_comp_id
code: @[reassoc]
theorem prod.map_comp_id {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasBinaryProduct X W]
    [HasBinaryProduct Z W] [HasBinaryProduct Y W] :
    prod.map (f ≫ g) (𝟙 W) = prod.map f (𝟙 W) ≫ prod.map g (𝟙 W) 
goal: CategoryTheory.Limits.prod.map (f ≫ g) (𝟙 W) =
  CategoryTheory.Limits.prod.map f (𝟙 W) ≫ CategoryTheory.Limits.prod.map g (𝟙 W)

full_name: CategoryTheory.Limits.prod.map_id_comp
code: @[reassoc]
theorem prod.map_id_comp {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasBinaryProduct W X]
    [HasBinaryProduct W Y] [HasBinaryProduct W Z] :
    prod.map (𝟙 W) (f ≫ g) = prod.map (𝟙 W) f ≫ prod.map (𝟙 W) g 
goal: CategoryTheory.Limits.prod.map (𝟙 W) (f ≫ g) =
  CategoryTheory.Limits.prod.map (𝟙 W) f ≫ CategoryTheory.Limits.prod.map (𝟙 W) g

full_name: CategoryTheory.Limits.prod.mapIso
code: /-- If the products `W ⨯ X` and `Y ⨯ Z` exist, then every pair of isomorphisms `f : W ≅ Y` and
    `g : X ≅ Z` induces an isomorphism `prod.mapIso f g : W ⨯ X ≅ Y ⨯ Z`. -/
@[simps]
def prod.mapIso {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ≅ Y)
    (g : X ≅ Z) : W ⨯ X ≅ Y ⨯ Z 
goal: W ⨯ X ≅ Y ⨯ Z

full_name: CategoryTheory.Limits.prod.mapIso_inv
code: /-- If the products `W ⨯ X` and `Y ⨯ Z` exist, then every pair of isomorphisms `f : W ≅ Y` and
    `g : X ≅ Z` induces an isomorphism `prod.mapIso f g : W ⨯ X ≅ Y ⨯ Z`. -/
@[simps]
def prod.mapIso {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ≅ Y)
    (g : X ≅ Z) : W ⨯ X ≅ Y ⨯ Z 
goal: (CategoryTheory.Limits.prod.mapIso f g).inv = CategoryTheory.Limits.prod.map f.inv g.inv

full_name: CategoryTheory.Limits.prod.mapIso_hom
code: /-- If the products `W ⨯ X` and `Y ⨯ Z` exist, then every pair of isomorphisms `f : W ≅ Y` and
    `g : X ≅ Z` induces an isomorphism `prod.mapIso f g : W ⨯ X ≅ Y ⨯ Z`. -/
@[simps]
def prod.mapIso {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ≅ Y)
    (g : X ≅ Z) : W ⨯ X ≅ Y ⨯ Z 
goal: (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom

full_name: CategoryTheory.Limits.isIso_prod
code: instance isIso_prod {W X Y Z : C} [HasBinaryProduct W X] [HasBinaryProduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) [IsIso f] [IsIso g] : IsIso (prod.map f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.prod.map f g)

full_name: CategoryTheory.Limits.prod.map_mono
code: instance prod.map_mono {C : Type*} [Category C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z) [Mono f]
    [Mono g] [HasBinaryProduct W X] [HasBinaryProduct Y Z] : Mono (prod.map f g) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.prod.map f g)

full_name: CategoryTheory.Limits.prod.diag_map
code: @[reassoc] -- Porting note (#10618): simp can prove these
theorem prod.diag_map {X Y : C} (f : X ⟶ Y) [HasBinaryProduct X X] [HasBinaryProduct Y Y] :
    diag X ≫ prod.map f f = f ≫ diag Y 
goal: CategoryTheory.Limits.diag X ≫ CategoryTheory.Limits.prod.map f f = f ≫ CategoryTheory.Limits.diag Y

full_name: CategoryTheory.Limits.prod.diag_map_fst_snd
code: @[reassoc] -- Porting note (#10618): simp can prove these
theorem prod.diag_map_fst_snd {X Y : C} [HasBinaryProduct X Y] [HasBinaryProduct (X ⨯ Y) (X ⨯ Y)] :
    diag (X ⨯ Y) ≫ prod.map prod.fst prod.snd = 𝟙 (X ⨯ Y) 
goal: CategoryTheory.Limits.diag (X ⨯ Y) ≫
    CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd =
  𝟙 (X ⨯ Y)

full_name: CategoryTheory.Limits.prod.diag_map_fst_snd_comp
code: @[reassoc] -- Porting note (#10618): simp can prove these
theorem prod.diag_map_fst_snd_comp [HasLimitsOfShape (Discrete WalkingPair) C] {X X' Y Y' : C}
    (g : X ⟶ Y) (g' : X' ⟶ Y') :
    diag (X ⨯ X') ≫ prod.map (prod.fst ≫ g) (prod.snd ≫ g') = prod.map g g' 
goal: CategoryTheory.Limits.diag (X ⨯ X') ≫
    CategoryTheory.Limits.prod.map (CategoryTheory.Limits.prod.fst ≫ g) (CategoryTheory.Limits.prod.snd ≫ g') =
  CategoryTheory.Limits.prod.map g g'

full_name: CategoryTheory.Limits.instIsSplitMonoDiag
code: instance {X : C} [HasBinaryProduct X X] : IsSplitMono (diag X) 
goal: CategoryTheory.IsSplitMono (CategoryTheory.Limits.diag X)

full_name: CategoryTheory.Limits.coprod.desc_comp
code: @[simp] -- Porting note: removing reassoc tag since result is not hygienic (two h's)
theorem coprod.desc_comp {V W X Y : C} [HasBinaryCoproduct X Y] (f : V ⟶ W) (g : X ⟶ V)
    (h : Y ⟶ V) : coprod.desc g h ≫ f = coprod.desc (g ≫ f) (h ≫ f) 
goal: CategoryTheory.Limits.coprod.desc g h ≫ f = CategoryTheory.Limits.coprod.desc (g ≫ f) (h ≫ f)

full_name: CategoryTheory.Limits.coprod.desc_comp_assoc
code: theorem coprod.desc_comp_assoc {C : Type u} [Category C] {V W X Y : C}
    [HasBinaryCoproduct X Y] (f : V ⟶ W) (g : X ⟶ V) (h : Y ⟶ V) {Z : C} (l : W ⟶ Z) :
    coprod.desc g h ≫ f ≫ l = coprod.desc (g ≫ f) (h ≫ f) ≫ l 
goal: CategoryTheory.Limits.coprod.desc g h ≫ f ≫ l = CategoryTheory.Limits.coprod.desc (g ≫ f) (h ≫ f) ≫ l

full_name: CategoryTheory.Limits.coprod.diag_comp
code: theorem coprod.diag_comp {X Y : C} [HasBinaryCoproduct X X] (f : X ⟶ Y) :
    codiag X ≫ f = coprod.desc f f 
goal: CategoryTheory.Limits.codiag X ≫ f = CategoryTheory.Limits.coprod.desc f f

full_name: CategoryTheory.Limits.coprod.inl_map
code: @[reassoc (attr := simp)]
theorem coprod.inl_map {W X Y Z : C} [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : coprod.inl ≫ coprod.map f g = f ≫ coprod.inl 
goal: CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.Limits.coprod.map f g = f ≫ CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.coprod.inr_map
code: @[reassoc (attr := simp)]
theorem coprod.inr_map {W X Y Z : C} [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : coprod.inr ≫ coprod.map f g = g ≫ coprod.inr 
goal: CategoryTheory.Limits.coprod.inr ≫ CategoryTheory.Limits.coprod.map f g = g ≫ CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.coprod.map_id_id
code: @[simp]
theorem coprod.map_id_id {X Y : C} [HasBinaryCoproduct X Y] : coprod.map (𝟙 X) (𝟙 Y) = 𝟙 _ 
goal: CategoryTheory.Limits.coprod.map (𝟙 X) (𝟙 Y) = 𝟙 (X ⨿ Y)

full_name: CategoryTheory.Limits.coprod.desc_inl_inr
code: @[simp]
theorem coprod.desc_inl_inr {X Y : C} [HasBinaryCoproduct X Y] :
    coprod.desc coprod.inl coprod.inr = 𝟙 (X ⨿ Y) 
goal: CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr = 𝟙 (X ⨿ Y)

full_name: CategoryTheory.Limits.coprod.map_desc
code: @[reassoc, simp]
theorem coprod.map_desc {S T U V W : C} [HasBinaryCoproduct U W] [HasBinaryCoproduct T V]
    (f : U ⟶ S) (g : W ⟶ S) (h : T ⟶ U) (k : V ⟶ W) :
    coprod.map h k ≫ coprod.desc f g = coprod.desc (h ≫ f) (k ≫ g) 
goal: CategoryTheory.Limits.coprod.map h k ≫ CategoryTheory.Limits.coprod.desc f g =
  CategoryTheory.Limits.coprod.desc (h ≫ f) (k ≫ g)

full_name: CategoryTheory.Limits.coprod.desc_comp_inl_comp_inr
code: @[simp]
theorem coprod.desc_comp_inl_comp_inr {W X Y Z : C} [HasBinaryCoproduct W Y]
    [HasBinaryCoproduct X Z] (g : W ⟶ X) (g' : Y ⟶ Z) :
    coprod.desc (g ≫ coprod.inl) (g' ≫ coprod.inr) = coprod.map g g' 
goal: CategoryTheory.Limits.coprod.desc (g ≫ CategoryTheory.Limits.coprod.inl) (g' ≫ CategoryTheory.Limits.coprod.inr) =
  CategoryTheory.Limits.coprod.map g g'

full_name: CategoryTheory.Limits.coprod.map_map
code: @[reassoc (attr := simp)]
theorem coprod.map_map {A₁ A₂ A₃ B₁ B₂ B₃ : C} [HasBinaryCoproduct A₁ B₁] [HasBinaryCoproduct A₂ B₂]
    [HasBinaryCoproduct A₃ B₃] (f : A₁ ⟶ A₂) (g : B₁ ⟶ B₂) (h : A₂ ⟶ A₃) (k : B₂ ⟶ B₃) :
    coprod.map f g ≫ coprod.map h k = coprod.map (f ≫ h) (g ≫ k) 
goal: CategoryTheory.Limits.coprod.map f g ≫ CategoryTheory.Limits.coprod.map h k =
  CategoryTheory.Limits.coprod.map (f ≫ h) (g ≫ k)

full_name: CategoryTheory.Limits.coprod.map_swap
code: @[reassoc]
theorem coprod.map_swap {A B X Y : C} (f : A ⟶ B) (g : X ⟶ Y)
    [HasColimitsOfShape (Discrete WalkingPair) C] :
    coprod.map (𝟙 X) f ≫ coprod.map g (𝟙 B) = coprod.map g (𝟙 A) ≫ coprod.map (𝟙 Y) f 
goal: CategoryTheory.Limits.coprod.map (𝟙 X) f ≫ CategoryTheory.Limits.coprod.map g (𝟙 B) =
  CategoryTheory.Limits.coprod.map g (𝟙 A) ≫ CategoryTheory.Limits.coprod.map (𝟙 Y) f

full_name: CategoryTheory.Limits.coprod.map_comp_id
code: @[reassoc]
theorem coprod.map_comp_id {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasBinaryCoproduct Z W]
    [HasBinaryCoproduct Y W] [HasBinaryCoproduct X W] :
    coprod.map (f ≫ g) (𝟙 W) = coprod.map f (𝟙 W) ≫ coprod.map g (𝟙 W) 
goal: CategoryTheory.Limits.coprod.map (f ≫ g) (𝟙 W) =
  CategoryTheory.Limits.coprod.map f (𝟙 W) ≫ CategoryTheory.Limits.coprod.map g (𝟙 W)

full_name: CategoryTheory.Limits.coprod.map_id_comp
code: @[reassoc]
theorem coprod.map_id_comp {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [HasBinaryCoproduct W X]
    [HasBinaryCoproduct W Y] [HasBinaryCoproduct W Z] :
    coprod.map (𝟙 W) (f ≫ g) = coprod.map (𝟙 W) f ≫ coprod.map (𝟙 W) g 
goal: CategoryTheory.Limits.coprod.map (𝟙 W) (f ≫ g) =
  CategoryTheory.Limits.coprod.map (𝟙 W) f ≫ CategoryTheory.Limits.coprod.map (𝟙 W) g

full_name: CategoryTheory.Limits.coprod.mapIso
code: /-- If the coproducts `W ⨿ X` and `Y ⨿ Z` exist, then every pair of isomorphisms `f : W ≅ Y` and
   `g : W ≅ Z` induces an isomorphism `coprod.mapIso f g : W ⨿ X ≅ Y ⨿ Z`. -/
@[simps]
def coprod.mapIso {W X Y Z : C} [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] (f : W ≅ Y)
    (g : X ≅ Z) : W ⨿ X ≅ Y ⨿ Z 
goal: W ⨿ X ≅ Y ⨿ Z

full_name: CategoryTheory.Limits.coprod.mapIso_inv
code: /-- If the coproducts `W ⨿ X` and `Y ⨿ Z` exist, then every pair of isomorphisms `f : W ≅ Y` and
   `g : W ≅ Z` induces an isomorphism `coprod.mapIso f g : W ⨿ X ≅ Y ⨿ Z`. -/
@[simps]
def coprod.mapIso {W X Y Z : C} [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] (f : W ≅ Y)
    (g : X ≅ Z) : W ⨿ X ≅ Y ⨿ Z 
goal: (CategoryTheory.Limits.coprod.mapIso f g).inv = CategoryTheory.Limits.coprod.map f.inv g.inv

full_name: CategoryTheory.Limits.coprod.mapIso_hom
code: /-- If the coproducts `W ⨿ X` and `Y ⨿ Z` exist, then every pair of isomorphisms `f : W ≅ Y` and
   `g : W ≅ Z` induces an isomorphism `coprod.mapIso f g : W ⨿ X ≅ Y ⨿ Z`. -/
@[simps]
def coprod.mapIso {W X Y Z : C} [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] (f : W ≅ Y)
    (g : X ≅ Z) : W ⨿ X ≅ Y ⨿ Z 
goal: (CategoryTheory.Limits.coprod.mapIso f g).hom = CategoryTheory.Limits.coprod.map f.hom g.hom

full_name: CategoryTheory.Limits.isIso_coprod
code: instance isIso_coprod {W X Y Z : C} [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) [IsIso f] [IsIso g] : IsIso (coprod.map f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.coprod.map f g)

full_name: CategoryTheory.Limits.coprod.map_epi
code: instance coprod.map_epi {C : Type*} [Category C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z) [Epi f]
    [Epi g] [HasBinaryCoproduct W X] [HasBinaryCoproduct Y Z] : Epi (coprod.map f g) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.coprod.map f g)

full_name: CategoryTheory.Limits.coprod.map_codiag
code: @[reassoc]
theorem coprod.map_codiag {X Y : C} (f : X ⟶ Y) [HasBinaryCoproduct X X] [HasBinaryCoproduct Y Y] :
    coprod.map f f ≫ codiag Y = codiag X ≫ f 
goal: CategoryTheory.Limits.coprod.map f f ≫ CategoryTheory.Limits.codiag Y = CategoryTheory.Limits.codiag X ≫ f

full_name: CategoryTheory.Limits.coprod.map_inl_inr_codiag
code: @[reassoc]
theorem coprod.map_inl_inr_codiag {X Y : C} [HasBinaryCoproduct X Y]
    [HasBinaryCoproduct (X ⨿ Y) (X ⨿ Y)] :
    coprod.map coprod.inl coprod.inr ≫ codiag (X ⨿ Y) = 𝟙 (X ⨿ Y) 
goal: CategoryTheory.Limits.coprod.map CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr ≫
    CategoryTheory.Limits.codiag (X ⨿ Y) =
  𝟙 (X ⨿ Y)

full_name: CategoryTheory.Limits.coprod.map_comp_inl_inr_codiag
code: @[reassoc]
theorem coprod.map_comp_inl_inr_codiag [HasColimitsOfShape (Discrete WalkingPair) C] {X X' Y Y' : C}
    (g : X ⟶ Y) (g' : X' ⟶ Y') :
    coprod.map (g ≫ coprod.inl) (g' ≫ coprod.inr) ≫ codiag (Y ⨿ Y') = coprod.map g g' 
goal: CategoryTheory.Limits.coprod.map (g ≫ CategoryTheory.Limits.coprod.inl) (g' ≫ CategoryTheory.Limits.coprod.inr) ≫
    CategoryTheory.Limits.codiag (Y ⨿ Y') =
  CategoryTheory.Limits.coprod.map g g'

full_name: CategoryTheory.Limits.HasBinaryProducts
code: /-- `HasBinaryProducts` represents a choice of product for every pair of objects.

See <https://stacks.math.columbia.edu/tag/001T>.
-/
abbrev HasBinaryProducts 
goal: Prop

full_name: CategoryTheory.Limits.HasBinaryCoproducts
code: /-- `HasBinaryCoproducts` represents a choice of coproduct for every pair of objects.

See <https://stacks.math.columbia.edu/tag/04AP>.
-/
abbrev HasBinaryCoproducts 
goal: Prop

full_name: CategoryTheory.Limits.hasBinaryProducts_of_hasLimit_pair
code: /-- If `C` has all limits of diagrams `pair X Y`, then it has all binary products -/
theorem hasBinaryProducts_of_hasLimit_pair [∀ {X Y : C}, HasLimit (pair X Y)] :
    HasBinaryProducts C 
goal: CategoryTheory.Limits.HasBinaryProducts C

full_name: CategoryTheory.Limits.hasBinaryCoproducts_of_hasColimit_pair
code: /-- If `C` has all colimits of diagrams `pair X Y`, then it has all binary coproducts -/
theorem hasBinaryCoproducts_of_hasColimit_pair [∀ {X Y : C}, HasColimit (pair X Y)] :
    HasBinaryCoproducts C 
goal: CategoryTheory.Limits.HasBinaryCoproducts C

full_name: CategoryTheory.Limits.prod.braiding_inv
code: /-- The braiding isomorphism which swaps a binary product. -/
@[simps]
def prod.braiding (P Q : C) [HasBinaryProduct P Q] [HasBinaryProduct Q P] : P ⨯ Q ≅ Q ⨯ P 
goal: (CategoryTheory.Limits.prod.braiding P Q).inv =
  CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.prod.braiding
code: /-- The braiding isomorphism which swaps a binary product. -/
@[simps]
def prod.braiding (P Q : C) [HasBinaryProduct P Q] [HasBinaryProduct Q P] : P ⨯ Q ≅ Q ⨯ P 
goal: P ⨯ Q ≅ Q ⨯ P

full_name: CategoryTheory.Limits.prod.braiding_hom
code: /-- The braiding isomorphism which swaps a binary product. -/
@[simps]
def prod.braiding (P Q : C) [HasBinaryProduct P Q] [HasBinaryProduct Q P] : P ⨯ Q ≅ Q ⨯ P 
goal: (CategoryTheory.Limits.prod.braiding P Q).hom =
  CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.braid_natural
code: /-- The braiding isomorphism can be passed through a map by swapping the order. -/
@[reassoc]
theorem braid_natural [HasBinaryProducts C] {W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W) :
    prod.map f g ≫ (prod.braiding _ _).hom = (prod.braiding _ _).hom ≫ prod.map g f 
goal: CategoryTheory.Limits.prod.map f g ≫ (CategoryTheory.Limits.prod.braiding Y W).hom =
  (CategoryTheory.Limits.prod.braiding X Z).hom ≫ CategoryTheory.Limits.prod.map g f

full_name: CategoryTheory.Limits.prod.symmetry'
code: @[reassoc]
theorem prod.symmetry' (P Q : C) [HasBinaryProduct P Q] [HasBinaryProduct Q P] :
    prod.lift prod.snd prod.fst ≫ prod.lift prod.snd prod.fst = 𝟙 (P ⨯ Q) 
goal: CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst ≫
    CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.fst =
  𝟙 (P ⨯ Q)

full_name: CategoryTheory.Limits.prod.symmetry
code: /-- The braiding isomorphism is symmetric. -/
@[reassoc]
theorem prod.symmetry (P Q : C) [HasBinaryProduct P Q] [HasBinaryProduct Q P] :
    (prod.braiding P Q).hom ≫ (prod.braiding Q P).hom = 𝟙 _ 
goal: (CategoryTheory.Limits.prod.braiding P Q).hom ≫ (CategoryTheory.Limits.prod.braiding Q P).hom = 𝟙 (P ⨯ Q)

full_name: CategoryTheory.Limits.prod.associator_hom
code: /-- The associator isomorphism for binary products. -/
@[simps]
def prod.associator [HasBinaryProducts C] (P Q R : C) : (P ⨯ Q) ⨯ R ≅ P ⨯ Q ⨯ R 
goal: (CategoryTheory.Limits.prod.associator P Q R).hom =
  CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.prod.fst ≫ CategoryTheory.Limits.prod.fst)
    (CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.prod.fst ≫ CategoryTheory.Limits.prod.snd)
      CategoryTheory.Limits.prod.snd)

full_name: CategoryTheory.Limits.prod.associator
code: /-- The associator isomorphism for binary products. -/
@[simps]
def prod.associator [HasBinaryProducts C] (P Q R : C) : (P ⨯ Q) ⨯ R ≅ P ⨯ Q ⨯ R 
goal: (P ⨯ Q) ⨯ R ≅ P ⨯ Q ⨯ R

full_name: CategoryTheory.Limits.prod.associator_inv
code: /-- The associator isomorphism for binary products. -/
@[simps]
def prod.associator [HasBinaryProducts C] (P Q R : C) : (P ⨯ Q) ⨯ R ≅ P ⨯ Q ⨯ R 
goal: (CategoryTheory.Limits.prod.associator P Q R).inv =
  CategoryTheory.Limits.prod.lift
    (CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
      (CategoryTheory.Limits.prod.snd ≫ CategoryTheory.Limits.prod.fst))
    (CategoryTheory.Limits.prod.snd ≫ CategoryTheory.Limits.prod.snd)

full_name: CategoryTheory.Limits.prod.pentagon
code: @[reassoc]
theorem prod.pentagon [HasBinaryProducts C] (W X Y Z : C) :
    prod.map (prod.associator W X Y).hom (𝟙 Z) ≫
        (prod.associator W (X ⨯ Y) Z).hom ≫ prod.map (𝟙 W) (prod.associator X Y Z).hom =
      (prod.associator (W ⨯ X) Y Z).hom ≫ (prod.associator W X (Y ⨯ Z)).hom 
goal: CategoryTheory.Limits.prod.map (CategoryTheory.Limits.prod.associator W X Y).hom (𝟙 Z) ≫
    (CategoryTheory.Limits.prod.associator W (X ⨯ Y) Z).hom ≫
      CategoryTheory.Limits.prod.map (𝟙 W) (CategoryTheory.Limits.prod.associator X Y Z).hom =
  (CategoryTheory.Limits.prod.associator (W ⨯ X) Y Z).hom ≫ (CategoryTheory.Limits.prod.associator W X (Y ⨯ Z)).hom

full_name: CategoryTheory.Limits.prod.associator_naturality
code: @[reassoc]
theorem prod.associator_naturality [HasBinaryProducts C] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C} (f₁ : X₁ ⟶ Y₁)
    (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃) :
    prod.map (prod.map f₁ f₂) f₃ ≫ (prod.associator Y₁ Y₂ Y₃).hom =
      (prod.associator X₁ X₂ X₃).hom ≫ prod.map f₁ (prod.map f₂ f₃) 
goal: CategoryTheory.Limits.prod.map (CategoryTheory.Limits.prod.map f₁ f₂) f₃ ≫
    (CategoryTheory.Limits.prod.associator Y₁ Y₂ Y₃).hom =
  (CategoryTheory.Limits.prod.associator X₁ X₂ X₃).hom ≫
    CategoryTheory.Limits.prod.map f₁ (CategoryTheory.Limits.prod.map f₂ f₃)

full_name: CategoryTheory.Limits.prod.leftUnitor
code: /-- The left unitor isomorphism for binary products with the terminal object. -/
@[simps]
def prod.leftUnitor (P : C) [HasBinaryProduct (⊤_ C) P] : (⊤_ C) ⨯ P ≅ P 
goal: (⊤_ C) ⨯ P ≅ P

full_name: CategoryTheory.Limits.prod.leftUnitor_inv
code: /-- The left unitor isomorphism for binary products with the terminal object. -/
@[simps]
def prod.leftUnitor (P : C) [HasBinaryProduct (⊤_ C) P] : (⊤_ C) ⨯ P ≅ P 
goal: (CategoryTheory.Limits.prod.leftUnitor P).inv =
  CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.terminal.from P) (𝟙 P)

full_name: CategoryTheory.Limits.prod.leftUnitor_hom
code: /-- The left unitor isomorphism for binary products with the terminal object. -/
@[simps]
def prod.leftUnitor (P : C) [HasBinaryProduct (⊤_ C) P] : (⊤_ C) ⨯ P ≅ P 
goal: (CategoryTheory.Limits.prod.leftUnitor P).hom = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.prod.rightUnitor_hom
code: /-- The right unitor isomorphism for binary products with the terminal object. -/
@[simps]
def prod.rightUnitor (P : C) [HasBinaryProduct P (⊤_ C)] : P ⨯ ⊤_ C ≅ P 
goal: (CategoryTheory.Limits.prod.rightUnitor P).hom = CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.prod.rightUnitor_inv
code: /-- The right unitor isomorphism for binary products with the terminal object. -/
@[simps]
def prod.rightUnitor (P : C) [HasBinaryProduct P (⊤_ C)] : P ⨯ ⊤_ C ≅ P 
goal: (CategoryTheory.Limits.prod.rightUnitor P).inv =
  CategoryTheory.Limits.prod.lift (𝟙 P) (CategoryTheory.Limits.terminal.from P)

full_name: CategoryTheory.Limits.prod.rightUnitor
code: /-- The right unitor isomorphism for binary products with the terminal object. -/
@[simps]
def prod.rightUnitor (P : C) [HasBinaryProduct P (⊤_ C)] : P ⨯ ⊤_ C ≅ P 
goal: P ⨯ ⊤_ C ≅ P

full_name: CategoryTheory.Limits.prod.leftUnitor_hom_naturality
code: @[reassoc]
theorem prod.leftUnitor_hom_naturality [HasBinaryProducts C] (f : X ⟶ Y) :
    prod.map (𝟙 _) f ≫ (prod.leftUnitor Y).hom = (prod.leftUnitor X).hom ≫ f 
goal: CategoryTheory.Limits.prod.map (𝟙 (⊤_ C)) f ≫ (CategoryTheory.Limits.prod.leftUnitor Y).hom =
  (CategoryTheory.Limits.prod.leftUnitor X).hom ≫ f

full_name: CategoryTheory.Limits.prod.leftUnitor_inv_naturality
code: @[reassoc]
theorem prod.leftUnitor_inv_naturality [HasBinaryProducts C] (f : X ⟶ Y) :
    (prod.leftUnitor X).inv ≫ prod.map (𝟙 _) f = f ≫ (prod.leftUnitor Y).inv 
goal: (CategoryTheory.Limits.prod.leftUnitor X).inv ≫ CategoryTheory.Limits.prod.map (𝟙 (⊤_ C)) f =
  f ≫ (CategoryTheory.Limits.prod.leftUnitor Y).inv

full_name: CategoryTheory.Limits.prod.rightUnitor_hom_naturality
code: @[reassoc]
theorem prod.rightUnitor_hom_naturality [HasBinaryProducts C] (f : X ⟶ Y) :
    prod.map f (𝟙 _) ≫ (prod.rightUnitor Y).hom = (prod.rightUnitor X).hom ≫ f 
goal: CategoryTheory.Limits.prod.map f (𝟙 (⊤_ C)) ≫ (CategoryTheory.Limits.prod.rightUnitor Y).hom =
  (CategoryTheory.Limits.prod.rightUnitor X).hom ≫ f

full_name: CategoryTheory.Limits.prod_rightUnitor_inv_naturality
code: @[reassoc]
theorem prod_rightUnitor_inv_naturality [HasBinaryProducts C] (f : X ⟶ Y) :
    (prod.rightUnitor X).inv ≫ prod.map f (𝟙 _) = f ≫ (prod.rightUnitor Y).inv 
goal: (CategoryTheory.Limits.prod.rightUnitor X).inv ≫ CategoryTheory.Limits.prod.map f (𝟙 (⊤_ C)) =
  f ≫ (CategoryTheory.Limits.prod.rightUnitor Y).inv

full_name: CategoryTheory.Limits.prod.triangle
code: theorem prod.triangle [HasBinaryProducts C] (X Y : C) :
    (prod.associator X (⊤_ C) Y).hom ≫ prod.map (𝟙 X) (prod.leftUnitor Y).hom =
      prod.map (prod.rightUnitor X).hom (𝟙 Y) 
goal: (CategoryTheory.Limits.prod.associator X (⊤_ C) Y).hom ≫
    CategoryTheory.Limits.prod.map (𝟙 X) (CategoryTheory.Limits.prod.leftUnitor Y).hom =
  CategoryTheory.Limits.prod.map (CategoryTheory.Limits.prod.rightUnitor X).hom (𝟙 Y)

full_name: CategoryTheory.Limits.coprod.braiding
code: /-- The braiding isomorphism which swaps a binary coproduct. -/
@[simps]
def coprod.braiding (P Q : C) : P ⨿ Q ≅ Q ⨿ P 
goal: P ⨿ Q ≅ Q ⨿ P

full_name: CategoryTheory.Limits.coprod.braiding_hom
code: /-- The braiding isomorphism which swaps a binary coproduct. -/
@[simps]
def coprod.braiding (P Q : C) : P ⨿ Q ≅ Q ⨿ P 
goal: (CategoryTheory.Limits.coprod.braiding P Q).hom =
  CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.coprod.braiding_inv
code: /-- The braiding isomorphism which swaps a binary coproduct. -/
@[simps]
def coprod.braiding (P Q : C) : P ⨿ Q ≅ Q ⨿ P 
goal: (CategoryTheory.Limits.coprod.braiding P Q).inv =
  CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.coprod.symmetry'
code: @[reassoc]
theorem coprod.symmetry' (P Q : C) :
    coprod.desc coprod.inr coprod.inl ≫ coprod.desc coprod.inr coprod.inl = 𝟙 (P ⨿ Q) 
goal: CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl ≫
    CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl =
  𝟙 (P ⨿ Q)

full_name: CategoryTheory.Limits.coprod.symmetry
code: /-- The braiding isomorphism is symmetric. -/
theorem coprod.symmetry (P Q : C) : (coprod.braiding P Q).hom ≫ (coprod.braiding Q P).hom = 𝟙 _ 
goal: (CategoryTheory.Limits.coprod.braiding P Q).hom ≫ (CategoryTheory.Limits.coprod.braiding Q P).hom = 𝟙 (P ⨿ Q)

full_name: CategoryTheory.Limits.coprod.associator
code: /-- The associator isomorphism for binary coproducts. -/
@[simps]
def coprod.associator (P Q R : C) : (P ⨿ Q) ⨿ R ≅ P ⨿ Q ⨿ R 
goal: (P ⨿ Q) ⨿ R ≅ P ⨿ Q ⨿ R

full_name: CategoryTheory.Limits.coprod.associator_hom
code: /-- The associator isomorphism for binary coproducts. -/
@[simps]
def coprod.associator (P Q R : C) : (P ⨿ Q) ⨿ R ≅ P ⨿ Q ⨿ R 
goal: (CategoryTheory.Limits.coprod.associator P Q R).hom =
  CategoryTheory.Limits.coprod.desc
    (CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inl
      (CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.Limits.coprod.inr))
    (CategoryTheory.Limits.coprod.inr ≫ CategoryTheory.Limits.coprod.inr)

full_name: CategoryTheory.Limits.coprod.associator_inv
code: /-- The associator isomorphism for binary coproducts. -/
@[simps]
def coprod.associator (P Q R : C) : (P ⨿ Q) ⨿ R ≅ P ⨿ Q ⨿ R 
goal: (CategoryTheory.Limits.coprod.associator P Q R).inv =
  CategoryTheory.Limits.coprod.desc (CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.Limits.coprod.inl)
    (CategoryTheory.Limits.coprod.desc (CategoryTheory.Limits.coprod.inr ≫ CategoryTheory.Limits.coprod.inl)
      CategoryTheory.Limits.coprod.inr)

full_name: CategoryTheory.Limits.coprod.pentagon
code: theorem coprod.pentagon (W X Y Z : C) :
    coprod.map (coprod.associator W X Y).hom (𝟙 Z) ≫
        (coprod.associator W (X ⨿ Y) Z).hom ≫ coprod.map (𝟙 W) (coprod.associator X Y Z).hom =
      (coprod.associator (W ⨿ X) Y Z).hom ≫ (coprod.associator W X (Y ⨿ Z)).hom 
goal: CategoryTheory.Limits.coprod.map (CategoryTheory.Limits.coprod.associator W X Y).hom (𝟙 Z) ≫
    (CategoryTheory.Limits.coprod.associator W (X ⨿ Y) Z).hom ≫
      CategoryTheory.Limits.coprod.map (𝟙 W) (CategoryTheory.Limits.coprod.associator X Y Z).hom =
  (CategoryTheory.Limits.coprod.associator (W ⨿ X) Y Z).hom ≫ (CategoryTheory.Limits.coprod.associator W X (Y ⨿ Z)).hom

full_name: CategoryTheory.Limits.coprod.associator_naturality
code: theorem coprod.associator_naturality {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
    (f₃ : X₃ ⟶ Y₃) :
    coprod.map (coprod.map f₁ f₂) f₃ ≫ (coprod.associator Y₁ Y₂ Y₃).hom =
      (coprod.associator X₁ X₂ X₃).hom ≫ coprod.map f₁ (coprod.map f₂ f₃) 
goal: CategoryTheory.Limits.coprod.map (CategoryTheory.Limits.coprod.map f₁ f₂) f₃ ≫
    (CategoryTheory.Limits.coprod.associator Y₁ Y₂ Y₃).hom =
  (CategoryTheory.Limits.coprod.associator X₁ X₂ X₃).hom ≫
    CategoryTheory.Limits.coprod.map f₁ (CategoryTheory.Limits.coprod.map f₂ f₃)

full_name: CategoryTheory.Limits.coprod.leftUnitor_inv
code: /-- The left unitor isomorphism for binary coproducts with the initial object. -/
@[simps]
def coprod.leftUnitor (P : C) : (⊥_ C) ⨿ P ≅ P 
goal: (CategoryTheory.Limits.coprod.leftUnitor P).inv = CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.coprod.leftUnitor_hom
code: /-- The left unitor isomorphism for binary coproducts with the initial object. -/
@[simps]
def coprod.leftUnitor (P : C) : (⊥_ C) ⨿ P ≅ P 
goal: (CategoryTheory.Limits.coprod.leftUnitor P).hom =
  CategoryTheory.Limits.coprod.desc (CategoryTheory.Limits.initial.to P) (𝟙 P)

full_name: CategoryTheory.Limits.coprod.leftUnitor
code: /-- The left unitor isomorphism for binary coproducts with the initial object. -/
@[simps]
def coprod.leftUnitor (P : C) : (⊥_ C) ⨿ P ≅ P 
goal: (⊥_ C) ⨿ P ≅ P

full_name: CategoryTheory.Limits.coprod.rightUnitor_hom
code: /-- The right unitor isomorphism for binary coproducts with the initial object. -/
@[simps]
def coprod.rightUnitor (P : C) : P ⨿ ⊥_ C ≅ P 
goal: (CategoryTheory.Limits.coprod.rightUnitor P).hom =
  CategoryTheory.Limits.coprod.desc (𝟙 P) (CategoryTheory.Limits.initial.to P)

full_name: CategoryTheory.Limits.coprod.rightUnitor_inv
code: /-- The right unitor isomorphism for binary coproducts with the initial object. -/
@[simps]
def coprod.rightUnitor (P : C) : P ⨿ ⊥_ C ≅ P 
goal: (CategoryTheory.Limits.coprod.rightUnitor P).inv = CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.coprod.rightUnitor
code: /-- The right unitor isomorphism for binary coproducts with the initial object. -/
@[simps]
def coprod.rightUnitor (P : C) : P ⨿ ⊥_ C ≅ P 
goal: P ⨿ ⊥_ C ≅ P

full_name: CategoryTheory.Limits.coprod.triangle
code: theorem coprod.triangle (X Y : C) :
    (coprod.associator X (⊥_ C) Y).hom ≫ coprod.map (𝟙 X) (coprod.leftUnitor Y).hom =
      coprod.map (coprod.rightUnitor X).hom (𝟙 Y) 
goal: (CategoryTheory.Limits.coprod.associator X (⊥_ C) Y).hom ≫
    CategoryTheory.Limits.coprod.map (𝟙 X) (CategoryTheory.Limits.coprod.leftUnitor Y).hom =
  CategoryTheory.Limits.coprod.map (CategoryTheory.Limits.coprod.rightUnitor X).hom (𝟙 Y)

full_name: CategoryTheory.Limits.prod.functor_map_app
code: /-- The binary product functor. -/
@[simps]
def prod.functor : C ⥤ C ⥤ C 
goal: ∀ {X Y : C} (f : X ⟶ Y) (T : C),
  (CategoryTheory.Limits.prod.functor.map f).app T = CategoryTheory.Limits.prod.map f (𝟙 T)

full_name: CategoryTheory.Limits.prod.functor_obj_obj
code: /-- The binary product functor. -/
@[simps]
def prod.functor : C ⥤ C ⥤ C 
goal: (CategoryTheory.Limits.prod.functor.obj X).obj Y = (X ⨯ Y)

full_name: CategoryTheory.Limits.prod.functor
code: /-- The binary product functor. -/
@[simps]
def prod.functor : C ⥤ C ⥤ C 
goal: C ⥤ C ⥤ C

full_name: CategoryTheory.Limits.prod.functor_obj_map
code: /-- The binary product functor. -/
@[simps]
def prod.functor : C ⥤ C ⥤ C 
goal: (CategoryTheory.Limits.prod.functor.obj X).map g = CategoryTheory.Limits.prod.map (𝟙 X) g

full_name: CategoryTheory.Limits.prod.functorLeftComp
code: /-- The product functor can be decomposed. -/
def prod.functorLeftComp (X Y : C) :
    prod.functor.obj (X ⨯ Y) ≅ prod.functor.obj Y ⋙ prod.functor.obj X 
goal: CategoryTheory.Limits.prod.functor.obj (X ⨯ Y) ≅
  CategoryTheory.Limits.prod.functor.obj Y ⋙ CategoryTheory.Limits.prod.functor.obj X

full_name: CategoryTheory.Limits.coprod.functor_obj_map
code: /-- The binary coproduct functor. -/
@[simps]
def coprod.functor : C ⥤ C ⥤ C 
goal: (CategoryTheory.Limits.coprod.functor.obj X).map g = CategoryTheory.Limits.coprod.map (𝟙 X) g

full_name: CategoryTheory.Limits.coprod.functor_obj_obj
code: /-- The binary coproduct functor. -/
@[simps]
def coprod.functor : C ⥤ C ⥤ C 
goal: (CategoryTheory.Limits.coprod.functor.obj X).obj Y = (X ⨿ Y)

full_name: CategoryTheory.Limits.coprod.functor_map_app
code: /-- The binary coproduct functor. -/
@[simps]
def coprod.functor : C ⥤ C ⥤ C 
goal: ∀ {X Y : C} (f : X ⟶ Y) (T : C),
  (CategoryTheory.Limits.coprod.functor.map f).app T = CategoryTheory.Limits.coprod.map f (𝟙 T)

full_name: CategoryTheory.Limits.coprod.functor
code: /-- The binary coproduct functor. -/
@[simps]
def coprod.functor : C ⥤ C ⥤ C 
goal: C ⥤ C ⥤ C

full_name: CategoryTheory.Limits.coprod.functorLeftComp
code: /-- The coproduct functor can be decomposed. -/
def coprod.functorLeftComp (X Y : C) :
    coprod.functor.obj (X ⨿ Y) ≅ coprod.functor.obj Y ⋙ coprod.functor.obj X 
goal: CategoryTheory.Limits.coprod.functor.obj (X ⨿ Y) ≅
  CategoryTheory.Limits.coprod.functor.obj Y ⋙ CategoryTheory.Limits.coprod.functor.obj X

full_name: CategoryTheory.Limits.prodComparison
code: /-- The product comparison morphism.

In `CategoryTheory/Limits/Preserves` we show this is always an iso iff F preserves binary products.
-/
def prodComparison (F : C ⥤ D) (A B : C) [HasBinaryProduct A B]
    [HasBinaryProduct (F.obj A) (F.obj B)] : F.obj (A ⨯ B) ⟶ F.obj A ⨯ F.obj B 
goal: F.obj (A ⨯ B) ⟶ F.obj A ⨯ F.obj B

full_name: CategoryTheory.Limits.prodComparison_fst
code: @[reassoc (attr := simp)]
theorem prodComparison_fst : prodComparison F A B ≫ prod.fst = F.map prod.fst 
goal: CategoryTheory.Limits.prodComparison F A B ≫ CategoryTheory.Limits.prod.fst = F.map CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.prodComparison_snd
code: @[reassoc (attr := simp)]
theorem prodComparison_snd : prodComparison F A B ≫ prod.snd = F.map prod.snd 
goal: CategoryTheory.Limits.prodComparison F A B ≫ CategoryTheory.Limits.prod.snd = F.map CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.prodComparison_natural
code: /-- Naturality of the `prodComparison` morphism in both arguments. -/
@[reassoc]
theorem prodComparison_natural (f : A ⟶ A') (g : B ⟶ B') :
    F.map (prod.map f g) ≫ prodComparison F A' B' =
      prodComparison F A B ≫ prod.map (F.map f) (F.map g) 
goal: F.map (CategoryTheory.Limits.prod.map f g) ≫ CategoryTheory.Limits.prodComparison F A' B' =
  CategoryTheory.Limits.prodComparison F A B ≫ CategoryTheory.Limits.prod.map (F.map f) (F.map g)

full_name: CategoryTheory.Limits.prodComparisonNatTrans_app
code: /-- The product comparison morphism from `F(A ⨯ -)` to `FA ⨯ F-`, whose components are given by
`prodComparison`.
-/
@[simps]
def prodComparisonNatTrans [HasBinaryProducts C] [HasBinaryProducts D] (F : C ⥤ D) (A : C) :
    prod.functor.obj A ⋙ F ⟶ F ⋙ prod.functor.obj (F.obj A) 
goal: (CategoryTheory.Limits.prodComparisonNatTrans F A).app B = CategoryTheory.Limits.prodComparison F A B

full_name: CategoryTheory.Limits.prodComparisonNatTrans
code: /-- The product comparison morphism from `F(A ⨯ -)` to `FA ⨯ F-`, whose components are given by
`prodComparison`.
-/
@[simps]
def prodComparisonNatTrans [HasBinaryProducts C] [HasBinaryProducts D] (F : C ⥤ D) (A : C) :
    prod.functor.obj A ⋙ F ⟶ F ⋙ prod.functor.obj (F.obj A) 
goal: CategoryTheory.Limits.prod.functor.obj A ⋙ F ⟶ F ⋙ CategoryTheory.Limits.prod.functor.obj (F.obj A)

full_name: CategoryTheory.Limits.inv_prodComparison_map_fst
code: @[reassoc]
theorem inv_prodComparison_map_fst [IsIso (prodComparison F A B)] :
    inv (prodComparison F A B) ≫ F.map prod.fst = prod.fst 
goal: CategoryTheory.inv (CategoryTheory.Limits.prodComparison F A B) ≫ F.map CategoryTheory.Limits.prod.fst =
  CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.inv_prodComparison_map_snd
code: @[reassoc]
theorem inv_prodComparison_map_snd [IsIso (prodComparison F A B)] :
    inv (prodComparison F A B) ≫ F.map prod.snd = prod.snd 
goal: CategoryTheory.inv (CategoryTheory.Limits.prodComparison F A B) ≫ F.map CategoryTheory.Limits.prod.snd =
  CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.prodComparison_inv_natural
code: /-- If the product comparison morphism is an iso, its inverse is natural. -/
@[reassoc]
theorem prodComparison_inv_natural (f : A ⟶ A') (g : B ⟶ B') [IsIso (prodComparison F A B)]
    [IsIso (prodComparison F A' B')] :
    inv (prodComparison F A B) ≫ F.map (prod.map f g) =
      prod.map (F.map f) (F.map g) ≫ inv (prodComparison F A' B') 
goal: CategoryTheory.inv (CategoryTheory.Limits.prodComparison F A B) ≫ F.map (CategoryTheory.Limits.prod.map f g) =
  CategoryTheory.Limits.prod.map (F.map f) (F.map g) ≫ CategoryTheory.inv (CategoryTheory.Limits.prodComparison F A' B')

full_name: CategoryTheory.Limits.prodComparisonNatIso_hom
code: /-- The natural isomorphism `F(A ⨯ -) ≅ FA ⨯ F-`, provided each `prodComparison F A B` is an
isomorphism (as `B` changes).
-/
-- @[simps (config := { rhsMd := semireducible })] -- Porting note: no config for semireducible
@[simps]
def prodComparisonNatIso [HasBinaryProducts C] [HasBinaryProducts D] (A : C)
    [∀ B, IsIso (prodComparison F A B)] :
    prod.functor.obj A ⋙ F ≅ F ⋙ prod.functor.obj (F.obj A) 
goal: (CategoryTheory.Limits.prodComparisonNatIso F A).hom = CategoryTheory.Limits.prodComparisonNatTrans F A

full_name: CategoryTheory.Limits.prodComparisonNatIso_inv
code: /-- The natural isomorphism `F(A ⨯ -) ≅ FA ⨯ F-`, provided each `prodComparison F A B` is an
isomorphism (as `B` changes).
-/
-- @[simps (config := { rhsMd := semireducible })] -- Porting note: no config for semireducible
@[simps]
def prodComparisonNatIso [HasBinaryProducts C] [HasBinaryProducts D] (A : C)
    [∀ B, IsIso (prodComparison F A B)] :
    prod.functor.obj A ⋙ F ≅ F ⋙ prod.functor.obj (F.obj A) 
goal: (CategoryTheory.Limits.prodComparisonNatIso F A).inv =
  (CategoryTheory.asIso { app := fun B => CategoryTheory.Limits.prodComparison F A B, naturality := ⋯ }).inv

full_name: CategoryTheory.Limits.prodComparisonNatIso
code: /-- The natural isomorphism `F(A ⨯ -) ≅ FA ⨯ F-`, provided each `prodComparison F A B` is an
isomorphism (as `B` changes).
-/
-- @[simps (config := { rhsMd := semireducible })] -- Porting note: no config for semireducible
@[simps]
def prodComparisonNatIso [HasBinaryProducts C] [HasBinaryProducts D] (A : C)
    [∀ B, IsIso (prodComparison F A B)] :
    prod.functor.obj A ⋙ F ≅ F ⋙ prod.functor.obj (F.obj A) 
goal: CategoryTheory.Limits.prod.functor.obj A ⋙ F ≅ F ⋙ CategoryTheory.Limits.prod.functor.obj (F.obj A)

full_name: CategoryTheory.Limits.prodComparison_comp
code: theorem prodComparison_comp :
    prodComparison (F ⋙ G) A B =
      G.map (prodComparison F A B) ≫ prodComparison G (F.obj A) (F.obj B) 
goal: CategoryTheory.Limits.prodComparison (F ⋙ G) A B =
  G.map (CategoryTheory.Limits.prodComparison F A B) ≫ CategoryTheory.Limits.prodComparison G (F.obj A) (F.obj B)

full_name: CategoryTheory.Limits.coprodComparison
code: /-- The coproduct comparison morphism.

In `CategoryTheory/Limits/Preserves` we show
this is always an iso iff F preserves binary coproducts.
-/
def coprodComparison (F : C ⥤ D) (A B : C) [HasBinaryCoproduct A B]
    [HasBinaryCoproduct (F.obj A) (F.obj B)] : F.obj A ⨿ F.obj B ⟶ F.obj (A ⨿ B) 
goal: F.obj A ⨿ F.obj B ⟶ F.obj (A ⨿ B)

full_name: CategoryTheory.Limits.coprodComparison_inl
code: @[reassoc (attr := simp)]
theorem coprodComparison_inl : coprod.inl ≫ coprodComparison F A B = F.map coprod.inl 
goal: CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.Limits.coprodComparison F A B = F.map CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.coprodComparison_inr
code: @[reassoc (attr := simp)]
theorem coprodComparison_inr : coprod.inr ≫ coprodComparison F A B = F.map coprod.inr 
goal: CategoryTheory.Limits.coprod.inr ≫ CategoryTheory.Limits.coprodComparison F A B = F.map CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.coprodComparison_natural
code: /-- Naturality of the coprod_comparison morphism in both arguments. -/
@[reassoc]
theorem coprodComparison_natural (f : A ⟶ A') (g : B ⟶ B') :
    coprodComparison F A B ≫ F.map (coprod.map f g) =
      coprod.map (F.map f) (F.map g) ≫ coprodComparison F A' B' 
goal: CategoryTheory.Limits.coprodComparison F A B ≫ F.map (CategoryTheory.Limits.coprod.map f g) =
  CategoryTheory.Limits.coprod.map (F.map f) (F.map g) ≫ CategoryTheory.Limits.coprodComparison F A' B'

full_name: CategoryTheory.Limits.coprodComparisonNatTrans_app
code: /-- The coproduct comparison morphism from `FA ⨿ F-` to `F(A ⨿ -)`, whose components are given by
`coprodComparison`.
-/
@[simps]
def coprodComparisonNatTrans [HasBinaryCoproducts C] [HasBinaryCoproducts D] (F : C ⥤ D) (A : C) :
    F ⋙ coprod.functor.obj (F.obj A) ⟶ coprod.functor.obj A ⋙ F 
goal: (CategoryTheory.Limits.coprodComparisonNatTrans F A).app B = CategoryTheory.Limits.coprodComparison F A B

full_name: CategoryTheory.Limits.coprodComparisonNatTrans
code: /-- The coproduct comparison morphism from `FA ⨿ F-` to `F(A ⨿ -)`, whose components are given by
`coprodComparison`.
-/
@[simps]
def coprodComparisonNatTrans [HasBinaryCoproducts C] [HasBinaryCoproducts D] (F : C ⥤ D) (A : C) :
    F ⋙ coprod.functor.obj (F.obj A) ⟶ coprod.functor.obj A ⋙ F 
goal: F ⋙ CategoryTheory.Limits.coprod.functor.obj (F.obj A) ⟶ CategoryTheory.Limits.coprod.functor.obj A ⋙ F

full_name: CategoryTheory.Limits.map_inl_inv_coprodComparison
code: @[reassoc]
theorem map_inl_inv_coprodComparison [IsIso (coprodComparison F A B)] :
    F.map coprod.inl ≫ inv (coprodComparison F A B) = coprod.inl 
goal: F.map CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.inv (CategoryTheory.Limits.coprodComparison F A B) =
  CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.map_inr_inv_coprodComparison
code: @[reassoc]
theorem map_inr_inv_coprodComparison [IsIso (coprodComparison F A B)] :
    F.map coprod.inr ≫ inv (coprodComparison F A B) = coprod.inr 
goal: F.map CategoryTheory.Limits.coprod.inr ≫ CategoryTheory.inv (CategoryTheory.Limits.coprodComparison F A B) =
  CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.coprodComparison_inv_natural
code: /-- If the coproduct comparison morphism is an iso, its inverse is natural. -/
@[reassoc]
theorem coprodComparison_inv_natural (f : A ⟶ A') (g : B ⟶ B') [IsIso (coprodComparison F A B)]
    [IsIso (coprodComparison F A' B')] :
    inv (coprodComparison F A B) ≫ coprod.map (F.map f) (F.map g) =
      F.map (coprod.map f g) ≫ inv (coprodComparison F A' B') 
goal: CategoryTheory.inv (CategoryTheory.Limits.coprodComparison F A B) ≫
    CategoryTheory.Limits.coprod.map (F.map f) (F.map g) =
  F.map (CategoryTheory.Limits.coprod.map f g) ≫ CategoryTheory.inv (CategoryTheory.Limits.coprodComparison F A' B')

full_name: CategoryTheory.Limits.coprodComparisonNatIso_inv
code: /-- The natural isomorphism `FA ⨿ F- ≅ F(A ⨿ -)`, provided each `coprodComparison F A B` is an
isomorphism (as `B` changes).
-/
-- @[simps (config := { rhsMd := semireducible })] -- Porting note: no config for semireducible
@[simps]
def coprodComparisonNatIso [HasBinaryCoproducts C] [HasBinaryCoproducts D] (A : C)
    [∀ B, IsIso (coprodComparison F A B)] :
    F ⋙ coprod.functor.obj (F.obj A) ≅ coprod.functor.obj A ⋙ F 
goal: (CategoryTheory.Limits.coprodComparisonNatIso F A).inv =
  (CategoryTheory.asIso { app := fun B => CategoryTheory.Limits.coprodComparison F A B, naturality := ⋯ }).inv

full_name: CategoryTheory.Limits.coprodComparisonNatIso_hom
code: /-- The natural isomorphism `FA ⨿ F- ≅ F(A ⨿ -)`, provided each `coprodComparison F A B` is an
isomorphism (as `B` changes).
-/
-- @[simps (config := { rhsMd := semireducible })] -- Porting note: no config for semireducible
@[simps]
def coprodComparisonNatIso [HasBinaryCoproducts C] [HasBinaryCoproducts D] (A : C)
    [∀ B, IsIso (coprodComparison F A B)] :
    F ⋙ coprod.functor.obj (F.obj A) ≅ coprod.functor.obj A ⋙ F 
goal: (CategoryTheory.Limits.coprodComparisonNatIso F A).hom = CategoryTheory.Limits.coprodComparisonNatTrans F A

full_name: CategoryTheory.Limits.coprodComparisonNatIso
code: /-- The natural isomorphism `FA ⨿ F- ≅ F(A ⨿ -)`, provided each `coprodComparison F A B` is an
isomorphism (as `B` changes).
-/
-- @[simps (config := { rhsMd := semireducible })] -- Porting note: no config for semireducible
@[simps]
def coprodComparisonNatIso [HasBinaryCoproducts C] [HasBinaryCoproducts D] (A : C)
    [∀ B, IsIso (coprodComparison F A B)] :
    F ⋙ coprod.functor.obj (F.obj A) ≅ coprod.functor.obj A ⋙ F 
goal: F ⋙ CategoryTheory.Limits.coprod.functor.obj (F.obj A) ≅ CategoryTheory.Limits.coprod.functor.obj A ⋙ F

full_name: CategoryTheory.Over.coprodObj
code: /-- Auxiliary definition for `Over.coprod`. -/
@[simps]
def Over.coprodObj [HasBinaryCoproducts C] {A : C} : Over A → Over A ⥤ Over A 
goal: CategoryTheory.Over A → CategoryTheory.Over A ⥤ CategoryTheory.Over A

full_name: CategoryTheory.Over.coprodObj_map
code: /-- Auxiliary definition for `Over.coprod`. -/
@[simps]
def Over.coprodObj [HasBinaryCoproducts C] {A : C} : Over A → Over A ⥤ Over A 
goal: ∀ (a : CategoryTheory.Over A) {X Y : CategoryTheory.Over A} (k : X ⟶ Y),
  a.coprodObj.map k = CategoryTheory.Over.homMk (CategoryTheory.Limits.coprod.map (𝟙 ((𝟭 C).obj a.left)) k.left) ⋯

full_name: CategoryTheory.Over.coprodObj_obj
code: /-- Auxiliary definition for `Over.coprod`. -/
@[simps]
def Over.coprodObj [HasBinaryCoproducts C] {A : C} : Over A → Over A ⥤ Over A 
goal: ∀ (a g : CategoryTheory.Over A),
  a.coprodObj.obj g = CategoryTheory.Over.mk (CategoryTheory.Limits.coprod.desc a.hom g.hom)

full_name: CategoryTheory.Over.coprod_map_app
code: /-- A category with binary coproducts has a functorial `sup` operation on over categories. -/
@[simps]
def Over.coprod [HasBinaryCoproducts C] {A : C} : Over A ⥤ Over A ⥤ Over A 
goal: ∀ {X Y : CategoryTheory.Over A} (k : X ⟶ Y) (g : CategoryTheory.Over A),
  (CategoryTheory.Over.coprod.map k).app g =
    CategoryTheory.Over.homMk (CategoryTheory.Limits.coprod.map k.left (𝟙 ((𝟭 C).obj g.left))) ⋯

full_name: CategoryTheory.Over.coprod_obj
code: /-- A category with binary coproducts has a functorial `sup` operation on over categories. -/
@[simps]
def Over.coprod [HasBinaryCoproducts C] {A : C} : Over A ⥤ Over A ⥤ Over A 
goal: CategoryTheory.Over.coprod.obj f = f.coprodObj

full_name: CategoryTheory.Over.coprod
code: /-- A category with binary coproducts has a functorial `sup` operation on over categories. -/
@[simps]
def Over.coprod [HasBinaryCoproducts C] {A : C} : Over A ⥤ Over A ⥤ Over A 
goal: CategoryTheory.Over A ⥤ CategoryTheory.Over A ⥤ CategoryTheory.Over A