ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.RegularEpi.w
class RegularEpi (f : X ⟶ Y) where
    W : C -- Porting note: violates naming convention but what is better?
    (left right : W ⟶ X)
    w : left ≫ f = right ≫ f := by aesop_cat
    isColimit : IsColimit (Cofork.ofπ f w)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.RegularEpi f]
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.RegularEpi.left f =
  CategoryTheory.CategoryStruct.comp CategoryTheory.RegularEpi.right f
-- CategoryTheory.isIso_of_regularEpi_of_mono
theorem isIso_of_regularEpi_of_mono (f : X ⟶ Y) [RegularEpi f] [Mono f] : IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.RegularEpi f] [CategoryTheory.Mono f]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.Fan.mk_π_app
@[simps! pt π_app]
def Fan.mk {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) : Fan f 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (P : C) (p : (b : β) → P ⟶ f b) (X : CategoryTheory.Discrete β)
Goal: (CategoryTheory.Limits.Fan.mk P p).π.app X = p X.as
-- CategoryTheory.Limits.Fan.mk_pt
@[simps! pt π_app]
def Fan.mk {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) : Fan f 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (P : C) (p : (b : β) → P ⟶ f b)
Goal: (CategoryTheory.Limits.Fan.mk P p).pt = P
-- CategoryTheory.Limits.Cofan.mk_pt
@[simps! pt ι_app]
def Cofan.mk {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) : Cofan f 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (P : C) (p : (b : β) → f b ⟶ P)
Goal: (CategoryTheory.Limits.Cofan.mk P p).pt = P
-- CategoryTheory.Limits.Cofan.mk_ι_app
@[simps! pt ι_app]
def Cofan.mk {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) : Cofan f 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (P : C) (p : (b : β) → f b ⟶ P) (X : CategoryTheory.Discrete β)
Goal: (CategoryTheory.Limits.Cofan.mk P p).ι.app X = p X.as
-- CategoryTheory.Limits.fan_mk_proj
@[simp]
theorem fan_mk_proj {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) (j : β) : (Fan.mk P p).proj j = p j 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (P : C) (p : (b : β) → P ⟶ f b) (j : β)
Goal: (CategoryTheory.Limits.Fan.mk P p).proj j = p j
-- CategoryTheory.Limits.cofan_mk_inj
@[simp]
theorem cofan_mk_inj {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) (j : β) :
    (Cofan.mk P p).inj j = p j 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (P : C) (p : (b : β) → f b ⟶ P) (j : β)
Goal: (CategoryTheory.Limits.Cofan.mk P p).inj j = p j
-- CategoryTheory.Limits.hasCoproduct_of_equiv_of_iso
lemma hasCoproduct_of_equiv_of_iso (f : α → C) (g : β → C)
    [HasCoproduct f] (e : β ≃ α) (iso : ∀ j, g j ≅ f (e j)) : HasCoproduct g 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] (f : α → C) (g : β → C) [CategoryTheory.Limits.HasCoproduct f] (e : β ≃ α) (iso : (j : β) → g j ≅ f (e j))
Goal: CategoryTheory.Limits.HasCoproduct g
-- CategoryTheory.Limits.hasProduct_of_equiv_of_iso
lemma hasProduct_of_equiv_of_iso (f : α → C) (g : β → C)
    [HasProduct f] (e : β ≃ α) (iso : ∀ j, g j ≅ f (e j)) : HasProduct g 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] (f : α → C) (g : β → C) [CategoryTheory.Limits.HasProduct f] (e : β ≃ α) (iso : (j : β) → g j ≅ f (e j))
Goal: CategoryTheory.Limits.HasProduct g
-- CategoryTheory.Limits.mkFanLimit_lift
@[simps]
def mkFanLimit {f : β → C} (t : Fan f) (lift : ∀ s : Fan f, s.pt ⟶ t.pt)
    (fac : ∀ (s : Fan f) (j : β), lift s ≫ t.proj j = s.proj j := by aesop_cat)
    (uniq : ∀ (s : Fan f) (m : s.pt ⟶ t.pt) (_ : ∀ j : β, m ≫ t.proj j = s.proj j),
      m = lift s := by aesop_cat) :
    IsLimit t 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (t : CategoryTheory.Limits.Fan f) (lift : (s : CategoryTheory.Limits.Fan f) → s.pt ⟶ t.pt) (fac : ∀ (s : CategoryTheory.Limits.Fan f) (j : β), lift s ≫ t.proj j = s.proj j := by aesop_cat) (uniq : ∀ (s : CategoryTheory.Limits.Fan f) (m : s.pt ⟶ t.pt), (∀ (j : β), m ≫ t.proj j = s.proj j) → m = lift s := by
  aesop_cat) (s : CategoryTheory.Limits.Fan f)
Goal: (CategoryTheory.Limits.mkFanLimit t lift fac uniq).lift s = lift s
-- CategoryTheory.Limits.Fan.IsLimit.fac
@[reassoc (attr := simp)]
lemma Fan.IsLimit.fac {F : β → C} {c : Fan F} (hc : IsLimit c) {A : C}
    (f : ∀ i, A ⟶ F i) (i : β) :
    Fan.IsLimit.desc hc f ≫ c.proj i = f i 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : β → C} {c : CategoryTheory.Limits.Fan F} (hc : CategoryTheory.Limits.IsLimit c) {A : C} (f : (i : β) → A ⟶ F i) (i : β)
Goal: CategoryTheory.Limits.Fan.IsLimit.desc hc f ≫ c.proj i = f i
-- CategoryTheory.Limits.Fan.IsLimit.hom_ext
lemma Fan.IsLimit.hom_ext {I : Type*} {F : I → C} {c : Fan F} (hc : IsLimit c) {A : C}
    (f g : A ⟶ c.pt) (h : ∀ i, f ≫ c.proj i = g ≫ c.proj i) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type u_1} {F : I → C} {c : CategoryTheory.Limits.Fan F} (hc : CategoryTheory.Limits.IsLimit c) {A : C} (f g : A ⟶ c.pt) (h : ∀ (i : I), f ≫ c.proj i = g ≫ c.proj i)
Goal: f = g
-- CategoryTheory.Limits.mkCofanColimit_desc
@[simps]
def mkCofanColimit {f : β → C} (s : Cofan f) (desc : ∀ t : Cofan f, s.pt ⟶ t.pt)
    (fac : ∀ (t : Cofan f) (j : β), s.inj j ≫ desc t = t.inj j := by aesop_cat)
    (uniq : ∀ (t : Cofan f) (m : s.pt ⟶ t.pt) (_ : ∀ j : β, s.inj j ≫ m = t.inj j),
      m = desc t := by aesop_cat) :
    IsColimit s 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} (s : CategoryTheory.Limits.Cofan f) (desc : (t : CategoryTheory.Limits.Cofan f) → s.pt ⟶ t.pt) (fac : ∀ (t : CategoryTheory.Limits.Cofan f) (j : β), s.inj j ≫ desc t = t.inj j := by aesop_cat) (uniq : ∀ (t : CategoryTheory.Limits.Cofan f) (m : s.pt ⟶ t.pt), (∀ (j : β), s.inj j ≫ m = t.inj j) → m = desc t := by
  aesop_cat) (t : CategoryTheory.Limits.Cofan f)
Goal: (CategoryTheory.Limits.mkCofanColimit s desc fac uniq).desc t = desc t
-- CategoryTheory.Limits.Cofan.IsColimit.fac
@[reassoc (attr := simp)]
lemma Cofan.IsColimit.fac {F : β → C} {c : Cofan F} (hc : IsColimit c) {A : C}
    (f : ∀ i, F i ⟶ A) (i : β) :
    c.inj i ≫ Cofan.IsColimit.desc hc f = f i 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : β → C} {c : CategoryTheory.Limits.Cofan F} (hc : CategoryTheory.Limits.IsColimit c) {A : C} (f : (i : β) → F i ⟶ A) (i : β)
Goal: c.inj i ≫ CategoryTheory.Limits.Cofan.IsColimit.desc hc f = f i
-- CategoryTheory.Limits.Cofan.IsColimit.hom_ext
lemma Cofan.IsColimit.hom_ext {I : Type*} {F : I → C} {c : Cofan F} (hc : IsColimit c) {A : C}
    (f g : c.pt ⟶ A) (h : ∀ i, c.inj i ≫ f = c.inj i ≫ g) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : Type u_1} {F : I → C} {c : CategoryTheory.Limits.Cofan F} (hc : CategoryTheory.Limits.IsColimit c) {A : C} (f g : c.pt ⟶ A) (h : ∀ (i : I), c.inj i ≫ f = c.inj i ≫ g)
Goal: f = g
-- CategoryTheory.Limits.Pi.hom_ext
@[ext 1050]
lemma Pi.hom_ext {f : β → C} [HasProduct f] {X : C} (g₁ g₂ : X ⟶ ∏ᶜ f)
    (h : ∀ (b : β), g₁ ≫ Pi.π f b = g₂ ≫ Pi.π f b) : g₁ = g₂ 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} [CategoryTheory.Limits.HasProduct f] {X : C} (g₁ g₂ : X ⟶ ∏ᶜ f) (h : ∀ (b : β), g₁ ≫ CategoryTheory.Limits.Pi.π f b = g₂ ≫ CategoryTheory.Limits.Pi.π f b)
Goal: g₁ = g₂
-- CategoryTheory.Limits.Sigma.hom_ext
@[ext 1050]
lemma Sigma.hom_ext {f : β → C} [HasCoproduct f] {X : C} (g₁ g₂ : ∐ f ⟶ X)
    (h : ∀ (b : β), Sigma.ι f b ≫ g₁ = Sigma.ι f b ≫ g₂) : g₁ = g₂ 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} [CategoryTheory.Limits.HasCoproduct f] {X : C} (g₁ g₂ : ∐ f ⟶ X) (h : ∀ (b : β), CategoryTheory.Limits.Sigma.ι f b ≫ g₁ = CategoryTheory.Limits.Sigma.ι f b ≫ g₂)
Goal: g₁ = g₂
-- CategoryTheory.Limits.Pi.π_comp_eqToHom
@[reassoc (attr := simp, nolint simpNF)]
theorem Pi.π_comp_eqToHom {J : Type*} (f : J → C) [HasProduct f] {j j' : J} (w : j = j') :
    Pi.π f j ≫ eqToHom (by simp [w]) = Pi.π f j' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u_1} (f : J → C) [CategoryTheory.Limits.HasProduct f] {j j' : J} (w : j = j')
Goal: CategoryTheory.Limits.Pi.π f j ≫ CategoryTheory.eqToHom ⋯ = CategoryTheory.Limits.Pi.π f j'
-- CategoryTheory.Limits.Sigma.eqToHom_comp_ι
@[reassoc (attr := simp, nolint simpNF)]
theorem Sigma.eqToHom_comp_ι {J : Type*} (f : J → C) [HasCoproduct f] {j j' : J} (w : j = j') :
    eqToHom (by simp [w]) ≫ Sigma.ι f j' = Sigma.ι f j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u_1} (f : J → C) [CategoryTheory.Limits.HasCoproduct f] {j j' : J} (w : j = j')
Goal: CategoryTheory.eqToHom ⋯ ≫ CategoryTheory.Limits.Sigma.ι f j' = CategoryTheory.Limits.Sigma.ι f j
-- CategoryTheory.Limits.Pi.lift_π
theorem Pi.lift_π {β : Type w} {f : β → C} [HasProduct f] {P : C} (p : ∀ b, P ⟶ f b) (b : β) :
    Pi.lift p ≫ Pi.π f b = p b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type w} {f : β → C} [CategoryTheory.Limits.HasProduct f] {P : C} (p : (b : β) → P ⟶ f b) (b : β)
Goal: CategoryTheory.Limits.Pi.lift p ≫ CategoryTheory.Limits.Pi.π f b = p b
-- CategoryTheory.Limits.Sigma.ι_desc
theorem Sigma.ι_desc {β : Type w} {f : β → C} [HasCoproduct f] {P : C} (p : ∀ b, f b ⟶ P) (b : β) :
    Sigma.ι f b ≫ Sigma.desc p = p b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {β : Type w} {f : β → C} [CategoryTheory.Limits.HasCoproduct f] {P : C} (p : (b : β) → f b ⟶ P) (b : β)
Goal: CategoryTheory.Limits.Sigma.ι f b ≫ CategoryTheory.Limits.Sigma.desc p = p b
-- CategoryTheory.Limits.Cofan.ext_inv_hom
@[simps!]
def Cofan.ext {f : β → C} {c₁ c₂ : Cofan f} (e : c₁.pt ≅ c₂.pt)
    (w : ∀ (b : β), c₁.inj b ≫ e.hom = c₂.inj b := by aesop_cat) : c₁ ≅ c₂ 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} {c₁ c₂ : CategoryTheory.Limits.Cofan f} (e : c₁.pt ≅ c₂.pt) (w : ∀ (b : β), c₁.inj b ≫ e.hom = c₂.inj b := by aesop_cat)
Goal: (CategoryTheory.Limits.Cofan.ext e w).inv.hom = e.inv
-- CategoryTheory.Limits.Cofan.ext_hom_hom
@[simps!]
def Cofan.ext {f : β → C} {c₁ c₂ : Cofan f} (e : c₁.pt ≅ c₂.pt)
    (w : ∀ (b : β), c₁.inj b ≫ e.hom = c₂.inj b := by aesop_cat) : c₁ ≅ c₂ 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} {c₁ c₂ : CategoryTheory.Limits.Cofan f} (e : c₁.pt ≅ c₂.pt) (w : ∀ (b : β), c₁.inj b ≫ e.hom = c₂.inj b := by aesop_cat)
Goal: (CategoryTheory.Limits.Cofan.ext e w).hom.hom = e.hom
-- CategoryTheory.Limits.Cofan.isColimit_iff_isIso_sigmaDesc
lemma Cofan.isColimit_iff_isIso_sigmaDesc {f : β → C} [HasCoproduct f] (c : Cofan f) :
    IsIso (Sigma.desc c.inj) ↔ Nonempty (IsColimit c) 
Arguments: {β : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : β → C} [CategoryTheory.Limits.HasCoproduct f] (c : CategoryTheory.Limits.Cofan f)
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc c.inj) ↔ Nonempty (CategoryTheory.Limits.IsColimit c)
-- CategoryTheory.Limits.Pi.map_id
@[simp]
lemma Pi.map_id {f : α → C} [HasProduct f] : Pi.map (fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f) 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} [CategoryTheory.Limits.HasProduct f]
Goal: (CategoryTheory.Limits.Pi.map fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f)
-- CategoryTheory.Limits.Pi.map_comp_map
lemma Pi.map_comp_map {f g h : α → C} [HasProduct f] [HasProduct g] [HasProduct h]
    (q : ∀ (a : α), f a ⟶ g a) (q' : ∀ (a : α), g a ⟶ h a) :
    Pi.map q ≫ Pi.map q' = Pi.map (fun a => q a ≫ q' a) 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f g h : α → C} [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g] [CategoryTheory.Limits.HasProduct h] (q : (a : α) → f a ⟶ g a) (q' : (a : α) → g a ⟶ h a)
Goal: CategoryTheory.Limits.Pi.map q ≫ CategoryTheory.Limits.Pi.map q' = CategoryTheory.Limits.Pi.map fun a => q a ≫ q' a
-- CategoryTheory.Limits.Pi.map'_comp_π
@[reassoc (attr := simp)]
lemma Pi.map'_comp_π {f : α → C} {g : β → C} [HasProduct f] [HasProduct g] (p : β → α)
    (q : ∀ (b : β), f (p b) ⟶ g b) (b : β) : Pi.map' p q ≫ Pi.π g b = Pi.π f (p b) ≫ q b 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C} [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g] (p : β → α) (q : (b : β) → f (p b) ⟶ g b) (b : β)
Goal: CategoryTheory.Limits.Pi.map' p q ≫ CategoryTheory.Limits.Pi.π g b = CategoryTheory.Limits.Pi.π f (p b) ≫ q b
-- CategoryTheory.Limits.Pi.map'_id_id
lemma Pi.map'_id_id {f : α → C} [HasProduct f] : Pi.map' id (fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f) 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} [CategoryTheory.Limits.HasProduct f]
Goal: (CategoryTheory.Limits.Pi.map' id fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f)
-- CategoryTheory.Limits.Pi.map'_id
@[simp]
lemma Pi.map'_id {f g : α → C} [HasProduct f] [HasProduct g] (p : ∀ b, f b ⟶ g b) :
    Pi.map' id p = Pi.map p 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : α → C} [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g] (p : (b : α) → f b ⟶ g b)
Goal: CategoryTheory.Limits.Pi.map' id p = CategoryTheory.Limits.Pi.map p
-- CategoryTheory.Limits.Pi.map'_comp_map'
lemma Pi.map'_comp_map' {f : α → C} {g : β → C} {h : γ → C} [HasProduct f] [HasProduct g]
    [HasProduct h] (p : β → α) (p' : γ → β) (q : ∀ (b : β), f (p b) ⟶ g b)
    (q' : ∀ (c : γ), g (p' c) ⟶ h c) :
    Pi.map' p q ≫ Pi.map' p' q' = Pi.map' (p ∘ p') (fun c => q (p' c) ≫ q' c) 
Arguments: {β : Type w} {α : Type w₂} {γ : Type w₃} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C} {h : γ → C} [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g] [CategoryTheory.Limits.HasProduct h] (p : β → α) (p' : γ → β) (q : (b : β) → f (p b) ⟶ g b) (q' : (c : γ) → g (p' c) ⟶ h c)
Goal: CategoryTheory.Limits.Pi.map' p q ≫ CategoryTheory.Limits.Pi.map' p' q' =
  CategoryTheory.Limits.Pi.map' (p ∘ p') fun c => q (p' c) ≫ q' c
-- CategoryTheory.Limits.Pi.map'_comp_map
lemma Pi.map'_comp_map {f : α → C} {g h : β → C} [HasProduct f] [HasProduct g] [HasProduct h]
    (p : β → α) (q : ∀ (b : β), f (p b) ⟶ g b) (q' : ∀ (b : β), g b ⟶ h b) :
    Pi.map' p q ≫ Pi.map q' = Pi.map' p (fun b => q b ≫ q' b) 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g h : β → C} [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g] [CategoryTheory.Limits.HasProduct h] (p : β → α) (q : (b : β) → f (p b) ⟶ g b) (q' : (b : β) → g b ⟶ h b)
Goal: CategoryTheory.Limits.Pi.map' p q ≫ CategoryTheory.Limits.Pi.map q' =
  CategoryTheory.Limits.Pi.map' p fun b => q b ≫ q' b
-- CategoryTheory.Limits.Pi.map_comp_map'
lemma Pi.map_comp_map' {f g : α → C} {h : β → C} [HasProduct f] [HasProduct g] [HasProduct h]
    (p : β → α) (q : ∀ (a : α), f a ⟶ g a) (q' : ∀ (b : β), g (p b) ⟶ h b) :
    Pi.map q ≫ Pi.map' p q' = Pi.map' p (fun b => q (p b) ≫ q' b) 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : α → C} {h : β → C} [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g] [CategoryTheory.Limits.HasProduct h] (p : β → α) (q : (a : α) → f a ⟶ g a) (q' : (b : β) → g (p b) ⟶ h b)
Goal: CategoryTheory.Limits.Pi.map q ≫ CategoryTheory.Limits.Pi.map' p q' =
  CategoryTheory.Limits.Pi.map' p fun b => q (p b) ≫ q' b
-- CategoryTheory.Limits.Pi.map'_eq
lemma Pi.map'_eq {f : α → C} {g : β → C} [HasProduct f] [HasProduct g] {p p' : β → α}
    {q : ∀ (b : β), f (p b) ⟶ g b} {q' : ∀ (b : β), f (p' b) ⟶ g b} (hp : p = p')
    (hq : ∀ (b : β), eqToHom (hp ▸ rfl) ≫ q b = q' b) : Pi.map' p q = Pi.map' p' q' 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C} [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g] {p p' : β → α} {q : (b : β) → f (p b) ⟶ g b} {q' : (b : β) → f (p' b) ⟶ g b} (hp : p = p') (hq : ∀ (b : β), CategoryTheory.eqToHom ⋯ ≫ q b = q' b)
Goal: CategoryTheory.Limits.Pi.map' p q = CategoryTheory.Limits.Pi.map' p' q'
-- CategoryTheory.Limits.Pi.cone_pt
@[simps]
def Pi.cone : Cone X 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Discrete α ⥤ C) [CategoryTheory.Limits.HasProduct fun j => X.obj { as := j }]
Goal: (CategoryTheory.Limits.Pi.cone X).pt = ∏ᶜ fun j => X.obj { as := j }
-- CategoryTheory.Limits.Pi.cone_π
@[simps]
def Pi.cone : Cone X 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Discrete α ⥤ C) [CategoryTheory.Limits.HasProduct fun j => X.obj { as := j }]
Goal: (CategoryTheory.Limits.Pi.cone X).π =
  CategoryTheory.Discrete.natTrans fun x => CategoryTheory.Limits.Pi.π (fun j => X.obj { as := j }) x.as
-- CategoryTheory.Limits.Pi.isoLimit_inv_π
@[reassoc (attr := simp)]
lemma Pi.isoLimit_inv_π (j : α) :
    (Pi.isoLimit X).inv ≫ Pi.π _ j = limit.π _ (Discrete.mk j) 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Discrete α ⥤ C) [CategoryTheory.Limits.HasProduct fun j => X.obj { as := j }] [CategoryTheory.Limits.HasLimit X] (j : α)
Goal: (CategoryTheory.Limits.Pi.isoLimit X).inv ≫ CategoryTheory.Limits.Pi.π (fun j => X.obj { as := j }) j =
  CategoryTheory.Limits.limit.π X { as := j }
-- CategoryTheory.Limits.Pi.isoLimit_hom_π
@[reassoc (attr := simp)]
lemma Pi.isoLimit_hom_π (j : α) :
    (Pi.isoLimit X).hom ≫ limit.π _ (Discrete.mk j) = Pi.π _ j 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Discrete α ⥤ C) [CategoryTheory.Limits.HasProduct fun j => X.obj { as := j }] [CategoryTheory.Limits.HasLimit X] (j : α)
Goal: (CategoryTheory.Limits.Pi.isoLimit X).hom ≫ CategoryTheory.Limits.limit.π X { as := j } =
  CategoryTheory.Limits.Pi.π (fun j => X.obj { as := j }) j
-- CategoryTheory.Limits.Sigma.map_id
@[simp]
lemma Sigma.map_id {f : α → C} [HasCoproduct f] : Sigma.map (fun a => 𝟙 (f a)) = 𝟙 (∐ f) 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} [CategoryTheory.Limits.HasCoproduct f]
Goal: (CategoryTheory.Limits.Sigma.map fun a => 𝟙 (f a)) = 𝟙 (∐ f)
-- CategoryTheory.Limits.Sigma.map_comp_map
lemma Sigma.map_comp_map {f g h : α → C} [HasCoproduct f] [HasCoproduct g] [HasCoproduct h]
    (q : ∀ (a : α), f a ⟶ g a) (q' : ∀ (a : α), g a ⟶ h a) :
    Sigma.map q ≫ Sigma.map q' = Sigma.map (fun a => q a ≫ q' a) 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f g h : α → C} [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g] [CategoryTheory.Limits.HasCoproduct h] (q : (a : α) → f a ⟶ g a) (q' : (a : α) → g a ⟶ h a)
Goal: CategoryTheory.Limits.Sigma.map q ≫ CategoryTheory.Limits.Sigma.map q' =
  CategoryTheory.Limits.Sigma.map fun a => q a ≫ q' a
-- CategoryTheory.Limits.Sigma.ι_comp_map'
@[reassoc (attr := simp)]
lemma Sigma.ι_comp_map' {f : α → C} {g : β → C} [HasCoproduct f] [HasCoproduct g]
    (p : α → β) (q : ∀ (a : α), f a ⟶ g (p a)) (a : α) :
    Sigma.ι f a ≫ Sigma.map' p q = q a ≫ Sigma.ι g (p a) 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C} [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g] (p : α → β) (q : (a : α) → f a ⟶ g (p a)) (a : α)
Goal: CategoryTheory.Limits.Sigma.ι f a ≫ CategoryTheory.Limits.Sigma.map' p q = q a ≫ CategoryTheory.Limits.Sigma.ι g (p a)
-- CategoryTheory.Limits.Sigma.map'_id_id
lemma Sigma.map'_id_id {f : α → C} [HasCoproduct f] :
    Sigma.map' id (fun a => 𝟙 (f a)) = 𝟙 (∐ f) 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} [CategoryTheory.Limits.HasCoproduct f]
Goal: (CategoryTheory.Limits.Sigma.map' id fun a => 𝟙 (f a)) = 𝟙 (∐ f)
-- CategoryTheory.Limits.Sigma.map'_id
@[simp]
lemma Sigma.map'_id {f g : α → C} [HasCoproduct f] [HasCoproduct g] (p : ∀ b, f b ⟶ g b) :
    Sigma.map' id p = Sigma.map p 
Arguments: {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : α → C} [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g] (p : (b : α) → f b ⟶ g b)
Goal: CategoryTheory.Limits.Sigma.map' id p = CategoryTheory.Limits.Sigma.map p
-- CategoryTheory.Limits.Sigma.map'_comp_map'
lemma Sigma.map'_comp_map' {f : α → C} {g : β → C} {h : γ → C} [HasCoproduct f] [HasCoproduct g]
    [HasCoproduct h] (p : α → β) (p' : β → γ) (q : ∀ (a : α), f a ⟶ g (p a))
    (q' : ∀ (b : β), g b ⟶ h (p' b)) :
    Sigma.map' p q ≫ Sigma.map' p' q' = Sigma.map' (p' ∘ p) (fun a => q a ≫ q' (p a)) 
Arguments: {β : Type w} {α : Type w₂} {γ : Type w₃} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C} {h : γ → C} [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g] [CategoryTheory.Limits.HasCoproduct h] (p : α → β) (p' : β → γ) (q : (a : α) → f a ⟶ g (p a)) (q' : (b : β) → g b ⟶ h (p' b))
Goal: CategoryTheory.Limits.Sigma.map' p q ≫ CategoryTheory.Limits.Sigma.map' p' q' =
  CategoryTheory.Limits.Sigma.map' (p' ∘ p) fun a => q a ≫ q' (p a)
-- CategoryTheory.Limits.Sigma.map'_comp_map
lemma Sigma.map'_comp_map {f : α → C} {g h : β → C} [HasCoproduct f] [HasCoproduct g]
    [HasCoproduct h] (p : α → β) (q : ∀ (a : α), f a ⟶ g (p a)) (q' : ∀ (b : β), g b ⟶ h b) :
    Sigma.map' p q ≫ Sigma.map q' = Sigma.map' p (fun a => q a ≫ q' (p a)) 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g h : β → C} [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g] [CategoryTheory.Limits.HasCoproduct h] (p : α → β) (q : (a : α) → f a ⟶ g (p a)) (q' : (b : β) → g b ⟶ h b)
Goal: CategoryTheory.Limits.Sigma.map' p q ≫ CategoryTheory.Limits.Sigma.map q' =
  CategoryTheory.Limits.Sigma.map' p fun a => q a ≫ q' (p a)
-- CategoryTheory.Limits.Sigma.map_comp_map'
lemma Sigma.map_comp_map' {f g : α → C} {h : β → C} [HasCoproduct f] [HasCoproduct g]
    [HasCoproduct h] (p : α → β) (q : ∀ (a : α), f a ⟶ g a) (q' : ∀ (a : α), g a ⟶ h (p a)) :
    Sigma.map q ≫ Sigma.map' p q' = Sigma.map' p (fun a => q a ≫ q' a) 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : α → C} {h : β → C} [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g] [CategoryTheory.Limits.HasCoproduct h] (p : α → β) (q : (a : α) → f a ⟶ g a) (q' : (a : α) → g a ⟶ h (p a))
Goal: CategoryTheory.Limits.Sigma.map q ≫ CategoryTheory.Limits.Sigma.map' p q' =
  CategoryTheory.Limits.Sigma.map' p fun a => q a ≫ q' a
-- CategoryTheory.Limits.Sigma.map'_eq
lemma Sigma.map'_eq {f : α → C} {g : β → C} [HasCoproduct f] [HasCoproduct g]
    {p p' : α → β} {q : ∀ (a : α), f a ⟶ g (p a)} {q' : ∀ (a : α), f a ⟶ g (p' a)}
    (hp : p = p') (hq : ∀ (a : α), q a ≫ eqToHom (hp ▸ rfl) = q' a) :
    Sigma.map' p q = Sigma.map' p' q' 
Arguments: {β : Type w} {α : Type w₂} {C : Type u} [CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C} [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct g] {p p' : α → β} {q : (a : α) → f a ⟶ g (p a)} {q' : (a : α) → f a ⟶ g (p' a)} (hp : p = p') (hq : ∀ (a : α), q a ≫ CategoryTheory.eqToHom ⋯ = q' a)
Goal: CategoryTheory.Limits.Sigma.map' p q = CategoryTheory.Limits.Sigma.map' p' q'
-- CategoryTheory.Limits.Pi.whiskerEquiv_hom
@[simps]
def Pi.whiskerEquiv {J K : Type*} {f : J → C} {g : K → C} (e : J ≃ K) (w : ∀ j, g (e j) ≅ f j)
    [HasProduct f] [HasProduct g] : ∏ᶜ f ≅ ∏ᶜ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C} (e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct g]
Goal: (CategoryTheory.Limits.Pi.whiskerEquiv e w).hom =
  CategoryTheory.Limits.Pi.map' ⇑e.symm fun k => (w (e.symm k)).inv ≫ CategoryTheory.eqToHom ⋯