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

full_name: CategoryTheory.Limits.WalkingMulticospan.left
code: /-- The type underlying the multiequalizer diagram. -/
--@[nolint unused_arguments]
inductive WalkingMulticospan {L R : Type w} (fst snd : R → L) : Type w
  | left : L → WalkingMulticospan fst snd
  | right : R → WalkingMulticospan fst snd
goal: L → CategoryTheory.Limits.WalkingMulticospan fst snd

full_name: CategoryTheory.Limits.WalkingMulticospan.right
code: /-- The type underlying the multiequalizer diagram. -/
--@[nolint unused_arguments]
inductive WalkingMulticospan {L R : Type w} (fst snd : R → L) : Type w
  | left : L → WalkingMulticospan fst snd
  | right : R → WalkingMulticospan fst snd
goal: R → CategoryTheory.Limits.WalkingMulticospan fst snd

full_name: CategoryTheory.Limits.WalkingMulticospan
code: /-- The type underlying the multiequalizer diagram. -/
--@[nolint unused_arguments]
inductive WalkingMulticospan {L R : Type w} (fst snd : R → L) : Type w
  | left : L → WalkingMulticospan fst snd
  | right : R → WalkingMulticospan fst snd
goal: Type w

full_name: CategoryTheory.Limits.WalkingMultispan.right
code: /-- The type underlying the multiecoqualizer diagram. -/
--@[nolint unused_arguments]
inductive WalkingMultispan {L R : Type w} (fst snd : L → R) : Type w
  | left : L → WalkingMultispan fst snd
  | right : R → WalkingMultispan fst snd
goal: R → CategoryTheory.Limits.WalkingMultispan fst snd

full_name: CategoryTheory.Limits.WalkingMultispan
code: /-- The type underlying the multiecoqualizer diagram. -/
--@[nolint unused_arguments]
inductive WalkingMultispan {L R : Type w} (fst snd : L → R) : Type w
  | left : L → WalkingMultispan fst snd
  | right : R → WalkingMultispan fst snd
goal: Type w

full_name: CategoryTheory.Limits.WalkingMultispan.left
code: /-- The type underlying the multiecoqualizer diagram. -/
--@[nolint unused_arguments]
inductive WalkingMultispan {L R : Type w} (fst snd : L → R) : Type w
  | left : L → WalkingMultispan fst snd
  | right : R → WalkingMultispan fst snd
goal: L → CategoryTheory.Limits.WalkingMultispan fst snd

full_name: CategoryTheory.Limits.WalkingMulticospan.instInhabited
code: instance [Inhabited L] : Inhabited (WalkingMulticospan fst snd) 
goal: Inhabited (CategoryTheory.Limits.WalkingMulticospan fst snd)

full_name: CategoryTheory.Limits.WalkingMulticospan.Hom.snd
code: /-- Morphisms for `WalkingMulticospan`. -/
inductive Hom : ∀ _ _ : WalkingMulticospan fst snd, Type w
  | id (A) : Hom A A
  | fst (b) : Hom (left (fst b)) (right b)
  | snd (b) : Hom (left (snd b)) (right b)
goal: (CategoryTheory.Limits.WalkingMulticospan.left (snd b)).Hom (CategoryTheory.Limits.WalkingMulticospan.right b)

full_name: CategoryTheory.Limits.WalkingMulticospan.Hom.fst
code: /-- Morphisms for `WalkingMulticospan`. -/
inductive Hom : ∀ _ _ : WalkingMulticospan fst snd, Type w
  | id (A) : Hom A A
  | fst (b) : Hom (left (fst b)) (right b)
  | snd (b) : Hom (left (snd b)) (right b)
goal: (CategoryTheory.Limits.WalkingMulticospan.left (fst b)).Hom (CategoryTheory.Limits.WalkingMulticospan.right b)

full_name: CategoryTheory.Limits.WalkingMulticospan.Hom
code: /-- Morphisms for `WalkingMulticospan`. -/
inductive Hom : ∀ _ _ : WalkingMulticospan fst snd, Type w
  | id (A) : Hom A A
  | fst (b) : Hom (left (fst b)) (right b)
  | snd (b) : Hom (left (snd b)) (right b)
goal: CategoryTheory.Limits.WalkingMulticospan fst snd → CategoryTheory.Limits.WalkingMulticospan fst snd → Type w

full_name: CategoryTheory.Limits.WalkingMulticospan.Hom.id
code: /-- Morphisms for `WalkingMulticospan`. -/
inductive Hom : ∀ _ _ : WalkingMulticospan fst snd, Type w
  | id (A) : Hom A A
  | fst (b) : Hom (left (fst b)) (right b)
  | snd (b) : Hom (left (snd b)) (right b)
goal: A.Hom A

full_name: CategoryTheory.Limits.WalkingMulticospan.instInhabitedHom
code: instance {a : WalkingMulticospan fst snd} : Inhabited (Hom a a) 
goal: Inhabited (a.Hom a)

full_name: CategoryTheory.Limits.WalkingMulticospan.Hom.comp
code: /-- Composition of morphisms for `WalkingMulticospan`. -/
def Hom.comp : ∀ {A B C : WalkingMulticospan fst snd} (_ : Hom A B) (_ : Hom B C), Hom A C
  
goal: A.Hom B → B.Hom C → A.Hom C

full_name: CategoryTheory.Limits.WalkingMulticospan.instSmallCategory
code: instance : SmallCategory (WalkingMulticospan fst snd) 
goal: CategoryTheory.SmallCategory (CategoryTheory.Limits.WalkingMulticospan fst snd)

full_name: CategoryTheory.Limits.WalkingMulticospan.Hom.id_eq_id
code: @[simp]
lemma Hom.id_eq_id (X : WalkingMulticospan fst snd) :
    Hom.id X = 𝟙 X 
goal: CategoryTheory.Limits.WalkingMulticospan.Hom.id X = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Limits.WalkingMulticospan.Hom.comp_eq_comp
code: @[simp]
lemma Hom.comp_eq_comp {X Y Z : WalkingMulticospan fst snd}
    (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.comp f g = f ≫ g 
goal: CategoryTheory.Limits.WalkingMulticospan.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g

full_name: CategoryTheory.Limits.WalkingMultispan.instInhabited
code: instance [Inhabited L] : Inhabited (WalkingMultispan fst snd) 
goal: Inhabited (CategoryTheory.Limits.WalkingMultispan fst snd)

full_name: CategoryTheory.Limits.WalkingMultispan.Hom.snd
code: /-- Morphisms for `WalkingMultispan`. -/
inductive Hom : ∀ _ _ : WalkingMultispan fst snd, Type v
  | id (A) : Hom A A
  | fst (a) : Hom (left a) (right (fst a))
  | snd (a) : Hom (left a) (right (snd a))
goal: (CategoryTheory.Limits.WalkingMultispan.left a).Hom (CategoryTheory.Limits.WalkingMultispan.right (snd a))

full_name: CategoryTheory.Limits.WalkingMultispan.Hom
code: /-- Morphisms for `WalkingMultispan`. -/
inductive Hom : ∀ _ _ : WalkingMultispan fst snd, Type v
  | id (A) : Hom A A
  | fst (a) : Hom (left a) (right (fst a))
  | snd (a) : Hom (left a) (right (snd a))
goal: CategoryTheory.Limits.WalkingMultispan fst snd → CategoryTheory.Limits.WalkingMultispan fst snd → Type v

full_name: CategoryTheory.Limits.WalkingMultispan.Hom.fst
code: /-- Morphisms for `WalkingMultispan`. -/
inductive Hom : ∀ _ _ : WalkingMultispan fst snd, Type v
  | id (A) : Hom A A
  | fst (a) : Hom (left a) (right (fst a))
  | snd (a) : Hom (left a) (right (snd a))
goal: (CategoryTheory.Limits.WalkingMultispan.left a).Hom (CategoryTheory.Limits.WalkingMultispan.right (fst a))

full_name: CategoryTheory.Limits.WalkingMultispan.Hom.id
code: /-- Morphisms for `WalkingMultispan`. -/
inductive Hom : ∀ _ _ : WalkingMultispan fst snd, Type v
  | id (A) : Hom A A
  | fst (a) : Hom (left a) (right (fst a))
  | snd (a) : Hom (left a) (right (snd a))
goal: A.Hom A

full_name: CategoryTheory.Limits.WalkingMultispan.instInhabitedHom
code: instance {a : WalkingMultispan fst snd} : Inhabited (Hom a a) 
goal: Inhabited (a.Hom a)

full_name: CategoryTheory.Limits.WalkingMultispan.Hom.comp
code: /-- Composition of morphisms for `WalkingMultispan`. -/
def Hom.comp : ∀ {A B C : WalkingMultispan fst snd} (_ : Hom A B) (_ : Hom B C), Hom A C
  
goal: A.Hom B → B.Hom C → A.Hom C

full_name: CategoryTheory.Limits.WalkingMultispan.instSmallCategory
code: instance : SmallCategory (WalkingMultispan fst snd) 
goal: CategoryTheory.SmallCategory (CategoryTheory.Limits.WalkingMultispan fst snd)

full_name: CategoryTheory.Limits.WalkingMultispan.Hom.id_eq_id
code: @[simp]
lemma Hom.id_eq_id (X : WalkingMultispan fst snd) : Hom.id X = 𝟙 X 
goal: CategoryTheory.Limits.WalkingMultispan.Hom.id X = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Limits.WalkingMultispan.Hom.comp_eq_comp
code: @[simp]
lemma Hom.comp_eq_comp {X Y Z : WalkingMultispan fst snd}
    (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.comp f g = f ≫ g 
goal: CategoryTheory.Limits.WalkingMultispan.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g

full_name: CategoryTheory.Limits.MulticospanIndex.fstTo
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: self.R → self.L

full_name: CategoryTheory.Limits.MulticospanIndex
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: Type (max (max u v) (w + 1))

full_name: CategoryTheory.Limits.MulticospanIndex.fst
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: self.left (self.fstTo b) ⟶ self.right b

full_name: CategoryTheory.Limits.MulticospanIndex.snd
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: self.left (self.sndTo b) ⟶ self.right b

full_name: CategoryTheory.Limits.MulticospanIndex.left
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: self.L → C

full_name: CategoryTheory.Limits.MulticospanIndex.right
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: self.R → C

full_name: CategoryTheory.Limits.MulticospanIndex.sndTo
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: self.R → self.L

full_name: CategoryTheory.Limits.MulticospanIndex.R
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: Type w

full_name: CategoryTheory.Limits.MulticospanIndex.L
code: /-- This is a structure encapsulating the data necessary to define a `Multicospan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MulticospanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstTo sndTo : R → L)
  left : L → C
  right : R → C
  fst : ∀ b, left (fstTo b) ⟶ right b
  snd : ∀ b, left (sndTo b) ⟶ right b
goal: Type w

full_name: CategoryTheory.Limits.MultispanIndex.right
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: self.R → C

full_name: CategoryTheory.Limits.MultispanIndex.L
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: Type w

full_name: CategoryTheory.Limits.MultispanIndex.R
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: Type w

full_name: CategoryTheory.Limits.MultispanIndex
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: Type (max (max u v) (w + 1))

full_name: CategoryTheory.Limits.MultispanIndex.left
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: self.L → C

full_name: CategoryTheory.Limits.MultispanIndex.fst
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: self.left a ⟶ self.right (self.fstFrom a)

full_name: CategoryTheory.Limits.MultispanIndex.snd
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: self.left a ⟶ self.right (self.sndFrom a)

full_name: CategoryTheory.Limits.MultispanIndex.fstFrom
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: self.L → self.R

full_name: CategoryTheory.Limits.MultispanIndex.sndFrom
code: /-- This is a structure encapsulating the data necessary to define a `Multispan`. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
structure MultispanIndex (C : Type u) [Category.{v} C] where
  (L R : Type w)
  (fstFrom sndFrom : L → R)
  left : L → C
  right : R → C
  fst : ∀ a, left a ⟶ right (fstFrom a)
  snd : ∀ a, left a ⟶ right (sndFrom a)
goal: self.L → self.R

full_name: CategoryTheory.Limits.MulticospanIndex.multicospan_map
code: /-- The multicospan associated to `I : MulticospanIndex`. -/
@[simps]
def multicospan : WalkingMulticospan I.fstTo I.sndTo ⥤ C 
goal: I.multicospan.map f =
  match x, y, f with
  | x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
    CategoryTheory.CategoryStruct.id
      ((fun x =>
          match x with
          | CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
          | CategoryTheory.Limits.WalkingMulticospan.right b => I.right b)
        x)
  | .(CategoryTheory.Limits.WalkingMulticospan.left (I.fstTo b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
    CategoryTheory.Limits.WalkingMulticospan.Hom.fst b => I.fst b
  | .(CategoryTheory.Limits.WalkingMulticospan.left (I.sndTo b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
    CategoryTheory.Limits.WalkingMulticospan.Hom.snd b => I.snd b

full_name: CategoryTheory.Limits.MulticospanIndex.multicospan
code: /-- The multicospan associated to `I : MulticospanIndex`. -/
@[simps]
def multicospan : WalkingMulticospan I.fstTo I.sndTo ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan I.fstTo I.sndTo) C

full_name: CategoryTheory.Limits.MulticospanIndex.multicospan_obj
code: /-- The multicospan associated to `I : MulticospanIndex`. -/
@[simps]
def multicospan : WalkingMulticospan I.fstTo I.sndTo ⥤ C 
goal: I.multicospan.obj x =
  match x with
  | CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
  | CategoryTheory.Limits.WalkingMulticospan.right b => I.right b

full_name: CategoryTheory.Limits.MulticospanIndex.fstPiMap
code: /-- The induced map `∏ᶜ I.left ⟶ ∏ᶜ I.right` via `I.fst`. -/
noncomputable def fstPiMap : ∏ᶜ I.left ⟶ ∏ᶜ I.right 
goal: ∏ᶜ I.left ⟶ ∏ᶜ I.right

full_name: CategoryTheory.Limits.MulticospanIndex.sndPiMap
code: /-- The induced map `∏ᶜ I.left ⟶ ∏ᶜ I.right` via `I.snd`. -/
noncomputable def sndPiMap : ∏ᶜ I.left ⟶ ∏ᶜ I.right 
goal: ∏ᶜ I.left ⟶ ∏ᶜ I.right

full_name: CategoryTheory.Limits.MulticospanIndex.fstPiMap_π
code: @[reassoc (attr := simp)]
theorem fstPiMap_π (b) : I.fstPiMap ≫ Pi.π I.right b = Pi.π I.left _ ≫ I.fst b 
goal: CategoryTheory.CategoryStruct.comp I.fstPiMap (CategoryTheory.Limits.Pi.π I.right b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (I.fstTo b)) (I.fst b)

full_name: CategoryTheory.Limits.MulticospanIndex.sndPiMap_π
code: @[reassoc (attr := simp)]
theorem sndPiMap_π (b) : I.sndPiMap ≫ Pi.π I.right b = Pi.π I.left _ ≫ I.snd b 
goal: CategoryTheory.CategoryStruct.comp I.sndPiMap (CategoryTheory.Limits.Pi.π I.right b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (I.sndTo b)) (I.snd b)

full_name: CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram_obj
code: /-- Taking the multiequalizer over the multicospan index is equivalent to taking the equalizer over
the two morphisms `∏ᶜ I.left ⇉ ∏ᶜ I.right`. This is the diagram of the latter.
-/
@[simps!]
protected noncomputable def parallelPairDiagram 
goal: I.parallelPairDiagram.obj x =
  match x with
  | CategoryTheory.Limits.WalkingParallelPair.zero => ∏ᶜ I.left
  | CategoryTheory.Limits.WalkingParallelPair.one => ∏ᶜ I.right

full_name: CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram_map
code: /-- Taking the multiequalizer over the multicospan index is equivalent to taking the equalizer over
the two morphisms `∏ᶜ I.left ⇉ ∏ᶜ I.right`. This is the diagram of the latter.
-/
@[simps!]
protected noncomputable def parallelPairDiagram 
goal: ∀ {X Y : CategoryTheory.Limits.WalkingParallelPair} (h : X ⟶ Y),
  I.parallelPairDiagram.map h =
    match X, Y, h with
    | x, .(x), CategoryTheory.Limits.WalkingParallelPairHom.id .(x) =>
      CategoryTheory.CategoryStruct.id
        (match x with
        | CategoryTheory.Limits.WalkingParallelPair.zero => ∏ᶜ I.left
        | CategoryTheory.Limits.WalkingParallelPair.one => ∏ᶜ I.right)
    | .(CategoryTheory.Limits.WalkingParallelPair.zero), .(CategoryTheory.Limits.WalkingParallelPair.one),
      CategoryTheory.Limits.WalkingParallelPairHom.left => I.fstPiMap
    | .(CategoryTheory.Limits.WalkingParallelPair.zero), .(CategoryTheory.Limits.WalkingParallelPair.one),
      CategoryTheory.Limits.WalkingParallelPairHom.right => I.sndPiMap

full_name: CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram
code: /-- Taking the multiequalizer over the multicospan index is equivalent to taking the equalizer over
the two morphisms `∏ᶜ I.left ⇉ ∏ᶜ I.right`. This is the diagram of the latter.
-/
@[simps!]
protected noncomputable def parallelPairDiagram 
goal: CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C

full_name: CategoryTheory.Limits.MultispanIndex.multispan
code: /-- The multispan associated to `I : MultispanIndex`. -/
def multispan : WalkingMultispan I.fstFrom I.sndFrom ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Limits.WalkingMultispan I.fstFrom I.sndFrom) C

full_name: CategoryTheory.Limits.MultispanIndex.multispan_obj_left
code: @[simp]
theorem multispan_obj_left (a) : I.multispan.obj (WalkingMultispan.left a) = I.left a 
goal: I.multispan.obj (CategoryTheory.Limits.WalkingMultispan.left a) = I.left a

full_name: CategoryTheory.Limits.MultispanIndex.multispan_obj_right
code: @[simp]
theorem multispan_obj_right (b) : I.multispan.obj (WalkingMultispan.right b) = I.right b 
goal: I.multispan.obj (CategoryTheory.Limits.WalkingMultispan.right b) = I.right b

full_name: CategoryTheory.Limits.MultispanIndex.multispan_map_fst
code: @[simp]
theorem multispan_map_fst (a) : I.multispan.map (WalkingMultispan.Hom.fst a) = I.fst a 
goal: I.multispan.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst a) = I.fst a

full_name: CategoryTheory.Limits.MultispanIndex.multispan_map_snd
code: @[simp]
theorem multispan_map_snd (a) : I.multispan.map (WalkingMultispan.Hom.snd a) = I.snd a 
goal: I.multispan.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd a) = I.snd a

full_name: CategoryTheory.Limits.MultispanIndex.fstSigmaMap
code: /-- The induced map `∐ I.left ⟶ ∐ I.right` via `I.fst`. -/
noncomputable def fstSigmaMap : ∐ I.left ⟶ ∐ I.right 
goal: ∐ I.left ⟶ ∐ I.right

full_name: CategoryTheory.Limits.MultispanIndex.sndSigmaMap
code: /-- The induced map `∐ I.left ⟶ ∐ I.right` via `I.snd`. -/
noncomputable def sndSigmaMap : ∐ I.left ⟶ ∐ I.right 
goal: ∐ I.left ⟶ ∐ I.right

full_name: CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap
code: @[reassoc (attr := simp)]
theorem ι_fstSigmaMap (b) : Sigma.ι I.left b ≫ I.fstSigmaMap = I.fst b ≫ Sigma.ι I.right _ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left b) I.fstSigmaMap =
  CategoryTheory.CategoryStruct.comp (I.fst b) (CategoryTheory.Limits.Sigma.ι I.right (I.fstFrom b))

full_name: CategoryTheory.Limits.MultispanIndex.ι_sndSigmaMap
code: @[reassoc (attr := simp)]
theorem ι_sndSigmaMap (b) : Sigma.ι I.left b ≫ I.sndSigmaMap = I.snd b ≫ Sigma.ι I.right _ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left b) I.sndSigmaMap =
  CategoryTheory.CategoryStruct.comp (I.snd b) (CategoryTheory.Limits.Sigma.ι I.right (I.sndFrom b))

full_name: CategoryTheory.Limits.MultispanIndex.parallelPairDiagram
code: /--
Taking the multicoequalizer over the multispan index is equivalent to taking the coequalizer over
the two morphsims `∐ I.left ⇉ ∐ I.right`. This is the diagram of the latter.
-/
protected noncomputable abbrev parallelPairDiagram 
goal: CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C

full_name: CategoryTheory.Limits.Multifork
code: /-- A multifork is a cone over a multicospan. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
abbrev Multifork (I : MulticospanIndex.{w} C) 
goal: Type (max (max w u) v)

full_name: CategoryTheory.Limits.Multicofork
code: /-- A multicofork is a cocone over a multispan. -/
-- Porting note(#5171): linter not ported yet
-- @[nolint has_nonempty_instance]
abbrev Multicofork (I : MultispanIndex.{w} C) 
goal: Type (max (max w u) v)

full_name: CategoryTheory.Limits.Multifork.ι
code: /-- The maps from the cone point of a multifork to the objects on the left. -/
def ι (a : I.L) : K.pt ⟶ I.left a 
goal: K.pt ⟶ I.left a

full_name: CategoryTheory.Limits.Multifork.app_left_eq_ι
code: @[simp]
theorem app_left_eq_ι (a) : K.π.app (WalkingMulticospan.left a) = K.ι a 
goal: K.π.app (CategoryTheory.Limits.WalkingMulticospan.left a) = K.ι a

full_name: CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst
code: @[simp]
theorem app_right_eq_ι_comp_fst (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.fstTo b) ≫ I.fst b 
goal: K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b) =
  CategoryTheory.CategoryStruct.comp (K.ι (I.fstTo b)) (I.fst b)

full_name: CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_snd
code: @[reassoc]
theorem app_right_eq_ι_comp_snd (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.sndTo b) ≫ I.snd b 
goal: K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b) =
  CategoryTheory.CategoryStruct.comp (K.ι (I.sndTo b)) (I.snd b)

full_name: CategoryTheory.Limits.Multifork.hom_comp_ι
code: @[reassoc (attr := simp)]
theorem hom_comp_ι (K₁ K₂ : Multifork I) (f : K₁ ⟶ K₂) (j : I.L) : f.hom ≫ K₂.ι j = K₁.ι j 
goal: CategoryTheory.CategoryStruct.comp f.hom (K₂.ι j) = K₁.ι j

full_name: CategoryTheory.Limits.Multifork.ofι_pt
code: /-- Construct a multifork using a collection `ι` of morphisms. -/
@[simps]
def ofι (I : MulticospanIndex.{w} C) (P : C) (ι : ∀ a, P ⟶ I.left a)
    (w : ∀ b, ι (I.fstTo b) ≫ I.fst b = ι (I.sndTo b) ≫ I.snd b) : Multifork I 
goal: (CategoryTheory.Limits.Multifork.ofι I P ι w).pt = P

full_name: CategoryTheory.Limits.Multifork.ofι_π_app
code: /-- Construct a multifork using a collection `ι` of morphisms. -/
@[simps]
def ofι (I : MulticospanIndex.{w} C) (P : C) (ι : ∀ a, P ⟶ I.left a)
    (w : ∀ b, ι (I.fstTo b) ≫ I.fst b = ι (I.sndTo b) ≫ I.snd b) : Multifork I 
goal: (CategoryTheory.Limits.Multifork.ofι I P ι w).π.app x =
  match x with
  | CategoryTheory.Limits.WalkingMulticospan.left a => ι a
  | CategoryTheory.Limits.WalkingMulticospan.right b => CategoryTheory.CategoryStruct.comp (ι (I.fstTo b)) (I.fst b)

full_name: CategoryTheory.Limits.Multifork.ofι
code: /-- Construct a multifork using a collection `ι` of morphisms. -/
@[simps]
def ofι (I : MulticospanIndex.{w} C) (P : C) (ι : ∀ a, P ⟶ I.left a)
    (w : ∀ b, ι (I.fstTo b) ≫ I.fst b = ι (I.sndTo b) ≫ I.snd b) : Multifork I 
goal: CategoryTheory.Limits.Multifork I

full_name: CategoryTheory.Limits.Multifork.condition
code: @[reassoc (attr := simp)]
theorem condition (b) : K.ι (I.fstTo b) ≫ I.fst b = K.ι (I.sndTo b) ≫ I.snd b 
goal: CategoryTheory.CategoryStruct.comp (K.ι (I.fstTo b)) (I.fst b) =
  CategoryTheory.CategoryStruct.comp (K.ι (I.sndTo b)) (I.snd b)

full_name: CategoryTheory.Limits.Multifork.IsLimit.mk_lift
code: /-- This definition provides a convenient way to show that a multifork is a limit. -/
@[simps]
def IsLimit.mk (lift : ∀ E : Multifork I, E.pt ⟶ K.pt)
    (fac : ∀ (E : Multifork I) (i : I.L), lift E ≫ K.ι i = E.ι i)
    (uniq : ∀ (E : Multifork I) (m : E.pt ⟶ K.pt), (∀ i : I.L, m ≫ K.ι i = E.ι i) → m = lift E) :
    IsLimit K 
goal: (CategoryTheory.Limits.Multifork.IsLimit.mk K lift fac uniq).lift E = lift E

full_name: CategoryTheory.Limits.Multifork.IsLimit.mk
code: /-- This definition provides a convenient way to show that a multifork is a limit. -/
@[simps]
def IsLimit.mk (lift : ∀ E : Multifork I, E.pt ⟶ K.pt)
    (fac : ∀ (E : Multifork I) (i : I.L), lift E ≫ K.ι i = E.ι i)
    (uniq : ∀ (E : Multifork I) (m : E.pt ⟶ K.pt), (∀ i : I.L, m ≫ K.ι i = E.ι i) → m = lift E) :
    IsLimit K 
goal: CategoryTheory.Limits.IsLimit K

full_name: CategoryTheory.Limits.Multifork.IsLimit.hom_ext
code: lemma IsLimit.hom_ext (hK : IsLimit K) {T : C} {f g : T ⟶ K.pt}
    (h : ∀ a, f ≫ K.ι a = g ≫ K.ι a) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.Multifork.IsLimit.lift
code: /-- Constructor for morphisms to the point of a limit multifork. -/
def IsLimit.lift (hK : IsLimit K) {T : C} (k : ∀ a, T ⟶ I.left a)
    (hk : ∀ b, k (I.fstTo b) ≫ I.fst b = k (I.sndTo b) ≫ I.snd b) :
    T ⟶ K.pt 
goal: T ⟶ K.pt

full_name: CategoryTheory.Limits.Multifork.IsLimit.fac
code: @[reassoc (attr := simp)]
lemma IsLimit.fac (hK : IsLimit K) {T : C} (k : ∀ a, T ⟶ I.left a)
    (hk : ∀ b, k (I.fstTo b) ≫ I.fst b = k (I.sndTo b) ≫ I.snd b) (a : I.L) :
    IsLimit.lift hK k hk ≫ K.ι a = k a 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multifork.IsLimit.lift hK k hk) (K.ι a) = k a

full_name: CategoryTheory.Limits.Multifork.pi_condition
code: @[reassoc (attr := simp)]
theorem pi_condition : Pi.lift K.ι ≫ I.fstPiMap = Pi.lift K.ι ≫ I.sndPiMap 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.lift K.ι) I.fstPiMap =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.lift K.ι) I.sndPiMap

full_name: CategoryTheory.Limits.Multifork.toPiFork_pt
code: /-- Given a multifork, we may obtain a fork over `∏ᶜ I.left ⇉ ∏ᶜ I.right`. -/
@[simps pt]
noncomputable def toPiFork (K : Multifork I) : Fork I.fstPiMap I.sndPiMap 
goal: K.toPiFork.pt = K.pt

full_name: CategoryTheory.Limits.Multifork.toPiFork
code: /-- Given a multifork, we may obtain a fork over `∏ᶜ I.left ⇉ ∏ᶜ I.right`. -/
@[simps pt]
noncomputable def toPiFork (K : Multifork I) : Fork I.fstPiMap I.sndPiMap 
goal: CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap

full_name: CategoryTheory.Limits.Multifork.toPiFork_π_app_zero
code: @[simp]
theorem toPiFork_π_app_zero : K.toPiFork.ι = Pi.lift K.ι 
goal: K.toPiFork.ι = CategoryTheory.Limits.Pi.lift K.ι

full_name: CategoryTheory.Limits.Multifork.toPiFork_π_app_one
code: @[simp]
theorem toPiFork_π_app_one : K.toPiFork.π.app WalkingParallelPair.one = Pi.lift K.ι ≫ I.fstPiMap 
goal: K.toPiFork.π.app CategoryTheory.Limits.WalkingParallelPair.one =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.lift K.ι) I.fstPiMap

full_name: CategoryTheory.Limits.Multifork.ofPiFork_pt
code: /-- Given a fork over `∏ᶜ I.left ⇉ ∏ᶜ I.right`, we may obtain a multifork. -/
@[simps pt]
noncomputable def ofPiFork (c : Fork I.fstPiMap I.sndPiMap) : Multifork I 
goal: (CategoryTheory.Limits.Multifork.ofPiFork I c).pt = c.pt

full_name: CategoryTheory.Limits.Multifork.ofPiFork
code: /-- Given a fork over `∏ᶜ I.left ⇉ ∏ᶜ I.right`, we may obtain a multifork. -/
@[simps pt]
noncomputable def ofPiFork (c : Fork I.fstPiMap I.sndPiMap) : Multifork I 
goal: CategoryTheory.Limits.Multifork I

full_name: CategoryTheory.Limits.Multifork.ofPiFork_π_app_left
code: @[simp]
theorem ofPiFork_π_app_left (c : Fork I.fstPiMap I.sndPiMap) (a) :
    (ofPiFork I c).ι a = c.ι ≫ Pi.π _ _ 
goal: (CategoryTheory.Limits.Multifork.ofPiFork I c).ι a =
  CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.Limits.Pi.π I.left a)

full_name: CategoryTheory.Limits.Multifork.ofPiFork_π_app_right
code: @[simp]
theorem ofPiFork_π_app_right (c : Fork I.fstPiMap I.sndPiMap) (a) :
    (ofPiFork I c).π.app (WalkingMulticospan.right a) = c.ι ≫ I.fstPiMap ≫ Pi.π _ _ 
goal: (CategoryTheory.Limits.Multifork.ofPiFork I c).π.app (CategoryTheory.Limits.WalkingMulticospan.right a) =
  CategoryTheory.CategoryStruct.comp c.ι
    (CategoryTheory.CategoryStruct.comp I.fstPiMap (CategoryTheory.Limits.Pi.π I.right a))

full_name: CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_obj
code: /-- `Multifork.toPiFork` as a functor. -/
@[simps]
noncomputable def toPiForkFunctor : Multifork I ⥤ Fork I.fstPiMap I.sndPiMap 
goal: I.toPiForkFunctor.obj K = K.toPiFork

full_name: CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_map_hom
code: /-- `Multifork.toPiFork` as a functor. -/
@[simps]
noncomputable def toPiForkFunctor : Multifork I ⥤ Fork I.fstPiMap I.sndPiMap 
goal: (I.toPiForkFunctor.map f).hom = f.hom

full_name: CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor
code: /-- `Multifork.toPiFork` as a functor. -/
@[simps]
noncomputable def toPiForkFunctor : Multifork I ⥤ Fork I.fstPiMap I.sndPiMap 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Multifork I) (CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap)

full_name: CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_map_hom
code: /-- `Multifork.ofPiFork` as a functor. -/
@[simps]
noncomputable def ofPiForkFunctor : Fork I.fstPiMap I.sndPiMap ⥤ Multifork I 
goal: (I.ofPiForkFunctor.map f).hom = f.hom

full_name: CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor
code: /-- `Multifork.ofPiFork` as a functor. -/
@[simps]
noncomputable def ofPiForkFunctor : Fork I.fstPiMap I.sndPiMap ⥤ Multifork I 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap) (CategoryTheory.Limits.Multifork I)

full_name: CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_obj
code: /-- `Multifork.ofPiFork` as a functor. -/
@[simps]
noncomputable def ofPiForkFunctor : Fork I.fstPiMap I.sndPiMap ⥤ Multifork I 
goal: I.ofPiForkFunctor.obj c = CategoryTheory.Limits.Multifork.ofPiFork I c

full_name: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor
code: /-- The category of multiforks is equivalent to the category of forks over `∏ᶜ I.left ⇉ ∏ᶜ I.right`.
It then follows from `CategoryTheory.IsLimit.ofPreservesConeTerminal` (or `reflects`) that it
preserves and reflects limit cones.
-/
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
goal: I.multiforkEquivPiFork.functor = I.toPiForkFunctor

full_name: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_counitIso
code: /-- The category of multiforks is equivalent to the category of forks over `∏ᶜ I.left ⇉ ∏ᶜ I.right`.
It then follows from `CategoryTheory.IsLimit.ofPreservesConeTerminal` (or `reflects`) that it
preserves and reflects limit cones.
-/
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
goal: I.multiforkEquivPiFork.counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun K =>
      CategoryTheory.Limits.Fork.ext (CategoryTheory.Iso.refl ((I.ofPiForkFunctor.comp I.toPiForkFunctor).obj K).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork
code: /-- The category of multiforks is equivalent to the category of forks over `∏ᶜ I.left ⇉ ∏ᶜ I.right`.
It then follows from `CategoryTheory.IsLimit.ofPreservesConeTerminal` (or `reflects`) that it
preserves and reflects limit cones.
-/
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
goal: CategoryTheory.Limits.Multifork I ≌ CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap

full_name: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse
code: /-- The category of multiforks is equivalent to the category of forks over `∏ᶜ I.left ⇉ ∏ᶜ I.right`.
It then follows from `CategoryTheory.IsLimit.ofPreservesConeTerminal` (or `reflects`) that it
preserves and reflects limit cones.
-/
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
goal: I.multiforkEquivPiFork.inverse = I.ofPiForkFunctor

full_name: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_unitIso
code: /-- The category of multiforks is equivalent to the category of forks over `∏ᶜ I.left ⇉ ∏ᶜ I.right`.
It then follows from `CategoryTheory.IsLimit.ofPreservesConeTerminal` (or `reflects`) that it
preserves and reflects limit cones.
-/
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
goal: I.multiforkEquivPiFork.unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun K =>
      CategoryTheory.Limits.Cones.ext
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Multifork I)).obj K).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.Multicofork.π
code: /-- The maps to the cocone point of a multicofork from the objects on the right. -/
def π (b : I.R) : I.right b ⟶ K.pt 
goal: I.right b ⟶ K.pt

full_name: CategoryTheory.Limits.Multicofork.π_eq_app_right
code: @[simp]
theorem π_eq_app_right (b) : K.ι.app (WalkingMultispan.right _) = K.π b 
goal: K.ι.app (CategoryTheory.Limits.WalkingMultispan.right b) = K.π b

full_name: CategoryTheory.Limits.Multicofork.fst_app_right
code: @[simp]
theorem fst_app_right (a) : K.ι.app (WalkingMultispan.left a) = I.fst a ≫ K.π _ 
goal: K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) =
  CategoryTheory.CategoryStruct.comp (I.fst a) (K.π (I.fstFrom a))

full_name: CategoryTheory.Limits.Multicofork.snd_app_right
code: @[reassoc]
theorem snd_app_right (a) : K.ι.app (WalkingMultispan.left a) = I.snd a ≫ K.π _ 
goal: K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) =
  CategoryTheory.CategoryStruct.comp (I.snd a) (K.π (I.sndFrom a))

full_name: CategoryTheory.Limits.Multicofork.π_comp_hom
code: @[reassoc (attr := simp)]
lemma π_comp_hom (K₁ K₂ : Multicofork I) (f : K₁ ⟶ K₂) (b : I.R) : K₁.π b ≫ f.hom = K₂.π b 
goal: CategoryTheory.CategoryStruct.comp (K₁.π b) f.hom = K₂.π b

full_name: CategoryTheory.Limits.Multicofork.ofπ
code: /-- Construct a multicofork using a collection `π` of morphisms. -/
@[simps]
def ofπ (I : MultispanIndex.{w} C) (P : C) (π : ∀ b, I.right b ⟶ P)
    (w : ∀ a, I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)) : Multicofork I 
goal: CategoryTheory.Limits.Multicofork I

full_name: CategoryTheory.Limits.Multicofork.ofπ_pt
code: /-- Construct a multicofork using a collection `π` of morphisms. -/
@[simps]
def ofπ (I : MultispanIndex.{w} C) (P : C) (π : ∀ b, I.right b ⟶ P)
    (w : ∀ a, I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)) : Multicofork I 
goal: (CategoryTheory.Limits.Multicofork.ofπ I P π w).pt = P

full_name: CategoryTheory.Limits.Multicofork.ofπ_ι_app
code: /-- Construct a multicofork using a collection `π` of morphisms. -/
@[simps]
def ofπ (I : MultispanIndex.{w} C) (P : C) (π : ∀ b, I.right b ⟶ P)
    (w : ∀ a, I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)) : Multicofork I 
goal: (CategoryTheory.Limits.Multicofork.ofπ I P π w).ι.app x =
  match x with
  | CategoryTheory.Limits.WalkingMultispan.left a => CategoryTheory.CategoryStruct.comp (I.fst a) (π (I.fstFrom a))
  | CategoryTheory.Limits.WalkingMultispan.right b => π b

full_name: CategoryTheory.Limits.Multicofork.condition
code: @[reassoc (attr := simp)]
theorem condition (a) : I.fst a ≫ K.π (I.fstFrom a) = I.snd a ≫ K.π (I.sndFrom a) 
goal: CategoryTheory.CategoryStruct.comp (I.fst a) (K.π (I.fstFrom a)) =
  CategoryTheory.CategoryStruct.comp (I.snd a) (K.π (I.sndFrom a))

full_name: CategoryTheory.Limits.Multicofork.IsColimit.mk_desc
code: /-- This definition provides a convenient way to show that a multicofork is a colimit. -/
@[simps]
def IsColimit.mk (desc : ∀ E : Multicofork I, K.pt ⟶ E.pt)
    (fac : ∀ (E : Multicofork I) (i : I.R), K.π i ≫ desc E = E.π i)
    (uniq : ∀ (E : Multicofork I) (m : K.pt ⟶ E.pt), (∀ i : I.R, K.π i ≫ m = E.π i) → m = desc E) :
    IsColimit K 
goal: (CategoryTheory.Limits.Multicofork.IsColimit.mk K desc fac uniq).desc E = desc E

full_name: CategoryTheory.Limits.Multicofork.IsColimit.mk
code: /-- This definition provides a convenient way to show that a multicofork is a colimit. -/
@[simps]
def IsColimit.mk (desc : ∀ E : Multicofork I, K.pt ⟶ E.pt)
    (fac : ∀ (E : Multicofork I) (i : I.R), K.π i ≫ desc E = E.π i)
    (uniq : ∀ (E : Multicofork I) (m : K.pt ⟶ E.pt), (∀ i : I.R, K.π i ≫ m = E.π i) → m = desc E) :
    IsColimit K 
goal: CategoryTheory.Limits.IsColimit K

full_name: CategoryTheory.Limits.Multicofork.sigma_condition
code: @[reassoc (attr := simp)]
theorem sigma_condition : I.fstSigmaMap ≫ Sigma.desc K.π = I.sndSigmaMap ≫ Sigma.desc K.π 
goal: CategoryTheory.CategoryStruct.comp I.fstSigmaMap (CategoryTheory.Limits.Sigma.desc K.π) =
  CategoryTheory.CategoryStruct.comp I.sndSigmaMap (CategoryTheory.Limits.Sigma.desc K.π)

full_name: CategoryTheory.Limits.Multicofork.toSigmaCofork_pt
code: /-- Given a multicofork, we may obtain a cofork over `∐ I.left ⇉ ∐ I.right`. -/
@[simps pt]
noncomputable def toSigmaCofork (K : Multicofork I) : Cofork I.fstSigmaMap I.sndSigmaMap 
goal: K.toSigmaCofork.pt = K.pt

full_name: CategoryTheory.Limits.Multicofork.toSigmaCofork
code: /-- Given a multicofork, we may obtain a cofork over `∐ I.left ⇉ ∐ I.right`. -/
@[simps pt]
noncomputable def toSigmaCofork (K : Multicofork I) : Cofork I.fstSigmaMap I.sndSigmaMap 
goal: CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap

full_name: CategoryTheory.Limits.Multicofork.toSigmaCofork_π
code: @[simp]
theorem toSigmaCofork_π : K.toSigmaCofork.π = Sigma.desc K.π 
goal: K.toSigmaCofork.π = CategoryTheory.Limits.Sigma.desc K.π

full_name: CategoryTheory.Limits.Multicofork.ofSigmaCofork
code: /-- Given a cofork over `∐ I.left ⇉ ∐ I.right`, we may obtain a multicofork. -/
@[simps pt]
noncomputable def ofSigmaCofork (c : Cofork I.fstSigmaMap I.sndSigmaMap) : Multicofork I 
goal: CategoryTheory.Limits.Multicofork I

full_name: CategoryTheory.Limits.Multicofork.ofSigmaCofork_pt
code: /-- Given a cofork over `∐ I.left ⇉ ∐ I.right`, we may obtain a multicofork. -/
@[simps pt]
noncomputable def ofSigmaCofork (c : Cofork I.fstSigmaMap I.sndSigmaMap) : Multicofork I 
goal: (CategoryTheory.Limits.Multicofork.ofSigmaCofork I c).pt = c.pt

full_name: CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_left
code: @[simp]
theorem ofSigmaCofork_ι_app_left (c : Cofork I.fstSigmaMap I.sndSigmaMap) (a) :
    (ofSigmaCofork I c).ι.app (WalkingMultispan.left a) =
      (Sigma.ι I.left a : _) ≫ I.fstSigmaMap ≫ c.π 
goal: (CategoryTheory.Limits.Multicofork.ofSigmaCofork I c).ι.app (CategoryTheory.Limits.WalkingMultispan.left a) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left a)
    (CategoryTheory.CategoryStruct.comp I.fstSigmaMap c.π)

full_name: CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_right
code: theorem ofSigmaCofork_ι_app_right (c : Cofork I.fstSigmaMap I.sndSigmaMap) (b) :
    (ofSigmaCofork I c).ι.app (WalkingMultispan.right b) = (Sigma.ι I.right b : _) ≫ c.π 
goal: (CategoryTheory.Limits.Multicofork.ofSigmaCofork I c).ι.app (CategoryTheory.Limits.WalkingMultispan.right b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b) c.π

full_name: CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_right'
code: @[simp]
theorem ofSigmaCofork_ι_app_right' (c : Cofork I.fstSigmaMap I.sndSigmaMap) (b) :
    π (ofSigmaCofork I c) b = (Sigma.ι I.right b : _) ≫ c.π 
goal: (CategoryTheory.Limits.Multicofork.ofSigmaCofork I c).π b =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b) c.π

full_name: CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_obj
code: /-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: I.toSigmaCoforkFunctor.obj K = K.toSigmaCofork

full_name: CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_map_hom
code: /-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: (I.toSigmaCoforkFunctor.map f).hom = f.hom

full_name: CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor
code: /-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Multicofork I) (CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap)

full_name: CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor
code: /-- `Multicofork.ofSigmaCofork` as a functor. -/
@[simps]
noncomputable def ofSigmaCoforkFunctor : Cofork I.fstSigmaMap I.sndSigmaMap ⥤ Multicofork I 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap) (CategoryTheory.Limits.Multicofork I)

full_name: CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_map_hom
code: /-- `Multicofork.ofSigmaCofork` as a functor. -/
@[simps]
noncomputable def ofSigmaCoforkFunctor : Cofork I.fstSigmaMap I.sndSigmaMap ⥤ Multicofork I 
goal: (I.ofSigmaCoforkFunctor.map f).hom = f.hom

full_name: CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_obj
code: /-- `Multicofork.ofSigmaCofork` as a functor. -/
@[simps]
noncomputable def ofSigmaCoforkFunctor : Cofork I.fstSigmaMap I.sndSigmaMap ⥤ Multicofork I 
goal: I.ofSigmaCoforkFunctor.obj c = CategoryTheory.Limits.Multicofork.ofSigmaCofork I c

full_name: CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork
code: /--
The category of multicoforks is equivalent to the category of coforks over `∐ I.left ⇉ ∐ I.right`.
It then follows from `CategoryTheory.IsColimit.ofPreservesCoconeInitial` (or `reflects`) that
it preserves and reflects colimit cocones.
-/
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: CategoryTheory.Limits.Multicofork I ≌ CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap

full_name: CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_inverse
code: /--
The category of multicoforks is equivalent to the category of coforks over `∐ I.left ⇉ ∐ I.right`.
It then follows from `CategoryTheory.IsColimit.ofPreservesCoconeInitial` (or `reflects`) that
it preserves and reflects colimit cocones.
-/
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: I.multicoforkEquivSigmaCofork.inverse = I.ofSigmaCoforkFunctor

full_name: CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_functor
code: /--
The category of multicoforks is equivalent to the category of coforks over `∐ I.left ⇉ ∐ I.right`.
It then follows from `CategoryTheory.IsColimit.ofPreservesCoconeInitial` (or `reflects`) that
it preserves and reflects colimit cocones.
-/
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: I.multicoforkEquivSigmaCofork.functor = I.toSigmaCoforkFunctor

full_name: CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_counitIso
code: /--
The category of multicoforks is equivalent to the category of coforks over `∐ I.left ⇉ ∐ I.right`.
It then follows from `CategoryTheory.IsColimit.ofPreservesCoconeInitial` (or `reflects`) that
it preserves and reflects colimit cocones.
-/
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: I.multicoforkEquivSigmaCofork.counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun K =>
      CategoryTheory.Limits.Cofork.ext
        (CategoryTheory.Iso.refl ((I.ofSigmaCoforkFunctor.comp I.toSigmaCoforkFunctor).obj K).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_unitIso
code: /--
The category of multicoforks is equivalent to the category of coforks over `∐ I.left ⇉ ∐ I.right`.
It then follows from `CategoryTheory.IsColimit.ofPreservesCoconeInitial` (or `reflects`) that
it preserves and reflects colimit cocones.
-/
@[simps]
noncomputable def multicoforkEquivSigmaCofork :
    Multicofork I ≌ Cofork I.fstSigmaMap I.sndSigmaMap 
goal: I.multicoforkEquivSigmaCofork.unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun K =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Multicofork I)).obj K).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.HasMultiequalizer
code: /-- For `I : MulticospanIndex C`, we say that it has a multiequalizer if the associated
  multicospan has a limit. -/
abbrev HasMultiequalizer (I : MulticospanIndex.{w} C) 
goal: Prop

full_name: CategoryTheory.Limits.multiequalizer
code: /-- The multiequalizer of `I : MulticospanIndex C`. -/
abbrev multiequalizer (I : MulticospanIndex.{w} C) [HasMultiequalizer I] : C 
goal: C

full_name: CategoryTheory.Limits.HasMulticoequalizer
code: /-- For `I : MultispanIndex C`, we say that it has a multicoequalizer if
  the associated multicospan has a limit. -/
abbrev HasMulticoequalizer (I : MultispanIndex.{w} C) 
goal: Prop

full_name: CategoryTheory.Limits.multicoequalizer
code: /-- The multiecoqualizer of `I : MultispanIndex C`. -/
abbrev multicoequalizer (I : MultispanIndex.{w} C) [HasMulticoequalizer I] : C 
goal: C

full_name: CategoryTheory.Limits.Multiequalizer.ι
code: /-- The canonical map from the multiequalizer to the objects on the left. -/
abbrev ι (a : I.L) : multiequalizer I ⟶ I.left a 
goal: CategoryTheory.Limits.multiequalizer I ⟶ I.left a

full_name: CategoryTheory.Limits.Multiequalizer.multifork
code: /-- The multifork associated to the multiequalizer. -/
abbrev multifork : Multifork I 
goal: CategoryTheory.Limits.Multifork I

full_name: CategoryTheory.Limits.Multiequalizer.multifork_ι
code: @[simp]
theorem multifork_ι (a) : (Multiequalizer.multifork I).ι a = Multiequalizer.ι I a 
goal: (CategoryTheory.Limits.Multiequalizer.multifork I).ι a = CategoryTheory.Limits.Multiequalizer.ι I a

full_name: CategoryTheory.Limits.Multiequalizer.multifork_π_app_left
code: @[simp]
theorem multifork_π_app_left (a) :
    (Multiequalizer.multifork I).π.app (WalkingMulticospan.left a) = Multiequalizer.ι I a 
goal: (CategoryTheory.Limits.Multiequalizer.multifork I).π.app (CategoryTheory.Limits.WalkingMulticospan.left a) =
  CategoryTheory.Limits.Multiequalizer.ι I a

full_name: CategoryTheory.Limits.Multiequalizer.condition
code: @[reassoc]
theorem condition (b) :
    Multiequalizer.ι I (I.fstTo b) ≫ I.fst b = Multiequalizer.ι I (I.sndTo b) ≫ I.snd b 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (I.fstTo b)) (I.fst b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (I.sndTo b)) (I.snd b)

full_name: CategoryTheory.Limits.Multiequalizer.lift
code: /-- Construct a morphism to the multiequalizer from its universal property. -/
abbrev lift (W : C) (k : ∀ a, W ⟶ I.left a)
    (h : ∀ b, k (I.fstTo b) ≫ I.fst b = k (I.sndTo b) ≫ I.snd b) : W ⟶ multiequalizer I 
goal: W ⟶ CategoryTheory.Limits.multiequalizer I

full_name: CategoryTheory.Limits.Multiequalizer.lift_ι
code: @[reassoc] -- Porting note (#10618): simp can prove this, removed attribute
theorem lift_ι (W : C) (k : ∀ a, W ⟶ I.left a)
    (h : ∀ b, k (I.fstTo b) ≫ I.fst b = k (I.sndTo b) ≫ I.snd b) (a) :
    Multiequalizer.lift I _ k h ≫ Multiequalizer.ι I a = k _ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.lift I W k h)
    (CategoryTheory.Limits.Multiequalizer.ι I a) =
  k a

full_name: CategoryTheory.Limits.Multiequalizer.hom_ext
code: @[ext]
theorem hom_ext {W : C} (i j : W ⟶ multiequalizer I)
    (h : ∀ a, i ≫ Multiequalizer.ι I a = j ≫ Multiequalizer.ι I a) : i = j 
goal: i = j

full_name: CategoryTheory.Limits.Multiequalizer.instHasEqualizerFstPiMapSndPiMap
code: instance : HasEqualizer I.fstPiMap I.sndPiMap 
goal: CategoryTheory.Limits.HasEqualizer I.fstPiMap I.sndPiMap

full_name: CategoryTheory.Limits.Multiequalizer.isoEqualizer
code: /-- The multiequalizer is isomorphic to the equalizer of `∏ᶜ I.left ⇉ ∏ᶜ I.right`. -/
def isoEqualizer : multiequalizer I ≅ equalizer I.fstPiMap I.sndPiMap 
goal: CategoryTheory.Limits.multiequalizer I ≅ CategoryTheory.Limits.equalizer I.fstPiMap I.sndPiMap

full_name: CategoryTheory.Limits.Multiequalizer.ιPi
code: /-- The canonical injection `multiequalizer I ⟶ ∏ᶜ I.left`. -/
def ιPi : multiequalizer I ⟶ ∏ᶜ I.left 
goal: CategoryTheory.Limits.multiequalizer I ⟶ ∏ᶜ I.left

full_name: CategoryTheory.Limits.Multiequalizer.ιPi_π
code: @[reassoc (attr := simp)]
theorem ιPi_π (a) : ιPi I ≫ Pi.π I.left a = ι I a 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ιPi I) (CategoryTheory.Limits.Pi.π I.left a) =
  CategoryTheory.Limits.Multiequalizer.ι I a

full_name: CategoryTheory.Limits.Multiequalizer.instMonoιPi
code: instance : Mono (ιPi I) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.Multiequalizer.ιPi I)

full_name: CategoryTheory.Limits.Multicoequalizer.π
code: /-- The canonical map from the multiequalizer to the objects on the left. -/
abbrev π (b : I.R) : I.right b ⟶ multicoequalizer I 
goal: I.right b ⟶ CategoryTheory.Limits.multicoequalizer I

full_name: CategoryTheory.Limits.Multicoequalizer.multicofork
code: /-- The multicofork associated to the multicoequalizer. -/
abbrev multicofork : Multicofork I 
goal: CategoryTheory.Limits.Multicofork I

full_name: CategoryTheory.Limits.Multicoequalizer.multicofork_π
code: @[simp]
theorem multicofork_π (b) : (Multicoequalizer.multicofork I).π b = Multicoequalizer.π I b 
goal: (CategoryTheory.Limits.Multicoequalizer.multicofork I).π b = CategoryTheory.Limits.Multicoequalizer.π I b

full_name: CategoryTheory.Limits.Multicoequalizer.multicofork_ι_app_right
code: theorem multicofork_ι_app_right (b) :
    (Multicoequalizer.multicofork I).ι.app (WalkingMultispan.right b) = Multicoequalizer.π I b 
goal: (CategoryTheory.Limits.Multicoequalizer.multicofork I).ι.app (CategoryTheory.Limits.WalkingMultispan.right b) =
  CategoryTheory.Limits.Multicoequalizer.π I b

full_name: CategoryTheory.Limits.Multicoequalizer.multicofork_ι_app_right'
code: @[simp]
theorem multicofork_ι_app_right' (b) :
    colimit.ι (MultispanIndex.multispan I) (WalkingMultispan.right b) = π I b 
goal: CategoryTheory.Limits.colimit.ι I.multispan (CategoryTheory.Limits.WalkingMultispan.right b) =
  CategoryTheory.Limits.Multicoequalizer.π I b

full_name: CategoryTheory.Limits.Multicoequalizer.condition
code: @[reassoc]
theorem condition (a) :
    I.fst a ≫ Multicoequalizer.π I (I.fstFrom a) = I.snd a ≫ Multicoequalizer.π I (I.sndFrom a) 
goal: CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicoequalizer.π I (I.fstFrom a)) =
  CategoryTheory.CategoryStruct.comp (I.snd a) (CategoryTheory.Limits.Multicoequalizer.π I (I.sndFrom a))

full_name: CategoryTheory.Limits.Multicoequalizer.desc
code: /-- Construct a morphism from the multicoequalizer from its universal property. -/
abbrev desc (W : C) (k : ∀ b, I.right b ⟶ W)
    (h : ∀ a, I.fst a ≫ k (I.fstFrom a) = I.snd a ≫ k (I.sndFrom a)) : multicoequalizer I ⟶ W 
goal: CategoryTheory.Limits.multicoequalizer I ⟶ W

full_name: CategoryTheory.Limits.Multicoequalizer.π_desc
code: @[reassoc] -- Porting note (#10618): simp can prove this, removed attribute
theorem π_desc (W : C) (k : ∀ b, I.right b ⟶ W)
    (h : ∀ a, I.fst a ≫ k (I.fstFrom a) = I.snd a ≫ k (I.sndFrom a)) (b) :
    Multicoequalizer.π I b ≫ Multicoequalizer.desc I _ k h = k _ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b)
    (CategoryTheory.Limits.Multicoequalizer.desc I W k h) =
  k b

full_name: CategoryTheory.Limits.Multicoequalizer.hom_ext
code: @[ext]
theorem hom_ext {W : C} (i j : multicoequalizer I ⟶ W)
    (h : ∀ b, Multicoequalizer.π I b ≫ i = Multicoequalizer.π I b ≫ j) : i = j 
goal: i = j

full_name: CategoryTheory.Limits.Multicoequalizer.instHasCoequalizerFstSigmaMapSndSigmaMap
code: instance : HasCoequalizer I.fstSigmaMap I.sndSigmaMap 
goal: CategoryTheory.Limits.HasCoequalizer I.fstSigmaMap I.sndSigmaMap

full_name: CategoryTheory.Limits.Multicoequalizer.isoCoequalizer
code: /-- The multicoequalizer is isomorphic to the coequalizer of `∐ I.left ⇉ ∐ I.right`. -/
def isoCoequalizer : multicoequalizer I ≅ coequalizer I.fstSigmaMap I.sndSigmaMap 
goal: CategoryTheory.Limits.multicoequalizer I ≅ CategoryTheory.Limits.coequalizer I.fstSigmaMap I.sndSigmaMap

full_name: CategoryTheory.Limits.Multicoequalizer.sigmaπ
code: /-- The canonical projection `∐ I.right ⟶ multicoequalizer I`. -/
def sigmaπ : ∐ I.right ⟶ multicoequalizer I 
goal: ∐ I.right ⟶ CategoryTheory.Limits.multicoequalizer I

full_name: CategoryTheory.Limits.Multicoequalizer.ι_sigmaπ
code: @[reassoc (attr := simp)]
theorem ι_sigmaπ (b) : Sigma.ι I.right b ≫ sigmaπ I = π I b 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b)
    (CategoryTheory.Limits.Multicoequalizer.sigmaπ I) =
  CategoryTheory.Limits.Multicoequalizer.π I b

full_name: CategoryTheory.Limits.Multicoequalizer.instEpiSigmaπ
code: instance : Epi (sigmaπ I) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.Multicoequalizer.sigmaπ I)