ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.mapPair_left
@[simp]
theorem mapPair_left : (mapPair f g).app ⟨left⟩ = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C} (f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.left }) (g : F.obj { as := CategoryTheory.Limits.WalkingPair.right } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.right })
Goal: (CategoryTheory.Limits.mapPair f g).app { as := CategoryTheory.Limits.WalkingPair.left } = f
-- CategoryTheory.Limits.mapPair_right
@[simp]
theorem mapPair_right : (mapPair f g).app ⟨right⟩ = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C} (f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.left }) (g : F.obj { as := CategoryTheory.Limits.WalkingPair.right } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.right })
Goal: (CategoryTheory.Limits.mapPair f g).app { as := CategoryTheory.Limits.WalkingPair.right } = g
-- CategoryTheory.Limits.mapPairIso_hom_app
@[simps!]
def mapPairIso (f : F.obj ⟨left⟩ ≅ G.obj ⟨left⟩) (g : F.obj ⟨right⟩ ≅ G.obj ⟨right⟩) : F ≅ G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C} (f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ≅ G.obj { as := CategoryTheory.Limits.WalkingPair.left }) (g : F.obj { as := CategoryTheory.Limits.WalkingPair.right } ≅ G.obj { as := CategoryTheory.Limits.WalkingPair.right }) (X : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)
Goal: (CategoryTheory.Limits.mapPairIso f g).hom.app X = (CategoryTheory.Limits.WalkingPair.rec f g X.as).hom
-- CategoryTheory.Limits.mapPairIso_inv_app
@[simps!]
def mapPairIso (f : F.obj ⟨left⟩ ≅ G.obj ⟨left⟩) (g : F.obj ⟨right⟩ ≅ G.obj ⟨right⟩) : F ≅ G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C} (f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ≅ G.obj { as := CategoryTheory.Limits.WalkingPair.left }) (g : F.obj { as := CategoryTheory.Limits.WalkingPair.right } ≅ G.obj { as := CategoryTheory.Limits.WalkingPair.right }) (X : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)
Goal: (CategoryTheory.Limits.mapPairIso f g).inv.app X = (CategoryTheory.Limits.WalkingPair.rec f g X.as).inv
-- CategoryTheory.Limits.diagramIsoPair_hom_app
@[simps!]
def diagramIsoPair (F : Discrete WalkingPair ⥤ C) :
    F ≅ pair (F.obj ⟨WalkingPair.left⟩) (F.obj ⟨WalkingPair.right⟩) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C) (X : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)
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
-- CategoryTheory.Limits.diagramIsoPair_inv_app
@[simps!]
def diagramIsoPair (F : Discrete WalkingPair ⥤ C) :
    F ≅ pair (F.obj ⟨WalkingPair.left⟩) (F.obj ⟨WalkingPair.right⟩) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair ⥤ C) (X : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)
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
-- CategoryTheory.Limits.BinaryFan.π_app_left
@[simp]
theorem BinaryFan.π_app_left {X Y : C} (s : BinaryFan X Y) : s.π.app ⟨WalkingPair.left⟩ = s.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (s : CategoryTheory.Limits.BinaryFan X Y)
Goal: s.π.app { as := CategoryTheory.Limits.WalkingPair.left } = s.fst
-- CategoryTheory.Limits.BinaryFan.π_app_right
@[simp]
theorem BinaryFan.π_app_right {X Y : C} (s : BinaryFan X Y) : s.π.app ⟨WalkingPair.right⟩ = s.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (s : CategoryTheory.Limits.BinaryFan X Y)
Goal: s.π.app { as := CategoryTheory.Limits.WalkingPair.right } = s.snd
-- CategoryTheory.Limits.BinaryFan.IsLimit.hom_ext
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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y} (h : CategoryTheory.Limits.IsLimit s) {f g : W ⟶ s.pt} (h₁ : f ≫ s.fst = g ≫ s.fst) (h₂ : f ≫ s.snd = g ≫ s.snd)
Goal: f = g
-- CategoryTheory.Limits.BinaryCofan.ι_app_left
@[simp]
theorem BinaryCofan.ι_app_left {X Y : C} (s : BinaryCofan X Y) :
    s.ι.app ⟨WalkingPair.left⟩ = s.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (s : CategoryTheory.Limits.BinaryCofan X Y)
Goal: s.ι.app { as := CategoryTheory.Limits.WalkingPair.left } = s.inl
-- CategoryTheory.Limits.BinaryCofan.ι_app_right
@[simp]
theorem BinaryCofan.ι_app_right {X Y : C} (s : BinaryCofan X Y) :
    s.ι.app ⟨WalkingPair.right⟩ = s.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (s : CategoryTheory.Limits.BinaryCofan X Y)
Goal: s.ι.app { as := CategoryTheory.Limits.WalkingPair.right } = s.inr
-- CategoryTheory.Limits.BinaryCofan.IsColimit.hom_ext
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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryCofan X Y} (h : CategoryTheory.Limits.IsColimit s) {f g : s.pt ⟶ W} (h₁ : s.inl ≫ f = s.inl ≫ g) (h₂ : s.inr ≫ f = s.inr ≫ g)
Goal: f = g
-- CategoryTheory.Limits.BinaryFan.mk_pt
@[simps pt]
def BinaryFan.mk {P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y) : BinaryFan X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y)
Goal: (CategoryTheory.Limits.BinaryFan.mk π₁ π₂).pt = P
-- CategoryTheory.Limits.BinaryCofan.mk_pt
@[simps pt]
def BinaryCofan.mk {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : BinaryCofan X Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P)
Goal: (CategoryTheory.Limits.BinaryCofan.mk ι₁ ι₂).pt = P
-- CategoryTheory.Limits.BinaryFan.mk_fst
@[simp]
theorem BinaryFan.mk_fst {P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y) : (BinaryFan.mk π₁ π₂).fst = π₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y)
Goal: (CategoryTheory.Limits.BinaryFan.mk π₁ π₂).fst = π₁
-- CategoryTheory.Limits.BinaryFan.mk_snd
@[simp]
theorem BinaryFan.mk_snd {P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y) : (BinaryFan.mk π₁ π₂).snd = π₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y P : C} (π₁ : P ⟶ X) (π₂ : P ⟶ Y)
Goal: (CategoryTheory.Limits.BinaryFan.mk π₁ π₂).snd = π₂
-- CategoryTheory.Limits.BinaryCofan.mk_inl
@[simp]
theorem BinaryCofan.mk_inl {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : (BinaryCofan.mk ι₁ ι₂).inl = ι₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P)
Goal: (CategoryTheory.Limits.BinaryCofan.mk ι₁ ι₂).inl = ι₁
-- CategoryTheory.Limits.BinaryCofan.mk_inr
@[simp]
theorem BinaryCofan.mk_inr {P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P) : (BinaryCofan.mk ι₁ ι₂).inr = ι₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y P : C} (ι₁ : X ⟶ P) (ι₂ : Y ⟶ P)
Goal: (CategoryTheory.Limits.BinaryCofan.mk ι₁ ι₂).inr = ι₂
-- CategoryTheory.Limits.BinaryFan.IsLimit.lift'_coe
@[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 } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y} (h : CategoryTheory.Limits.IsLimit s) (f : W ⟶ X) (g : W ⟶ Y)
Goal: ↑(CategoryTheory.Limits.BinaryFan.IsLimit.lift' h f g) = h.lift (CategoryTheory.Limits.BinaryFan.mk f g)
-- CategoryTheory.Limits.BinaryCofan.IsColimit.desc'_coe
@[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 } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} {s : CategoryTheory.Limits.BinaryCofan X Y} (h : CategoryTheory.Limits.IsColimit s) (f : X ⟶ W) (g : Y ⟶ W)
Goal: ↑(CategoryTheory.Limits.BinaryCofan.IsColimit.desc' h f g) = h.desc (CategoryTheory.Limits.BinaryCofan.mk f g)
-- CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_fst
theorem BinaryFan.isLimit_iff_isIso_fst {X Y : C} (h : IsTerminal Y) (c : BinaryFan X Y) :
    Nonempty (IsLimit c) ↔ IsIso c.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsTerminal Y) (c : CategoryTheory.Limits.BinaryFan X Y)
Goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.fst
-- CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_snd
theorem BinaryFan.isLimit_iff_isIso_snd {X Y : C} (h : IsTerminal X) (c : BinaryFan X Y) :
    Nonempty (IsLimit c) ↔ IsIso c.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsTerminal X) (c : CategoryTheory.Limits.BinaryFan X Y)
Goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ CategoryTheory.IsIso c.snd
-- CategoryTheory.Limits.BinaryCofan.isColimit_iff_isIso_inl
theorem BinaryCofan.isColimit_iff_isIso_inl {X Y : C} (h : IsInitial Y) (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔ IsIso c.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsInitial Y) (c : CategoryTheory.Limits.BinaryCofan X Y)
Goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔ CategoryTheory.IsIso c.inl
-- CategoryTheory.Limits.BinaryCofan.isColimit_iff_isIso_inr
theorem BinaryCofan.isColimit_iff_isIso_inr {X Y : C} (h : IsInitial X) (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔ IsIso c.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (h : CategoryTheory.Limits.IsInitial X) (c : CategoryTheory.Limits.BinaryCofan X Y)
Goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔ CategoryTheory.IsIso c.inr
-- CategoryTheory.Limits.prod.hom_ext
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} [CategoryTheory.Limits.HasBinaryProduct X Y] {f g : W ⟶ X ⨯ Y} (h₁ : f ≫ CategoryTheory.Limits.prod.fst = g ≫ CategoryTheory.Limits.prod.fst) (h₂ : f ≫ CategoryTheory.Limits.prod.snd = g ≫ CategoryTheory.Limits.prod.snd)
Goal: f = g
-- CategoryTheory.Limits.coprod.hom_ext
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} [CategoryTheory.Limits.HasBinaryCoproduct X Y] {f g : X ⨿ Y ⟶ W} (h₁ : CategoryTheory.Limits.coprod.inl ≫ f = CategoryTheory.Limits.coprod.inl ≫ g) (h₂ : CategoryTheory.Limits.coprod.inr ≫ f = CategoryTheory.Limits.coprod.inr ≫ g)
Goal: f = g
-- CategoryTheory.Limits.prod.lift_fst
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} [CategoryTheory.Limits.HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y)
Goal: CategoryTheory.Limits.prod.lift f g ≫ CategoryTheory.Limits.prod.fst = f
-- CategoryTheory.Limits.prod.lift_snd
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} [CategoryTheory.Limits.HasBinaryProduct X Y] (f : W ⟶ X) (g : W ⟶ Y)
Goal: CategoryTheory.Limits.prod.lift f g ≫ CategoryTheory.Limits.prod.snd = g
-- CategoryTheory.Limits.coprod.inl_desc
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} [CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W)
Goal: CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.Limits.coprod.desc f g = f
-- CategoryTheory.Limits.coprod.inr_desc
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y : C} [CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W)
Goal: CategoryTheory.Limits.coprod.inr ≫ CategoryTheory.Limits.coprod.desc f g = g
-- CategoryTheory.Limits.prod.comp_lift
@[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) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {V W X Y : C} [CategoryTheory.Limits.HasBinaryProduct X Y] (f : V ⟶ W) (g : W ⟶ X) (h : W ⟶ Y)
Goal: f ≫ CategoryTheory.Limits.prod.lift g h = CategoryTheory.Limits.prod.lift (f ≫ g) (f ≫ h)
-- CategoryTheory.Limits.prod.comp_diag
theorem prod.comp_diag {X Y : C} [HasBinaryProduct Y Y] (f : X ⟶ Y) :
    f ≫ diag Y = prod.lift f f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasBinaryProduct Y Y] (f : X ⟶ Y)
Goal: f ≫ CategoryTheory.Limits.diag Y = CategoryTheory.Limits.prod.lift f f
-- CategoryTheory.Limits.prod.map_fst
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} [CategoryTheory.Limits.HasBinaryProduct W X] [CategoryTheory.Limits.HasBinaryProduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z)
Goal: CategoryTheory.Limits.prod.map f g ≫ CategoryTheory.Limits.prod.fst = CategoryTheory.Limits.prod.fst ≫ f
-- CategoryTheory.Limits.prod.map_snd
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} [CategoryTheory.Limits.HasBinaryProduct W X] [CategoryTheory.Limits.HasBinaryProduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z)
Goal: CategoryTheory.Limits.prod.map f g ≫ CategoryTheory.Limits.prod.snd = CategoryTheory.Limits.prod.snd ≫ g
-- CategoryTheory.Limits.prod.map_id_id
@[simp]
theorem prod.map_id_id {X Y : C} [HasBinaryProduct X Y] : prod.map (𝟙 X) (𝟙 Y) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasBinaryProduct X Y]
Goal: CategoryTheory.Limits.prod.map (𝟙 X) (𝟙 Y) = 𝟙 (X ⨯ Y)
-- CategoryTheory.Limits.prod.lift_fst_snd
@[simp]
theorem prod.lift_fst_snd {X Y : C} [HasBinaryProduct X Y] :
    prod.lift prod.fst prod.snd = 𝟙 (X ⨯ Y) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasBinaryProduct X Y]
Goal: CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd = 𝟙 (X ⨯ Y)
-- CategoryTheory.Limits.prod.lift_map
@[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) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {V W X Y Z : C} [CategoryTheory.Limits.HasBinaryProduct W X] [CategoryTheory.Limits.HasBinaryProduct Y Z] (f : V ⟶ W) (g : V ⟶ X) (h : W ⟶ Y) (k : X ⟶ Z)
Goal: CategoryTheory.Limits.prod.lift f g ≫ CategoryTheory.Limits.prod.map h k =
  CategoryTheory.Limits.prod.lift (f ≫ h) (g ≫ k)
-- CategoryTheory.Limits.prod.lift_fst_comp_snd_comp
@[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' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} [CategoryTheory.Limits.HasBinaryProduct W Y] [CategoryTheory.Limits.HasBinaryProduct X Z] (g : W ⟶ X) (g' : Y ⟶ Z)
Goal: CategoryTheory.Limits.prod.lift (CategoryTheory.Limits.prod.fst ≫ g) (CategoryTheory.Limits.prod.snd ≫ g') =
  CategoryTheory.Limits.prod.map g g'
-- CategoryTheory.Limits.prod.map_map
@[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) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A₁ A₂ A₃ B₁ B₂ B₃ : C} [CategoryTheory.Limits.HasBinaryProduct A₁ B₁] [CategoryTheory.Limits.HasBinaryProduct A₂ B₂] [CategoryTheory.Limits.HasBinaryProduct A₃ B₃] (f : A₁ ⟶ A₂) (g : B₁ ⟶ B₂) (h : A₂ ⟶ A₃) (k : B₂ ⟶ B₃)
Goal: CategoryTheory.Limits.prod.map f g ≫ CategoryTheory.Limits.prod.map h k = CategoryTheory.Limits.prod.map (f ≫ h) (g ≫ k)
-- CategoryTheory.Limits.prod.map_swap
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B X Y : C} (f : A ⟶ B) (g : X ⟶ Y) [CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C]
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
-- CategoryTheory.Limits.prod.map_comp_id
@[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) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Limits.HasBinaryProduct X W] [CategoryTheory.Limits.HasBinaryProduct Z W] [CategoryTheory.Limits.HasBinaryProduct Y W]
Goal: CategoryTheory.Limits.prod.map (f ≫ g) (𝟙 W) =
  CategoryTheory.Limits.prod.map f (𝟙 W) ≫ CategoryTheory.Limits.prod.map g (𝟙 W)
-- CategoryTheory.Limits.prod.map_id_comp
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z W : C} (f : X ⟶ Y) (g : Y ⟶ Z) [CategoryTheory.Limits.HasBinaryProduct W X] [CategoryTheory.Limits.HasBinaryProduct W Y] [CategoryTheory.Limits.HasBinaryProduct W Z]
Goal: CategoryTheory.Limits.prod.map (𝟙 W) (f ≫ g) =
  CategoryTheory.Limits.prod.map (𝟙 W) f ≫ CategoryTheory.Limits.prod.map (𝟙 W) g
-- CategoryTheory.Limits.prod.mapIso_inv
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} [CategoryTheory.Limits.HasBinaryProduct W X] [CategoryTheory.Limits.HasBinaryProduct Y Z] (f : W ≅ Y) (g : X ≅ Z)
Goal: (CategoryTheory.Limits.prod.mapIso f g).inv = CategoryTheory.Limits.prod.map f.inv g.inv
-- CategoryTheory.Limits.prod.mapIso_hom
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} [CategoryTheory.Limits.HasBinaryProduct W X] [CategoryTheory.Limits.HasBinaryProduct Y Z] (f : W ≅ Y) (g : X ≅ Z)
Goal: (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom
-- CategoryTheory.Limits.prod.diag_map
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasBinaryProduct X X] [CategoryTheory.Limits.HasBinaryProduct Y Y]
Goal: CategoryTheory.Limits.diag X ≫ CategoryTheory.Limits.prod.map f f = f ≫ CategoryTheory.Limits.diag Y
-- CategoryTheory.Limits.prod.diag_map_fst_snd
@[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) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasBinaryProduct X Y] [CategoryTheory.Limits.HasBinaryProduct (X ⨯ Y) (X ⨯ Y)]
Goal: CategoryTheory.Limits.diag (X ⨯ Y) ≫
    CategoryTheory.Limits.prod.map CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd =
  𝟙 (X ⨯ Y)
-- CategoryTheory.Limits.prod.diag_map_fst_snd_comp
@[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' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C] {X X' Y Y' : C} (g : X ⟶ Y) (g' : X' ⟶ Y')
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'
-- CategoryTheory.Limits.coprod.desc_comp
@[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) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {V W X Y : C} [CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : V ⟶ W) (g : X ⟶ V) (h : Y ⟶ V)
Goal: CategoryTheory.Limits.coprod.desc g h ≫ f = CategoryTheory.Limits.coprod.desc (g ≫ f) (h ≫ f)
-- CategoryTheory.Limits.coprod.desc_comp_assoc
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 
Arguments: {C : Type u} [CategoryTheory.Category.{u_1, u} C] {V W X Y : C} [CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : V ⟶ W) (g : X ⟶ V) (h : Y ⟶ V) {Z : C} (l : W ⟶ Z)
Goal: CategoryTheory.Limits.coprod.desc g h ≫ f ≫ l = CategoryTheory.Limits.coprod.desc (g ≫ f) (h ≫ f) ≫ l
-- CategoryTheory.Limits.coprod.diag_comp
theorem coprod.diag_comp {X Y : C} [HasBinaryCoproduct X X] (f : X ⟶ Y) :
    codiag X ≫ f = coprod.desc f f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasBinaryCoproduct X X] (f : X ⟶ Y)
Goal: CategoryTheory.Limits.codiag X ≫ f = CategoryTheory.Limits.coprod.desc f f
-- CategoryTheory.Limits.coprod.inl_map
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} [CategoryTheory.Limits.HasBinaryCoproduct W X] [CategoryTheory.Limits.HasBinaryCoproduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z)
Goal: CategoryTheory.Limits.coprod.inl ≫ CategoryTheory.Limits.coprod.map f g = f ≫ CategoryTheory.Limits.coprod.inl