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

full_name: CategoryTheory.Limits.Fan
code: /-- A fan over `f : β → C` consists of a collection of maps from an object `P` to every `f b`. -/
abbrev Fan (f : β → C) 
goal: Type (max (max w u) v)

full_name: CategoryTheory.Limits.Cofan
code: /-- A cofan over `f : β → C` consists of a collection of maps from every `f b` to an object `P`. -/
abbrev Cofan (f : β → C) 
goal: Type (max (max w u) v)

full_name: CategoryTheory.Limits.Fan.mk
code: /-- A fan over `f : β → C` consists of a collection of maps from an object `P` to every `f b`. -/
@[simps! pt π_app]
def Fan.mk {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) : Fan f 
goal: CategoryTheory.Limits.Fan f

full_name: CategoryTheory.Limits.Fan.mk_π_app
code: /-- A fan over `f : β → C` consists of a collection of maps from an object `P` to every `f b`. -/
@[simps! pt π_app]
def Fan.mk {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) : Fan f 
goal: (CategoryTheory.Limits.Fan.mk P p).π.app X = p X.as

full_name: CategoryTheory.Limits.Fan.mk_pt
code: /-- A fan over `f : β → C` consists of a collection of maps from an object `P` to every `f b`. -/
@[simps! pt π_app]
def Fan.mk {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) : Fan f 
goal: (CategoryTheory.Limits.Fan.mk P p).pt = P

full_name: CategoryTheory.Limits.Cofan.mk_pt
code: /-- A cofan over `f : β → C` consists of a collection of maps from every `f b` to an object `P`. -/
@[simps! pt ι_app]
def Cofan.mk {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) : Cofan f 
goal: (CategoryTheory.Limits.Cofan.mk P p).pt = P

full_name: CategoryTheory.Limits.Cofan.mk
code: /-- A cofan over `f : β → C` consists of a collection of maps from every `f b` to an object `P`. -/
@[simps! pt ι_app]
def Cofan.mk {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) : Cofan f 
goal: CategoryTheory.Limits.Cofan f

full_name: CategoryTheory.Limits.Cofan.mk_ι_app
code: /-- A cofan over `f : β → C` consists of a collection of maps from every `f b` to an object `P`. -/
@[simps! pt ι_app]
def Cofan.mk {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) : Cofan f 
goal: (CategoryTheory.Limits.Cofan.mk P p).ι.app X = p X.as

full_name: CategoryTheory.Limits.Fan.proj
code: /-- Get the `j`th "projection" in the fan.
(Note that the initial letter of `proj` matches the greek letter in `Cone.π`.) -/
def Fan.proj {f : β → C} (p : Fan f) (j : β) : p.pt ⟶ f j 
goal: p.pt ⟶ f j

full_name: CategoryTheory.Limits.Cofan.inj
code: /-- Get the `j`th "injection" in the cofan.
(Note that the initial letter of `inj` matches the greek letter in `Cocone.ι`.) -/
def Cofan.inj {f : β → C} (p : Cofan f) (j : β) : f j ⟶ p.pt 
goal: f j ⟶ p.pt

full_name: CategoryTheory.Limits.fan_mk_proj
code: @[simp]
theorem fan_mk_proj {f : β → C} (P : C) (p : ∀ b, P ⟶ f b) (j : β) : (Fan.mk P p).proj j = p j 
goal: (CategoryTheory.Limits.Fan.mk P p).proj j = p j

full_name: CategoryTheory.Limits.cofan_mk_inj
code: @[simp]
theorem cofan_mk_inj {f : β → C} (P : C) (p : ∀ b, f b ⟶ P) (j : β) :
    (Cofan.mk P p).inj j = p j 
goal: (CategoryTheory.Limits.Cofan.mk P p).inj j = p j

full_name: CategoryTheory.Limits.HasProduct
code: /-- An abbreviation for `HasLimit (Discrete.functor f)`. -/
abbrev HasProduct (f : β → C) 
goal: Prop

full_name: CategoryTheory.Limits.HasCoproduct
code: /-- An abbreviation for `HasColimit (Discrete.functor f)`. -/
abbrev HasCoproduct (f : β → C) 
goal: Prop

full_name: CategoryTheory.Limits.hasCoproduct_of_equiv_of_iso
code: lemma hasCoproduct_of_equiv_of_iso (f : α → C) (g : β → C)
    [HasCoproduct f] (e : β ≃ α) (iso : ∀ j, g j ≅ f (e j)) : HasCoproduct g 
goal: CategoryTheory.Limits.HasCoproduct g

full_name: CategoryTheory.Limits.hasProduct_of_equiv_of_iso
code: lemma hasProduct_of_equiv_of_iso (f : α → C) (g : β → C)
    [HasProduct f] (e : β ≃ α) (iso : ∀ j, g j ≅ f (e j)) : HasProduct g 
goal: CategoryTheory.Limits.HasProduct g

full_name: CategoryTheory.Limits.mkFanLimit_lift
code: /-- Make a fan `f` into a limit fan by providing `lift`, `fac`, and `uniq` --
  just a convenience lemma to avoid having to go through `Discrete` -/
@[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 
goal: (CategoryTheory.Limits.mkFanLimit t lift fac uniq).lift s = lift s

full_name: CategoryTheory.Limits.mkFanLimit
code: /-- Make a fan `f` into a limit fan by providing `lift`, `fac`, and `uniq` --
  just a convenience lemma to avoid having to go through `Discrete` -/
@[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 
goal: CategoryTheory.Limits.IsLimit t

full_name: CategoryTheory.Limits.Fan.IsLimit.desc
code: /-- Constructor for morphisms to the point of a limit fan. -/
def Fan.IsLimit.desc {F : β → C} {c : Fan F} (hc : IsLimit c) {A : C}
    (f : ∀ i, A ⟶ F i) : A ⟶ c.pt 
goal: A ⟶ c.pt

full_name: CategoryTheory.Limits.Fan.IsLimit.fac
code: @[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 
goal: CategoryTheory.Limits.Fan.IsLimit.desc hc f ≫ c.proj i = f i

full_name: CategoryTheory.Limits.Fan.IsLimit.hom_ext
code: 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 
goal: f = g

full_name: CategoryTheory.Limits.mkCofanColimit_desc
code: /-- Make a cofan `f` into a colimit cofan by providing `desc`, `fac`, and `uniq` --
  just a convenience lemma to avoid having to go through `Discrete` -/
@[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 
goal: (CategoryTheory.Limits.mkCofanColimit s desc fac uniq).desc t = desc t

full_name: CategoryTheory.Limits.mkCofanColimit
code: /-- Make a cofan `f` into a colimit cofan by providing `desc`, `fac`, and `uniq` --
  just a convenience lemma to avoid having to go through `Discrete` -/
@[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 
goal: CategoryTheory.Limits.IsColimit s

full_name: CategoryTheory.Limits.Cofan.IsColimit.desc
code: /-- Constructor for morphisms from the point of a colimit cofan. -/
def Cofan.IsColimit.desc {F : β → C} {c : Cofan F} (hc : IsColimit c) {A : C}
    (f : ∀ i, F i ⟶ A) : c.pt ⟶ A 
goal: c.pt ⟶ A

full_name: CategoryTheory.Limits.Cofan.IsColimit.fac
code: @[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 
goal: c.inj i ≫ CategoryTheory.Limits.Cofan.IsColimit.desc hc f = f i

full_name: CategoryTheory.Limits.Cofan.IsColimit.hom_ext
code: 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 
goal: f = g

full_name: CategoryTheory.Limits.HasProductsOfShape
code: /-- An abbreviation for `HasLimitsOfShape (Discrete f)`. -/
abbrev HasProductsOfShape (β : Type v) 
goal: Prop

full_name: CategoryTheory.Limits.HasCoproductsOfShape
code: /-- An abbreviation for `HasColimitsOfShape (Discrete f)`. -/
abbrev HasCoproductsOfShape (β : Type v) 
goal: Prop

full_name: CategoryTheory.Limits.piObj
code: /-- `piObj f` computes the product of a family of elements `f`.
(It is defined as an abbreviation for `limit (Discrete.functor f)`,
so for most facts about `piObj f`, you will just use general facts about limits.) -/
abbrev piObj (f : β → C) [HasProduct f] 
goal: C

full_name: CategoryTheory.Limits.sigmaObj
code: /-- `sigmaObj f` computes the coproduct of a family of elements `f`.
(It is defined as an abbreviation for `colimit (Discrete.functor f)`,
so for most facts about `sigmaObj f`, you will just use general facts about colimits.) -/
abbrev sigmaObj (f : β → C) [HasCoproduct f] 
goal: C

full_name: CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Products___unexpand_CategoryTheory_Limits_piObj_1
code: /-- notation for categorical products. We need `ᶜ` to avoid conflict with `Finset.prod`. -/
notation "∏ᶜ " f:60 => piObj f
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Products___macroRules_CategoryTheory_Limits_term∏ᶜ__1»
code: /-- notation for categorical products. We need `ᶜ` to avoid conflict with `Finset.prod`. -/
notation "∏ᶜ " f:60 => piObj f
goal: Lean.Macro

full_name: CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Products___unexpand_CategoryTheory_Limits_sigmaObj_1
code: /-- notation for categorical coproducts -/
notation "∐ " f:60 => sigmaObj f
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Products___macroRules_CategoryTheory_Limits_term∐__1»
code: /-- notation for categorical coproducts -/
notation "∐ " f:60 => sigmaObj f
goal: Lean.Macro

full_name: CategoryTheory.Limits.Pi.π
code: /-- The `b`-th projection from the pi object over `f` has the form `∏ᶜ f ⟶ f b`. -/
abbrev Pi.π (f : β → C) [HasProduct f] (b : β) : ∏ᶜ f ⟶ f b 
goal: ∏ᶜ f ⟶ f b

full_name: CategoryTheory.Limits.Sigma.ι
code: /-- The `b`-th inclusion into the sigma object over `f` has the form `f b ⟶ ∐ f`. -/
abbrev Sigma.ι (f : β → C) [HasCoproduct f] (b : β) : f b ⟶ ∐ f 
goal: f b ⟶ ∐ f

full_name: CategoryTheory.Limits.Pi.hom_ext
code: @[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₂ 
goal: g₁ = g₂

full_name: CategoryTheory.Limits.Sigma.hom_ext
code: @[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₂ 
goal: g₁ = g₂

full_name: CategoryTheory.Limits.productIsProduct
code: /-- The fan constructed of the projections from the product is limiting. -/
def productIsProduct (f : β → C) [HasProduct f] : IsLimit (Fan.mk _ (Pi.π f)) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fan.mk (∏ᶜ f) (CategoryTheory.Limits.Pi.π f))

full_name: CategoryTheory.Limits.coproductIsCoproduct
code: /-- The cofan constructed of the inclusions from the coproduct is colimiting. -/
def coproductIsCoproduct (f : β → C) [HasCoproduct f] : IsColimit (Cofan.mk _ (Sigma.ι f)) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofan.mk (∐ f) (CategoryTheory.Limits.Sigma.ι f))

full_name: CategoryTheory.Limits.Pi.π_comp_eqToHom
code: @[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' 
goal: CategoryTheory.Limits.Pi.π f j ≫ CategoryTheory.eqToHom ⋯ = CategoryTheory.Limits.Pi.π f j'

full_name: CategoryTheory.Limits.Sigma.eqToHom_comp_ι
code: @[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 
goal: CategoryTheory.eqToHom ⋯ ≫ CategoryTheory.Limits.Sigma.ι f j' = CategoryTheory.Limits.Sigma.ι f j

full_name: CategoryTheory.Limits.Pi.lift
code: /-- A collection of morphisms `P ⟶ f b` induces a morphism `P ⟶ ∏ᶜ f`. -/
abbrev Pi.lift {f : β → C} [HasProduct f] {P : C} (p : ∀ b, P ⟶ f b) : P ⟶ ∏ᶜ f 
goal: P ⟶ ∏ᶜ f

full_name: CategoryTheory.Limits.Pi.lift_π
code: 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 
goal: CategoryTheory.Limits.Pi.lift p ≫ CategoryTheory.Limits.Pi.π f b = p b

full_name: CategoryTheory.Limits.Sigma.desc
code: /-- A collection of morphisms `f b ⟶ P` induces a morphism `∐ f ⟶ P`. -/
abbrev Sigma.desc {f : β → C} [HasCoproduct f] {P : C} (p : ∀ b, f b ⟶ P) : ∐ f ⟶ P 
goal: ∐ f ⟶ P

full_name: CategoryTheory.Limits.Sigma.ι_desc
code: 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 
goal: CategoryTheory.Limits.Sigma.ι f b ≫ CategoryTheory.Limits.Sigma.desc p = p b

full_name: CategoryTheory.Limits.instIsIsoDescι
code: instance {f : β → C} [HasCoproduct f] : IsIso (Sigma.desc (fun a ↦ Sigma.ι f a)) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc fun a => CategoryTheory.Limits.Sigma.ι f a)

full_name: CategoryTheory.Limits.Cofan.ext_inv_hom
code: /-- A version of `Cocones.ext` for `Cofan`s. -/
@[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₂ 
goal: (CategoryTheory.Limits.Cofan.ext e w).inv.hom = e.inv

full_name: CategoryTheory.Limits.Cofan.ext
code: /-- A version of `Cocones.ext` for `Cofan`s. -/
@[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₂ 
goal: c₁ ≅ c₂

full_name: CategoryTheory.Limits.Cofan.ext_hom_hom
code: /-- A version of `Cocones.ext` for `Cofan`s. -/
@[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₂ 
goal: (CategoryTheory.Limits.Cofan.ext e w).hom.hom = e.hom

full_name: CategoryTheory.Limits.Cofan.isColimitOfIsIsoSigmaDesc
code: /-- A cofan `c` on `f` such that the induced map `∐ f ⟶ c.pt` is an iso, is a coproduct. -/
def Cofan.isColimitOfIsIsoSigmaDesc {f : β → C} [HasCoproduct f] (c : Cofan f)
    [hc : IsIso (Sigma.desc c.inj)] : IsColimit c 
goal: CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.Cofan.isColimit_iff_isIso_sigmaDesc
code: lemma Cofan.isColimit_iff_isIso_sigmaDesc {f : β → C} [HasCoproduct f] (c : Cofan f) :
    IsIso (Sigma.desc c.inj) ↔ Nonempty (IsColimit c) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc c.inj) ↔ Nonempty (CategoryTheory.Limits.IsColimit c)

full_name: CategoryTheory.Limits.Cofan.isColimitTrans
code: /-- A coproduct of coproducts is a coproduct -/
def Cofan.isColimitTrans {X : α → C} (c : Cofan X) (hc : IsColimit c)
    {β : α → Type*} {Y : (a : α) → β a → C} (π : (a : α) → (b : β a) → Y a b ⟶ X a)
      (hs : ∀ a, IsColimit (Cofan.mk (X a) (π a))) :
        IsColimit (Cofan.mk (f := fun ⟨a,b⟩ => Y a b) c.pt
          (fun (⟨a, b⟩ : Σ a, _) ↦ π a b ≫ c.inj a)) 
goal: CategoryTheory.Limits.IsColimit
  (CategoryTheory.Limits.Cofan.mk c.pt fun x =>
    match x with
    | ⟨a, b⟩ => π a b ≫ c.inj a)

full_name: CategoryTheory.Limits.Pi.map
code: /-- Construct a morphism between categorical products (indexed by the same type)
from a family of morphisms between the factors.
-/
abbrev Pi.map {f g : β → C} [HasProduct f] [HasProduct g] (p : ∀ b, f b ⟶ g b) : ∏ᶜ f ⟶ ∏ᶜ g 
goal: ∏ᶜ f ⟶ ∏ᶜ g

full_name: CategoryTheory.Limits.Pi.map_id
code: @[simp]
lemma Pi.map_id {f : α → C} [HasProduct f] : Pi.map (fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f) 
goal: (CategoryTheory.Limits.Pi.map fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f)

full_name: CategoryTheory.Limits.Pi.map_comp_map
code: 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) 
goal: CategoryTheory.Limits.Pi.map q ≫ CategoryTheory.Limits.Pi.map q' = CategoryTheory.Limits.Pi.map fun a => q a ≫ q' a

full_name: CategoryTheory.Limits.Pi.map_mono
code: instance Pi.map_mono {f g : β → C} [HasProduct f] [HasProduct g] (p : ∀ b, f b ⟶ g b)
    [∀ i, Mono (p i)] : Mono <| Pi.map p 
goal: CategoryTheory.Mono (CategoryTheory.Limits.Pi.map p)

full_name: CategoryTheory.Limits.Pi.map'
code: /-- Construct a morphism between categorical products from a family of morphisms between the
    factors. -/
def Pi.map' {f : α → C} {g : β → C} [HasProduct f] [HasProduct g] (p : β → α)
    (q : ∀ (b : β), f (p b) ⟶ g b) : ∏ᶜ f ⟶ ∏ᶜ g 
goal: ∏ᶜ f ⟶ ∏ᶜ g

full_name: CategoryTheory.Limits.Pi.map'_comp_π
code: @[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 
goal: CategoryTheory.Limits.Pi.map' p q ≫ CategoryTheory.Limits.Pi.π g b = CategoryTheory.Limits.Pi.π f (p b) ≫ q b

full_name: CategoryTheory.Limits.Pi.map'_id_id
code: lemma Pi.map'_id_id {f : α → C} [HasProduct f] : Pi.map' id (fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f) 
goal: (CategoryTheory.Limits.Pi.map' id fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f)

full_name: CategoryTheory.Limits.Pi.map'_id
code: @[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 
goal: CategoryTheory.Limits.Pi.map' id p = CategoryTheory.Limits.Pi.map p

full_name: CategoryTheory.Limits.Pi.map'_comp_map'
code: 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) 
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

full_name: CategoryTheory.Limits.Pi.map'_comp_map
code: 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) 
goal: CategoryTheory.Limits.Pi.map' p q ≫ CategoryTheory.Limits.Pi.map q' =
  CategoryTheory.Limits.Pi.map' p fun b => q b ≫ q' b

full_name: CategoryTheory.Limits.Pi.map_comp_map'
code: 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) 
goal: CategoryTheory.Limits.Pi.map q ≫ CategoryTheory.Limits.Pi.map' p q' =
  CategoryTheory.Limits.Pi.map' p fun b => q (p b) ≫ q' b

full_name: CategoryTheory.Limits.Pi.map'_eq
code: 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' 
goal: CategoryTheory.Limits.Pi.map' p q = CategoryTheory.Limits.Pi.map' p' q'

full_name: CategoryTheory.Limits.Pi.mapIso
code: /-- Construct an isomorphism between categorical products (indexed by the same type)
from a family of isomorphisms between the factors.
-/
abbrev Pi.mapIso {f g : β → C} [HasProductsOfShape β C] (p : ∀ b, f b ≅ g b) : ∏ᶜ f ≅ ∏ᶜ g 
goal: ∏ᶜ f ≅ ∏ᶜ g

full_name: CategoryTheory.Limits.Pi.cone_pt
code: /-- A limit cone for `X : Discrete α ⥤ C` that is given
by `∏ᶜ (fun j => X.obj (Discrete.mk j))`. -/
@[simps]
def Pi.cone : Cone X 
goal: (CategoryTheory.Limits.Pi.cone X).pt = ∏ᶜ fun j => X.obj { as := j }

full_name: CategoryTheory.Limits.Pi.cone
code: /-- A limit cone for `X : Discrete α ⥤ C` that is given
by `∏ᶜ (fun j => X.obj (Discrete.mk j))`. -/
@[simps]
def Pi.cone : Cone X 
goal: CategoryTheory.Limits.Cone X

full_name: CategoryTheory.Limits.Pi.cone_π
code: /-- A limit cone for `X : Discrete α ⥤ C` that is given
by `∏ᶜ (fun j => X.obj (Discrete.mk j))`. -/
@[simps]
def Pi.cone : Cone X 
goal: (CategoryTheory.Limits.Pi.cone X).π =
  CategoryTheory.Discrete.natTrans fun x => CategoryTheory.Limits.Pi.π (fun j => X.obj { as := j }) x.as

full_name: CategoryTheory.Limits.productIsProduct'
code: /-- The cone `Pi.cone X` is a limit cone. -/
def productIsProduct' :
    IsLimit (Pi.cone X) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Pi.cone X)

full_name: CategoryTheory.Limits.Pi.isoLimit
code: /-- The isomorphism `∏ᶜ (fun j => X.obj (Discrete.mk j)) ≅ limit X`. -/
def Pi.isoLimit :
    ∏ᶜ (fun j => X.obj (Discrete.mk j)) ≅ limit X 
goal: (∏ᶜ fun j => X.obj { as := j }) ≅ CategoryTheory.Limits.limit X

full_name: CategoryTheory.Limits.Pi.isoLimit_inv_π
code: @[reassoc (attr := simp)]
lemma Pi.isoLimit_inv_π (j : α) :
    (Pi.isoLimit X).inv ≫ Pi.π _ j = limit.π _ (Discrete.mk j) 
goal: (CategoryTheory.Limits.Pi.isoLimit X).inv ≫ CategoryTheory.Limits.Pi.π (fun j => X.obj { as := j }) j =
  CategoryTheory.Limits.limit.π X { as := j }

full_name: CategoryTheory.Limits.Pi.isoLimit_hom_π
code: @[reassoc (attr := simp)]
lemma Pi.isoLimit_hom_π (j : α) :
    (Pi.isoLimit X).hom ≫ limit.π _ (Discrete.mk j) = Pi.π _ j 
goal: (CategoryTheory.Limits.Pi.isoLimit X).hom ≫ CategoryTheory.Limits.limit.π X { as := j } =
  CategoryTheory.Limits.Pi.π (fun j => X.obj { as := j }) j

full_name: CategoryTheory.Limits.Sigma.map
code: /-- Construct a morphism between categorical coproducts (indexed by the same type)
from a family of morphisms between the factors.
-/
abbrev Sigma.map {f g : β → C} [HasCoproduct f] [HasCoproduct g] (p : ∀ b, f b ⟶ g b) :
    ∐ f ⟶ ∐ g 
goal: ∐ f ⟶ ∐ g

full_name: CategoryTheory.Limits.Sigma.map_id
code: @[simp]
lemma Sigma.map_id {f : α → C} [HasCoproduct f] : Sigma.map (fun a => 𝟙 (f a)) = 𝟙 (∐ f) 
goal: (CategoryTheory.Limits.Sigma.map fun a => 𝟙 (f a)) = 𝟙 (∐ f)

full_name: CategoryTheory.Limits.Sigma.map_comp_map
code: 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) 
goal: CategoryTheory.Limits.Sigma.map q ≫ CategoryTheory.Limits.Sigma.map q' =
  CategoryTheory.Limits.Sigma.map fun a => q a ≫ q' a

full_name: CategoryTheory.Limits.Sigma.map_epi
code: instance Sigma.map_epi {f g : β → C} [HasCoproduct f] [HasCoproduct g] (p : ∀ b, f b ⟶ g b)
    [∀ i, Epi (p i)] : Epi <| Sigma.map p 
goal: CategoryTheory.Epi (CategoryTheory.Limits.Sigma.map p)

full_name: CategoryTheory.Limits.Sigma.map'
code: /-- Construct a morphism between categorical coproducts from a family of morphisms between the
    factors. -/
def Sigma.map' {f : α → C} {g : β → C} [HasCoproduct f] [HasCoproduct g] (p : α → β)
    (q : ∀ (a : α), f a ⟶ g (p a)) : ∐ f ⟶ ∐ g 
goal: ∐ f ⟶ ∐ g

full_name: CategoryTheory.Limits.Sigma.ι_comp_map'
code: @[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) 
goal: CategoryTheory.Limits.Sigma.ι f a ≫ CategoryTheory.Limits.Sigma.map' p q = q a ≫ CategoryTheory.Limits.Sigma.ι g (p a)

full_name: CategoryTheory.Limits.Sigma.map'_id_id
code: lemma Sigma.map'_id_id {f : α → C} [HasCoproduct f] :
    Sigma.map' id (fun a => 𝟙 (f a)) = 𝟙 (∐ f) 
goal: (CategoryTheory.Limits.Sigma.map' id fun a => 𝟙 (f a)) = 𝟙 (∐ f)

full_name: CategoryTheory.Limits.Sigma.map'_id
code: @[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 
goal: CategoryTheory.Limits.Sigma.map' id p = CategoryTheory.Limits.Sigma.map p

full_name: CategoryTheory.Limits.Sigma.map'_comp_map'
code: 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)) 
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)

full_name: CategoryTheory.Limits.Sigma.map'_comp_map
code: 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)) 
goal: CategoryTheory.Limits.Sigma.map' p q ≫ CategoryTheory.Limits.Sigma.map q' =
  CategoryTheory.Limits.Sigma.map' p fun a => q a ≫ q' (p a)

full_name: CategoryTheory.Limits.Sigma.map_comp_map'
code: 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) 
goal: CategoryTheory.Limits.Sigma.map q ≫ CategoryTheory.Limits.Sigma.map' p q' =
  CategoryTheory.Limits.Sigma.map' p fun a => q a ≫ q' a

full_name: CategoryTheory.Limits.Sigma.map'_eq
code: 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' 
goal: CategoryTheory.Limits.Sigma.map' p q = CategoryTheory.Limits.Sigma.map' p' q'

full_name: CategoryTheory.Limits.Sigma.mapIso
code: /-- Construct an isomorphism between categorical coproducts (indexed by the same type)
from a family of isomorphisms between the factors.
-/
abbrev Sigma.mapIso {f g : β → C} [HasCoproductsOfShape β C] (p : ∀ b, f b ≅ g b) : ∐ f ≅ ∐ g 
goal: ∐ f ≅ ∐ g

full_name: CategoryTheory.Limits.Pi.whiskerEquiv
code: /-- Two products which differ by an equivalence in the indexing type,
and up to isomorphism in the factors, are isomorphic.
-/
@[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 
goal: ∏ᶜ f ≅ ∏ᶜ g

full_name: CategoryTheory.Limits.Pi.whiskerEquiv_hom
code: /-- Two products which differ by an equivalence in the indexing type,
and up to isomorphism in the factors, are isomorphic.
-/
@[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 
goal: (CategoryTheory.Limits.Pi.whiskerEquiv e w).hom =
  CategoryTheory.Limits.Pi.map' ⇑e.symm fun k => (w (e.symm k)).inv ≫ CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Limits.Pi.whiskerEquiv_inv
code: /-- Two products which differ by an equivalence in the indexing type,
and up to isomorphism in the factors, are isomorphic.
-/
@[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 
goal: (CategoryTheory.Limits.Pi.whiskerEquiv e w).inv = CategoryTheory.Limits.Pi.map' ⇑e fun j => (w j).hom

full_name: CategoryTheory.Limits.Sigma.whiskerEquiv_inv
code: /-- Two coproducts which differ by an equivalence in the indexing type,
and up to isomorphism in the factors, are isomorphic.
-/
@[simps]
def Sigma.whiskerEquiv {J K : Type*} {f : J → C} {g : K → C} (e : J ≃ K) (w : ∀ j, g (e j) ≅ f j)
    [HasCoproduct f] [HasCoproduct g] : ∐ f ≅ ∐ g 
goal: (CategoryTheory.Limits.Sigma.whiskerEquiv e w).inv =
  CategoryTheory.Limits.Sigma.map' ⇑e.symm fun k => CategoryTheory.eqToHom ⋯ ≫ (w (e.symm k)).hom

full_name: CategoryTheory.Limits.Sigma.whiskerEquiv_hom
code: /-- Two coproducts which differ by an equivalence in the indexing type,
and up to isomorphism in the factors, are isomorphic.
-/
@[simps]
def Sigma.whiskerEquiv {J K : Type*} {f : J → C} {g : K → C} (e : J ≃ K) (w : ∀ j, g (e j) ≅ f j)
    [HasCoproduct f] [HasCoproduct g] : ∐ f ≅ ∐ g 
goal: (CategoryTheory.Limits.Sigma.whiskerEquiv e w).hom = CategoryTheory.Limits.Sigma.map' ⇑e fun j => (w j).inv

full_name: CategoryTheory.Limits.Sigma.whiskerEquiv
code: /-- Two coproducts which differ by an equivalence in the indexing type,
and up to isomorphism in the factors, are isomorphic.
-/
@[simps]
def Sigma.whiskerEquiv {J K : Type*} {f : J → C} {g : K → C} (e : J ≃ K) (w : ∀ j, g (e j) ≅ f j)
    [HasCoproduct f] [HasCoproduct g] : ∐ f ≅ ∐ g 
goal: ∐ f ≅ ∐ g

full_name: CategoryTheory.Limits.instHasProductSigmaFstSndOfPiObj
code: instance {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasProduct (g i)] [HasProduct fun i => ∏ᶜ g i] :
    HasProduct fun p : Σ i, f i => g p.1 p.2 
goal: CategoryTheory.Limits.HasProduct fun p => g p.fst p.snd

full_name: CategoryTheory.Limits.piPiIso
code: /-- An iterated product is a product over a sigma type. -/
@[simps]
def piPiIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasProduct (g i)] [HasProduct fun i => ∏ᶜ g i] :
    (∏ᶜ fun i => ∏ᶜ g i) ≅ (∏ᶜ fun p : Σ i, f i => g p.1 p.2) 
goal: (∏ᶜ fun i => ∏ᶜ g i) ≅ ∏ᶜ fun p => g p.fst p.snd

full_name: CategoryTheory.Limits.piPiIso_inv
code: /-- An iterated product is a product over a sigma type. -/
@[simps]
def piPiIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasProduct (g i)] [HasProduct fun i => ∏ᶜ g i] :
    (∏ᶜ fun i => ∏ᶜ g i) ≅ (∏ᶜ fun p : Σ i, f i => g p.1 p.2) 
goal: (CategoryTheory.Limits.piPiIso f g).inv =
  CategoryTheory.Limits.Pi.lift fun i =>
    CategoryTheory.Limits.Pi.lift fun x => CategoryTheory.Limits.Pi.π (fun p => g p.fst p.snd) ⟨i, x⟩

full_name: CategoryTheory.Limits.piPiIso_hom
code: /-- An iterated product is a product over a sigma type. -/
@[simps]
def piPiIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasProduct (g i)] [HasProduct fun i => ∏ᶜ g i] :
    (∏ᶜ fun i => ∏ᶜ g i) ≅ (∏ᶜ fun p : Σ i, f i => g p.1 p.2) 
goal: (CategoryTheory.Limits.piPiIso f g).hom =
  CategoryTheory.Limits.Pi.lift fun x =>
    match x with
    | ⟨i, x⟩ => CategoryTheory.Limits.Pi.π (fun i => ∏ᶜ g i) i ≫ CategoryTheory.Limits.Pi.π (g i) x

full_name: CategoryTheory.Limits.instHasCoproductSigmaFstSndOfSigmaObj
code: instance {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasCoproduct (g i)] [HasCoproduct fun i => ∐ g i] :
    HasCoproduct fun p : Σ i, f i => g p.1 p.2 
goal: CategoryTheory.Limits.HasCoproduct fun p => g p.fst p.snd

full_name: CategoryTheory.Limits.sigmaSigmaIso_hom
code: /-- An iterated coproduct is a coproduct over a sigma type. -/
@[simps]
def sigmaSigmaIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasCoproduct (g i)] [HasCoproduct fun i => ∐ g i] :
    (∐ fun i => ∐ g i) ≅ (∐ fun p : Σ i, f i => g p.1 p.2) 
goal: (CategoryTheory.Limits.sigmaSigmaIso f g).hom =
  CategoryTheory.Limits.Sigma.desc fun i =>
    CategoryTheory.Limits.Sigma.desc fun x => CategoryTheory.Limits.Sigma.ι (fun p => g p.fst p.snd) ⟨i, x⟩

full_name: CategoryTheory.Limits.sigmaSigmaIso
code: /-- An iterated coproduct is a coproduct over a sigma type. -/
@[simps]
def sigmaSigmaIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasCoproduct (g i)] [HasCoproduct fun i => ∐ g i] :
    (∐ fun i => ∐ g i) ≅ (∐ fun p : Σ i, f i => g p.1 p.2) 
goal: (∐ fun i => ∐ g i) ≅ ∐ fun p => g p.fst p.snd

full_name: CategoryTheory.Limits.sigmaSigmaIso_inv
code: /-- An iterated coproduct is a coproduct over a sigma type. -/
@[simps]
def sigmaSigmaIso {ι : Type*} (f : ι → Type*) (g : (i : ι) → (f i) → C)
    [∀ i, HasCoproduct (g i)] [HasCoproduct fun i => ∐ g i] :
    (∐ fun i => ∐ g i) ≅ (∐ fun p : Σ i, f i => g p.1 p.2) 
goal: (CategoryTheory.Limits.sigmaSigmaIso f g).inv =
  CategoryTheory.Limits.Sigma.desc fun x =>
    match x with
    | ⟨i, x⟩ => CategoryTheory.Limits.Sigma.ι (g i) x ≫ CategoryTheory.Limits.Sigma.ι (fun i => ∐ g i) i

full_name: CategoryTheory.Limits.piComparison
code: /-- The comparison morphism for the product of `f`. This is an iso iff `G` preserves the product
of `f`, see `PreservesProduct.ofIsoComparison`. -/
def piComparison [HasProduct f] [HasProduct fun b => G.obj (f b)] :
    G.obj (∏ᶜ f) ⟶ ∏ᶜ fun b => G.obj (f b) 
goal: G.obj (∏ᶜ f) ⟶ ∏ᶜ fun b => G.obj (f b)

full_name: CategoryTheory.Limits.piComparison_comp_π
code: @[reassoc (attr := simp)]
theorem piComparison_comp_π [HasProduct f] [HasProduct fun b => G.obj (f b)] (b : β) :
    piComparison G f ≫ Pi.π _ b = G.map (Pi.π f b) 
goal: CategoryTheory.Limits.piComparison G f ≫ CategoryTheory.Limits.Pi.π (fun b => G.obj (f b)) b =
  G.map (CategoryTheory.Limits.Pi.π f b)

full_name: CategoryTheory.Limits.map_lift_piComparison
code: @[reassoc (attr := simp)]
theorem map_lift_piComparison [HasProduct f] [HasProduct fun b => G.obj (f b)] (P : C)
    (g : ∀ j, P ⟶ f j) : G.map (Pi.lift g) ≫ piComparison G f = Pi.lift fun j => G.map (g j) 
goal: G.map (CategoryTheory.Limits.Pi.lift g) ≫ CategoryTheory.Limits.piComparison G f =
  CategoryTheory.Limits.Pi.lift fun j => G.map (g j)

full_name: CategoryTheory.Limits.sigmaComparison
code: /-- The comparison morphism for the coproduct of `f`. This is an iso iff `G` preserves the coproduct
of `f`, see `PreservesCoproduct.ofIsoComparison`. -/
def sigmaComparison [HasCoproduct f] [HasCoproduct fun b => G.obj (f b)] :
    ∐ (fun b => G.obj (f b)) ⟶ G.obj (∐ f) 
goal: (∐ fun b => G.obj (f b)) ⟶ G.obj (∐ f)

full_name: CategoryTheory.Limits.ι_comp_sigmaComparison
code: @[reassoc (attr := simp)]
theorem ι_comp_sigmaComparison [HasCoproduct f] [HasCoproduct fun b => G.obj (f b)] (b : β) :
    Sigma.ι _ b ≫ sigmaComparison G f = G.map (Sigma.ι f b) 
goal: CategoryTheory.Limits.Sigma.ι (fun b => G.obj (f b)) b ≫ CategoryTheory.Limits.sigmaComparison G f =
  G.map (CategoryTheory.Limits.Sigma.ι f b)

full_name: CategoryTheory.Limits.sigmaComparison_map_desc
code: @[reassoc (attr := simp)]
theorem sigmaComparison_map_desc [HasCoproduct f] [HasCoproduct fun b => G.obj (f b)] (P : C)
    (g : ∀ j, f j ⟶ P) :
    sigmaComparison G f ≫ G.map (Sigma.desc g) = Sigma.desc fun j => G.map (g j) 
goal: CategoryTheory.Limits.sigmaComparison G f ≫ G.map (CategoryTheory.Limits.Sigma.desc g) =
  CategoryTheory.Limits.Sigma.desc fun j => G.map (g j)

full_name: CategoryTheory.Limits.HasProducts
code: /-- An abbreviation for `Π J, HasLimitsOfShape (Discrete J) C` -/
abbrev HasProducts 
goal: Prop

full_name: CategoryTheory.Limits.HasCoproducts
code: /-- An abbreviation for `Π J, HasColimitsOfShape (Discrete J) C` -/
abbrev HasCoproducts 
goal: Prop

full_name: CategoryTheory.Limits.has_smallest_products_of_hasProducts
code: theorem has_smallest_products_of_hasProducts [HasProducts.{w} C] : HasProducts.{0} C 
goal: CategoryTheory.Limits.HasProducts C

full_name: CategoryTheory.Limits.has_smallest_coproducts_of_hasCoproducts
code: theorem has_smallest_coproducts_of_hasCoproducts [HasCoproducts.{w} C] : HasCoproducts.{0} C 
goal: CategoryTheory.Limits.HasCoproducts C

full_name: CategoryTheory.Limits.hasProducts_of_limit_fans
code: theorem hasProducts_of_limit_fans (lf : ∀ {J : Type w} (f : J → C), Fan f)
    (lf_isLimit : ∀ {J : Type w} (f : J → C), IsLimit (lf f)) : HasProducts.{w} C 
goal: CategoryTheory.Limits.HasProducts C

full_name: CategoryTheory.Limits.limitConeOfUnique_cone_pt
code: /-- The limit cone for the product over an index type with exactly one term. -/
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f) 
goal: (CategoryTheory.Limits.limitConeOfUnique f).cone.pt = f default

full_name: CategoryTheory.Limits.limitConeOfUnique_cone_π
code: /-- The limit cone for the product over an index type with exactly one term. -/
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f) 
goal: (CategoryTheory.Limits.limitConeOfUnique f).cone.π =
  CategoryTheory.Discrete.natTrans fun x =>
    match x with
    | { as := j } => CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Limits.limitConeOfUnique
code: /-- The limit cone for the product over an index type with exactly one term. -/
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor f)

full_name: CategoryTheory.Limits.limitConeOfUnique_isLimit_lift
code: /-- The limit cone for the product over an index type with exactly one term. -/
@[simps]
def limitConeOfUnique : LimitCone (Discrete.functor f) 
goal: (CategoryTheory.Limits.limitConeOfUnique f).isLimit.lift s = s.π.app default

full_name: CategoryTheory.Limits.hasProduct_unique
code: instance (priority := 100) hasProduct_unique : HasProduct f 
goal: CategoryTheory.Limits.HasProduct f

full_name: CategoryTheory.Limits.productUniqueIso_hom
code: /-- A product over an index type with exactly one term is just the object over that term. -/
@[simps!]
def productUniqueIso : ∏ᶜ f ≅ f default 
goal: (CategoryTheory.Limits.productUniqueIso f).hom =
  CategoryTheory.Limits.limit.π (CategoryTheory.Discrete.functor f) default

full_name: CategoryTheory.Limits.productUniqueIso_inv
code: /-- A product over an index type with exactly one term is just the object over that term. -/
@[simps!]
def productUniqueIso : ∏ᶜ f ≅ f default 
goal: (CategoryTheory.Limits.productUniqueIso f).inv =
  CategoryTheory.Limits.limit.lift (CategoryTheory.Discrete.functor f) (CategoryTheory.Limits.limitConeOfUnique f).cone

full_name: CategoryTheory.Limits.productUniqueIso
code: /-- A product over an index type with exactly one term is just the object over that term. -/
@[simps!]
def productUniqueIso : ∏ᶜ f ≅ f default 
goal: ∏ᶜ f ≅ f default

full_name: CategoryTheory.Limits.colimitCoconeOfUnique_cocone_pt
code: /-- The colimit cocone for the coproduct over an index type with exactly one term. -/
@[simps]
def colimitCoconeOfUnique : ColimitCocone (Discrete.functor f) 
goal: (CategoryTheory.Limits.colimitCoconeOfUnique f).cocone.pt = f default

full_name: CategoryTheory.Limits.colimitCoconeOfUnique_cocone_ι
code: /-- The colimit cocone for the coproduct over an index type with exactly one term. -/
@[simps]
def colimitCoconeOfUnique : ColimitCocone (Discrete.functor f) 
goal: (CategoryTheory.Limits.colimitCoconeOfUnique f).cocone.ι =
  CategoryTheory.Discrete.natTrans fun x =>
    match x with
    | { as := j } => CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Limits.colimitCoconeOfUnique
code: /-- The colimit cocone for the coproduct over an index type with exactly one term. -/
@[simps]
def colimitCoconeOfUnique : ColimitCocone (Discrete.functor f) 
goal: CategoryTheory.Limits.ColimitCocone (CategoryTheory.Discrete.functor f)

full_name: CategoryTheory.Limits.colimitCoconeOfUnique_isColimit_desc
code: /-- The colimit cocone for the coproduct over an index type with exactly one term. -/
@[simps]
def colimitCoconeOfUnique : ColimitCocone (Discrete.functor f) 
goal: (CategoryTheory.Limits.colimitCoconeOfUnique f).isColimit.desc s = s.ι.app default

full_name: CategoryTheory.Limits.hasCoproduct_unique
code: instance (priority := 100) hasCoproduct_unique : HasCoproduct f 
goal: CategoryTheory.Limits.HasCoproduct f

full_name: CategoryTheory.Limits.coproductUniqueIso_inv
code: /-- A coproduct over an index type with exactly one term is just the object over that term. -/
@[simps!]
def coproductUniqueIso : ∐ f ≅ f default 
goal: (CategoryTheory.Limits.coproductUniqueIso f).inv =
  CategoryTheory.Limits.colimit.ι (CategoryTheory.Discrete.functor f) default

full_name: CategoryTheory.Limits.coproductUniqueIso_hom
code: /-- A coproduct over an index type with exactly one term is just the object over that term. -/
@[simps!]
def coproductUniqueIso : ∐ f ≅ f default 
goal: (CategoryTheory.Limits.coproductUniqueIso f).hom =
  CategoryTheory.Limits.colimit.desc (CategoryTheory.Discrete.functor f)
    (CategoryTheory.Limits.colimitCoconeOfUnique f).cocone

full_name: CategoryTheory.Limits.coproductUniqueIso
code: /-- A coproduct over an index type with exactly one term is just the object over that term. -/
@[simps!]
def coproductUniqueIso : ∐ f ≅ f default 
goal: ∐ f ≅ f default

full_name: CategoryTheory.Limits.Pi.reindex
code: /-- Reindex a categorical product via an equivalence of the index types. -/
def Pi.reindex : piObj (f ∘ ε) ≅ piObj f 
goal: ∏ᶜ f ∘ ⇑ε ≅ ∏ᶜ f

full_name: CategoryTheory.Limits.Pi.reindex_hom_π
code: @[reassoc (attr := simp)]
theorem Pi.reindex_hom_π (b : β) : (Pi.reindex ε f).hom ≫ Pi.π f (ε b) = Pi.π (f ∘ ε) b 
goal: (CategoryTheory.Limits.Pi.reindex ε f).hom ≫ CategoryTheory.Limits.Pi.π f (ε b) = CategoryTheory.Limits.Pi.π (f ∘ ⇑ε) b

full_name: CategoryTheory.Limits.Pi.reindex_inv_π
code: @[reassoc (attr := simp)]
theorem Pi.reindex_inv_π (b : β) : (Pi.reindex ε f).inv ≫ Pi.π (f ∘ ε) b = Pi.π f (ε b) 
goal: (CategoryTheory.Limits.Pi.reindex ε f).inv ≫ CategoryTheory.Limits.Pi.π (f ∘ ⇑ε) b = CategoryTheory.Limits.Pi.π f (ε b)

full_name: CategoryTheory.Limits.Sigma.reindex
code: /-- Reindex a categorical coproduct via an equivalence of the index types. -/
def Sigma.reindex : sigmaObj (f ∘ ε) ≅ sigmaObj f 
goal: ∐ f ∘ ⇑ε ≅ ∐ f

full_name: CategoryTheory.Limits.Sigma.ι_reindex_hom
code: @[reassoc (attr := simp)]
theorem Sigma.ι_reindex_hom (b : β) :
    Sigma.ι (f ∘ ε) b ≫ (Sigma.reindex ε f).hom = Sigma.ι f (ε b) 
goal: CategoryTheory.Limits.Sigma.ι (f ∘ ⇑ε) b ≫ (CategoryTheory.Limits.Sigma.reindex ε f).hom =
  CategoryTheory.Limits.Sigma.ι f (ε b)

full_name: CategoryTheory.Limits.Sigma.ι_reindex_inv
code: @[reassoc (attr := simp)]
theorem Sigma.ι_reindex_inv (b : β) :
    Sigma.ι f (ε b) ≫ (Sigma.reindex ε f).inv = Sigma.ι (f ∘ ε) b 
goal: CategoryTheory.Limits.Sigma.ι f (ε b) ≫ (CategoryTheory.Limits.Sigma.reindex ε f).inv =
  CategoryTheory.Limits.Sigma.ι (f ∘ ⇑ε) b