ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram_map
@[simps!]
protected noncomputable def parallelPairDiagram 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
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
-- CategoryTheory.Limits.MultispanIndex.multispan_obj_left
@[simp]
theorem multispan_obj_left (a) : I.multispan.obj (WalkingMultispan.left a) = I.left a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) (a : I.L)
Goal: I.multispan.obj (CategoryTheory.Limits.WalkingMultispan.left a) = I.left a
-- CategoryTheory.Limits.MultispanIndex.multispan_obj_right
@[simp]
theorem multispan_obj_right (b) : I.multispan.obj (WalkingMultispan.right b) = I.right b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) (b : I.R)
Goal: I.multispan.obj (CategoryTheory.Limits.WalkingMultispan.right b) = I.right b
-- CategoryTheory.Limits.MultispanIndex.multispan_map_fst
@[simp]
theorem multispan_map_fst (a) : I.multispan.map (WalkingMultispan.Hom.fst a) = I.fst a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) (a : I.L)
Goal: I.multispan.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst a) = I.fst a
-- CategoryTheory.Limits.MultispanIndex.multispan_map_snd
@[simp]
theorem multispan_map_snd (a) : I.multispan.map (WalkingMultispan.Hom.snd a) = I.snd a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) (a : I.L)
Goal: I.multispan.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd a) = I.snd a
-- CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap
@[reassoc (attr := simp)]
theorem ι_fstSigmaMap (b) : Sigma.ι I.left b ≫ I.fstSigmaMap = I.fst b ≫ Sigma.ι I.right _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : I.L)
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))
-- CategoryTheory.Limits.MultispanIndex.ι_sndSigmaMap
@[reassoc (attr := simp)]
theorem ι_sndSigmaMap (b) : Sigma.ι I.left b ≫ I.sndSigmaMap = I.snd b ≫ Sigma.ι I.right _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : I.L)
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))
-- CategoryTheory.Limits.Multifork.app_left_eq_ι
@[simp]
theorem app_left_eq_ι (a) : K.π.app (WalkingMulticospan.left a) = K.ι a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) (a : I.L)
Goal: K.π.app (CategoryTheory.Limits.WalkingMulticospan.left a) = K.ι a
-- CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst
@[simp]
theorem app_right_eq_ι_comp_fst (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.fstTo b) ≫ I.fst b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) (b : I.R)
Goal: K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b) =
  CategoryTheory.CategoryStruct.comp (K.ι (I.fstTo b)) (I.fst b)
-- CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_snd
@[reassoc]
theorem app_right_eq_ι_comp_snd (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.sndTo b) ≫ I.snd b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) (b : I.R)
Goal: K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b) =
  CategoryTheory.CategoryStruct.comp (K.ι (I.sndTo b)) (I.snd b)
-- CategoryTheory.Limits.Multifork.hom_comp_ι
@[reassoc (attr := simp)]
theorem hom_comp_ι (K₁ K₂ : Multifork I) (f : K₁ ⟶ K₂) (j : I.L) : f.hom ≫ K₂.ι j = K₁.ι j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K₁ K₂ : CategoryTheory.Limits.Multifork I) (f : K₁ ⟶ K₂) (j : I.L)
Goal: CategoryTheory.CategoryStruct.comp f.hom (K₂.ι j) = K₁.ι j
-- CategoryTheory.Limits.Multifork.ofι_pt
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) (P : C) (ι : (a : I.L) → P ⟶ I.left a) (w :
  ∀ (b : I.R),
    CategoryTheory.CategoryStruct.comp (ι (I.fstTo b)) (I.fst b) =
      CategoryTheory.CategoryStruct.comp (ι (I.sndTo b)) (I.snd b))
Goal: (CategoryTheory.Limits.Multifork.ofι I P ι w).pt = P
-- CategoryTheory.Limits.Multifork.ofι_π_app
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) (P : C) (ι : (a : I.L) → P ⟶ I.left a) (w :
  ∀ (b : I.R),
    CategoryTheory.CategoryStruct.comp (ι (I.fstTo b)) (I.fst b) =
      CategoryTheory.CategoryStruct.comp (ι (I.sndTo b)) (I.snd b)) (x : CategoryTheory.Limits.WalkingMulticospan I.fstTo I.sndTo)
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)
-- CategoryTheory.Limits.Multifork.condition
@[reassoc (attr := simp)]
theorem condition (b) : K.ι (I.fstTo b) ≫ I.fst b = K.ι (I.sndTo b) ≫ I.snd b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) (b : I.R)
Goal: CategoryTheory.CategoryStruct.comp (K.ι (I.fstTo b)) (I.fst b) =
  CategoryTheory.CategoryStruct.comp (K.ι (I.sndTo b)) (I.snd b)
-- CategoryTheory.Limits.Multifork.IsLimit.mk_lift
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) (lift : (E : CategoryTheory.Limits.Multifork I) → E.pt ⟶ K.pt) (fac : ∀ (E : CategoryTheory.Limits.Multifork I) (i : I.L), CategoryTheory.CategoryStruct.comp (lift E) (K.ι i) = E.ι i) (uniq :
  ∀ (E : CategoryTheory.Limits.Multifork I) (m : E.pt ⟶ K.pt),
    (∀ (i : I.L), CategoryTheory.CategoryStruct.comp m (K.ι i) = E.ι i) → m = lift E) (E : CategoryTheory.Limits.Multifork I)
Goal: (CategoryTheory.Limits.Multifork.IsLimit.mk K lift fac uniq).lift E = lift E
-- CategoryTheory.Limits.Multifork.IsLimit.hom_ext
lemma IsLimit.hom_ext (hK : IsLimit K) {T : C} {f g : T ⟶ K.pt}
    (h : ∀ a, f ≫ K.ι a = g ≫ K.ι a) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} {K : CategoryTheory.Limits.Multifork I} (hK : CategoryTheory.Limits.IsLimit K) {T : C} {f g : T ⟶ K.pt} (h : ∀ (a : I.L), CategoryTheory.CategoryStruct.comp f (K.ι a) = CategoryTheory.CategoryStruct.comp g (K.ι a))
Goal: f = g
-- CategoryTheory.Limits.Multifork.IsLimit.fac
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} {K : CategoryTheory.Limits.Multifork I} (hK : CategoryTheory.Limits.IsLimit K) {T : C} (k : (a : I.L) → T ⟶ I.left a) (hk :
  ∀ (b : I.R),
    CategoryTheory.CategoryStruct.comp (k (I.fstTo b)) (I.fst b) =
      CategoryTheory.CategoryStruct.comp (k (I.sndTo b)) (I.snd b)) (a : I.L)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multifork.IsLimit.lift hK k hk) (K.ι a) = k a
-- CategoryTheory.Limits.Multifork.pi_condition
@[reassoc (attr := simp)]
theorem pi_condition : Pi.lift K.ι ≫ I.fstPiMap = Pi.lift K.ι ≫ I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.lift K.ι) I.fstPiMap =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.lift K.ι) I.sndPiMap
-- CategoryTheory.Limits.Multifork.toPiFork_pt
@[simps pt]
noncomputable def toPiFork (K : Multifork I) : Fork I.fstPiMap I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (K : CategoryTheory.Limits.Multifork I)
Goal: K.toPiFork.pt = K.pt
-- CategoryTheory.Limits.Multifork.toPiFork_π_app_zero
@[simp]
theorem toPiFork_π_app_zero : K.toPiFork.ι = Pi.lift K.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
Goal: K.toPiFork.ι = CategoryTheory.Limits.Pi.lift K.ι
-- CategoryTheory.Limits.Multifork.toPiFork_π_app_one
@[simp]
theorem toPiFork_π_app_one : K.toPiFork.π.app WalkingParallelPair.one = Pi.lift K.ι ≫ I.fstPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MulticospanIndex C} (K : CategoryTheory.Limits.Multifork I) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
Goal: K.toPiFork.π.app CategoryTheory.Limits.WalkingParallelPair.one =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.lift K.ι) I.fstPiMap
-- CategoryTheory.Limits.Multifork.ofPiFork_pt
@[simps pt]
noncomputable def ofPiFork (c : Fork I.fstPiMap I.sndPiMap) : Multifork I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (c : CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap)
Goal: (CategoryTheory.Limits.Multifork.ofPiFork I c).pt = c.pt
-- CategoryTheory.Limits.Multifork.ofPiFork_π_app_left
@[simp]
theorem ofPiFork_π_app_left (c : Fork I.fstPiMap I.sndPiMap) (a) :
    (ofPiFork I c).ι a = c.ι ≫ Pi.π _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (c : CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap) (a : I.L)
Goal: (CategoryTheory.Limits.Multifork.ofPiFork I c).ι a =
  CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.Limits.Pi.π I.left a)
-- CategoryTheory.Limits.Multifork.ofPiFork_π_app_right
@[simp]
theorem ofPiFork_π_app_right (c : Fork I.fstPiMap I.sndPiMap) (a) :
    (ofPiFork I c).π.app (WalkingMulticospan.right a) = c.ι ≫ I.fstPiMap ≫ Pi.π _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (c : CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap) (a : I.R)
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))
-- CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_obj
@[simps]
noncomputable def toPiForkFunctor : Multifork I ⥤ Fork I.fstPiMap I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (K : CategoryTheory.Limits.Multifork I)
Goal: I.toPiForkFunctor.obj K = K.toPiFork
-- CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_map_hom
@[simps]
noncomputable def toPiForkFunctor : Multifork I ⥤ Fork I.fstPiMap I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] {K₁ K₂ : CategoryTheory.Limits.Multifork I} (f : K₁ ⟶ K₂)
Goal: (I.toPiForkFunctor.map f).hom = f.hom
-- CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_map_hom
@[simps]
noncomputable def ofPiForkFunctor : Fork I.fstPiMap I.sndPiMap ⥤ Multifork I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] {K₁ K₂ : CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap} (f : K₁ ⟶ K₂)
Goal: (I.ofPiForkFunctor.map f).hom = f.hom
-- CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_obj
@[simps]
noncomputable def ofPiForkFunctor : Fork I.fstPiMap I.sndPiMap ⥤ Multifork I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (c : CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap)
Goal: I.ofPiForkFunctor.obj c = CategoryTheory.Limits.Multifork.ofPiFork I c
-- CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
Goal: I.multiforkEquivPiFork.functor = I.toPiForkFunctor
-- CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_counitIso
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
Goal: I.multiforkEquivPiFork.counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun K =>
      CategoryTheory.Limits.Fork.ext (CategoryTheory.Iso.refl ((I.ofPiForkFunctor.comp I.toPiForkFunctor).obj K).pt) ⋯)
    ⋯
-- CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
Goal: I.multiforkEquivPiFork.inverse = I.ofPiForkFunctor
-- CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_unitIso
@[simps]
noncomputable def multiforkEquivPiFork : Multifork I ≌ Fork I.fstPiMap I.sndPiMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right]
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) ⋯)
    ⋯
-- CategoryTheory.Limits.Multicofork.π_eq_app_right
@[simp]
theorem π_eq_app_right (b) : K.ι.app (WalkingMultispan.right _) = K.π b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K : CategoryTheory.Limits.Multicofork I) (b : I.R)
Goal: K.ι.app (CategoryTheory.Limits.WalkingMultispan.right b) = K.π b
-- CategoryTheory.Limits.Multicofork.fst_app_right
@[simp]
theorem fst_app_right (a) : K.ι.app (WalkingMultispan.left a) = I.fst a ≫ K.π _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K : CategoryTheory.Limits.Multicofork I) (a : I.L)
Goal: K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) =
  CategoryTheory.CategoryStruct.comp (I.fst a) (K.π (I.fstFrom a))
-- CategoryTheory.Limits.Multicofork.snd_app_right
@[reassoc]
theorem snd_app_right (a) : K.ι.app (WalkingMultispan.left a) = I.snd a ≫ K.π _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K : CategoryTheory.Limits.Multicofork I) (a : I.L)
Goal: K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) =
  CategoryTheory.CategoryStruct.comp (I.snd a) (K.π (I.sndFrom a))
-- CategoryTheory.Limits.Multicofork.π_comp_hom
@[reassoc (attr := simp)]
lemma π_comp_hom (K₁ K₂ : Multicofork I) (f : K₁ ⟶ K₂) (b : I.R) : K₁.π b ≫ f.hom = K₂.π b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K₁ K₂ : CategoryTheory.Limits.Multicofork I) (f : K₁ ⟶ K₂) (b : I.R)
Goal: CategoryTheory.CategoryStruct.comp (K₁.π b) f.hom = K₂.π b
-- CategoryTheory.Limits.Multicofork.ofπ_pt
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) (P : C) (π : (b : I.R) → I.right b ⟶ P) (w :
  ∀ (a : I.L),
    CategoryTheory.CategoryStruct.comp (I.fst a) (π (I.fstFrom a)) =
      CategoryTheory.CategoryStruct.comp (I.snd a) (π (I.sndFrom a)))
Goal: (CategoryTheory.Limits.Multicofork.ofπ I P π w).pt = P
-- CategoryTheory.Limits.Multicofork.ofπ_ι_app
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) (P : C) (π : (b : I.R) → I.right b ⟶ P) (w :
  ∀ (a : I.L),
    CategoryTheory.CategoryStruct.comp (I.fst a) (π (I.fstFrom a)) =
      CategoryTheory.CategoryStruct.comp (I.snd a) (π (I.sndFrom a))) (x : CategoryTheory.Limits.WalkingMultispan I.fstFrom I.sndFrom)
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
-- CategoryTheory.Limits.Multicofork.condition
@[reassoc (attr := simp)]
theorem condition (a) : I.fst a ≫ K.π (I.fstFrom a) = I.snd a ≫ K.π (I.sndFrom a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K : CategoryTheory.Limits.Multicofork I) (a : I.L)
Goal: CategoryTheory.CategoryStruct.comp (I.fst a) (K.π (I.fstFrom a)) =
  CategoryTheory.CategoryStruct.comp (I.snd a) (K.π (I.sndFrom a))
-- CategoryTheory.Limits.Multicofork.IsColimit.mk_desc
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K : CategoryTheory.Limits.Multicofork I) (desc : (E : CategoryTheory.Limits.Multicofork I) → K.pt ⟶ E.pt) (fac :
  ∀ (E : CategoryTheory.Limits.Multicofork I) (i : I.R), CategoryTheory.CategoryStruct.comp (K.π i) (desc E) = E.π i) (uniq :
  ∀ (E : CategoryTheory.Limits.Multicofork I) (m : K.pt ⟶ E.pt),
    (∀ (i : I.R), CategoryTheory.CategoryStruct.comp (K.π i) m = E.π i) → m = desc E) (E : CategoryTheory.Limits.Multicofork I)
Goal: (CategoryTheory.Limits.Multicofork.IsColimit.mk K desc fac uniq).desc E = desc E
-- CategoryTheory.Limits.Multicofork.sigma_condition
@[reassoc (attr := simp)]
theorem sigma_condition : I.fstSigmaMap ≫ Sigma.desc K.π = I.sndSigmaMap ≫ Sigma.desc K.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K : CategoryTheory.Limits.Multicofork I) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right]
Goal: CategoryTheory.CategoryStruct.comp I.fstSigmaMap (CategoryTheory.Limits.Sigma.desc K.π) =
  CategoryTheory.CategoryStruct.comp I.sndSigmaMap (CategoryTheory.Limits.Sigma.desc K.π)
-- CategoryTheory.Limits.Multicofork.toSigmaCofork_pt
@[simps pt]
noncomputable def toSigmaCofork (K : Multicofork I) : Cofork I.fstSigmaMap I.sndSigmaMap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (K : CategoryTheory.Limits.Multicofork I)
Goal: K.toSigmaCofork.pt = K.pt
-- CategoryTheory.Limits.Multicofork.toSigmaCofork_π
@[simp]
theorem toSigmaCofork_π : K.toSigmaCofork.π = Sigma.desc K.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {I : CategoryTheory.Limits.MultispanIndex C} (K : CategoryTheory.Limits.Multicofork I) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right]
Goal: K.toSigmaCofork.π = CategoryTheory.Limits.Sigma.desc K.π
-- CategoryTheory.Limits.Multicofork.ofSigmaCofork_pt
@[simps pt]
noncomputable def ofSigmaCofork (c : Cofork I.fstSigmaMap I.sndSigmaMap) : Multicofork I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (c : CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap)
Goal: (CategoryTheory.Limits.Multicofork.ofSigmaCofork I c).pt = c.pt
-- CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_left
@[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.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MultispanIndex C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (c : CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap) (a : I.L)
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.π)