l3lab/ntp-mathlib huggingface dataset:
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> 

Proof state:
case zero.zero.id
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)).map
        (WalkingParallelPairHom.id WalkingParallelPair.zero) ≫
      (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.zero =
    (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.zero ≫
      ((Functor.const WalkingParallelPair).obj K.pt).map (WalkingParallelPairHom.id WalkingParallelPair.zero)

Next tactic:
dsimp
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> 

Proof state:
case zero.one.left
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)).map WalkingParallelPairHom.left ≫
      (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.one =
    (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.zero ≫
      ((Functor.const WalkingParallelPair).obj K.pt).map WalkingParallelPairHom.left

Next tactic:
dsimp
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> 

Proof state:
case zero.one.right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)).map WalkingParallelPairHom.right ≫
      (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.one =
    (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.zero ≫
      ((Functor.const WalkingParallelPair).obj K.pt).map WalkingParallelPairHom.right

Next tactic:
dsimp
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> 

Proof state:
case one.one.id
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)).map
        (WalkingParallelPairHom.id WalkingParallelPair.one) ≫
      (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.one =
    (fun x =>
          match x with
          | WalkingParallelPair.zero => MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)
          | WalkingParallelPair.one => Sigma.desc (π K))
        WalkingParallelPair.one ≫
      ((Functor.const WalkingParallelPair).obj K.pt).map (WalkingParallelPairHom.id WalkingParallelPair.one)

Next tactic:
dsimp
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> dsimp <;>
          

Proof state:
case zero.zero.id
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)).map (𝟙 WalkingParallelPair.zero) ≫
      MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K) =
    (MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)) ≫ 𝟙 K.pt

Next tactic:
simp only [Functor.map_id, parallelPair_obj_zero,
            parallelPair_obj_one, sigma_condition, Category.id_comp, Category.comp_id]
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> dsimp <;>
          

Proof state:
case zero.one.left
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K) = (MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)) ≫ 𝟙 K.pt

Next tactic:
simp only [Functor.map_id, parallelPair_obj_zero,
            parallelPair_obj_one, sigma_condition, Category.id_comp, Category.comp_id]
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> dsimp <;>
          

Proof state:
case zero.one.right
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ MultispanIndex.sndSigmaMap I ≫ Sigma.desc (π K) = (MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K)) ≫ 𝟙 K.pt

Next tactic:
simp only [Functor.map_id, parallelPair_obj_zero,
            parallelPair_obj_one, sigma_condition, Category.id_comp, Category.comp_id]
/-- 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 where
  pt := K.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingParallelPair.zero => I.fstSigmaMap ≫ Sigma.desc K.π
        | WalkingParallelPair.one => Sigma.desc K.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;> dsimp <;>
          

Proof state:
case one.one.id
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K✝ : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K : Multicofork I
⊢ (parallelPair (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)).map (𝟙 WalkingParallelPair.one) ≫
      Sigma.desc (π K) =
    Sigma.desc (π K) ≫ 𝟙 K.pt

Next tactic:
simp only [Functor.map_id, parallelPair_obj_zero,
            parallelPair_obj_one, sigma_condition, Category.id_comp, Category.comp_id]
/-- 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 where
  pt := c.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingMultispan.left a => (Sigma.ι I.left a : _) ≫ I.fstSigmaMap ≫ c.π
        | WalkingMultispan.right b => (Sigma.ι I.right b : _) ≫ c.π
      naturality := by
        

Proof state:
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
c : Cofork (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)
⊢ ∀ ⦃X Y : WalkingMultispan I.fstFrom I.sndFrom⦄ (f : X ⟶ Y),
    (MultispanIndex.multispan I).map f ≫
        (fun x =>
            match x with
            | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
            | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
          Y =
      (fun x =>
            match x with
            | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
            | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
          X ≫
        ((Functor.const (WalkingMultispan I.fstFrom I.sndFrom)).obj c.pt).map f

Next tactic:
rintro (_ | _) (_ | _) (_ | _ | _)
/-- 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 where
  pt := c.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingMultispan.left a => (Sigma.ι I.left a : _) ≫ I.fstSigmaMap ≫ c.π
        | WalkingMultispan.right b => (Sigma.ι I.right b : _) ≫ c.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _)
        · 

Proof state:
case left.left.id
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
c : Cofork (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)
a✝ : I.L
⊢ (MultispanIndex.multispan I).map (WalkingMultispan.Hom.id (WalkingMultispan.left a✝)) ≫
      (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.left a✝) =
    (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.left a✝) ≫
      ((Functor.const (WalkingMultispan I.fstFrom I.sndFrom)).obj c.pt).map
        (WalkingMultispan.Hom.id (WalkingMultispan.left a✝))

Next tactic:
simp
/-- 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 where
  pt := c.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingMultispan.left a => (Sigma.ι I.left a : _) ≫ I.fstSigmaMap ≫ c.π
        | WalkingMultispan.right b => (Sigma.ι I.right b : _) ≫ c.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _)
        · simp
        · 

Proof state:
case left.right.fst
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
c : Cofork (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)
a✝ : I.L
⊢ (MultispanIndex.multispan I).map (WalkingMultispan.Hom.fst a✝) ≫
      (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.right (MultispanIndex.fstFrom I a✝)) =
    (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.left a✝) ≫
      ((Functor.const (WalkingMultispan I.fstFrom I.sndFrom)).obj c.pt).map (WalkingMultispan.Hom.fst a✝)

Next tactic:
simp
/-- 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 where
  pt := c.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingMultispan.left a => (Sigma.ι I.left a : _) ≫ I.fstSigmaMap ≫ c.π
        | WalkingMultispan.right b => (Sigma.ι I.right b : _) ≫ c.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _)
        · simp
        · simp
        · 

Proof state:
case left.right.snd
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
c : Cofork (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)
a✝ : I.L
⊢ (MultispanIndex.multispan I).map (WalkingMultispan.Hom.snd a✝) ≫
      (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.right (MultispanIndex.sndFrom I a✝)) =
    (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.left a✝) ≫
      ((Functor.const (WalkingMultispan I.fstFrom I.sndFrom)).obj c.pt).map (WalkingMultispan.Hom.snd a✝)

Next tactic:
simp [c.condition]
/-- 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 where
  pt := c.pt
  ι :=
    { app := fun x =>
        match x with
        | WalkingMultispan.left a => (Sigma.ι I.left a : _) ≫ I.fstSigmaMap ≫ c.π
        | WalkingMultispan.right b => (Sigma.ι I.right b : _) ≫ c.π
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _)
        · simp
        · simp
        · simp [c.condition]
        · 

Proof state:
case right.right.id
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
K : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
c : Cofork (MultispanIndex.fstSigmaMap I) (MultispanIndex.sndSigmaMap I)
a✝ : I.R
⊢ (MultispanIndex.multispan I).map (WalkingMultispan.Hom.id (WalkingMultispan.right a✝)) ≫
      (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.right a✝) =
    (fun x =>
          match x with
          | WalkingMultispan.left a => Sigma.ι I.left a ≫ MultispanIndex.fstSigmaMap I ≫ Cofork.π c
          | WalkingMultispan.right b => Sigma.ι I.right b ≫ Cofork.π c)
        (WalkingMultispan.right a✝) ≫
      ((Functor.const (WalkingMultispan I.fstFrom I.sndFrom)).obj c.pt).map
        (WalkingMultispan.Hom.id (WalkingMultispan.right a✝))

Next tactic:
simp
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      

Proof state:
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ ∀ (j : WalkingParallelPair), (Multicofork.toSigmaCofork K₁).ι.app j ≫ f.hom = (Multicofork.toSigmaCofork K₂).ι.app j

Next tactic:
rintro (_|_)
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      

Proof state:
case zero
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.zero ≫ f.hom =
    (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.zero
case one
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.one ≫ f.hom =
    (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.one

Next tactic:
all_goals {
        apply colimit.hom_ext
        rintro ⟨j⟩
        simp }
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals 

Proof state:
case zero
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.zero ≫ f.hom =
    (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.zero

Next tactic:
{
        apply colimit.hom_ext
        rintro ⟨j⟩
        simp }
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals {
        

Proof state:
case zero
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.zero ≫ f.hom =
    (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.zero

Next tactic:
apply colimit.hom_ext
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals {
        apply colimit.hom_ext
        

Proof state:
case zero.w
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ ∀ (j : Discrete I.L),
    colimit.ι (Discrete.functor I.left) j ≫ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.zero ≫ f.hom =
      colimit.ι (Discrete.functor I.left) j ≫ (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.zero

Next tactic:
rintro ⟨j⟩
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals {
        apply colimit.hom_ext
        rintro ⟨j⟩
        

Proof state:
case zero.w.mk
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
j : I.L
⊢ colimit.ι (Discrete.functor I.left) { as := j } ≫
      (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.zero ≫ f.hom =
    colimit.ι (Discrete.functor I.left) { as := j } ≫ (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.zero

Next tactic:
simp
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals 

Proof state:
case one
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.one ≫ f.hom =
    (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.one

Next tactic:
{
        apply colimit.hom_ext
        rintro ⟨j⟩
        simp }
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals {
        

Proof state:
case one
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.one ≫ f.hom =
    (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.one

Next tactic:
apply colimit.hom_ext
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals {
        apply colimit.hom_ext
        

Proof state:
case one.w
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ ∀ (j : Discrete I.R),
    colimit.ι (Discrete.functor I.right) j ≫ (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.one ≫ f.hom =
      colimit.ι (Discrete.functor I.right) j ≫ (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.one

Next tactic:
rintro ⟨j⟩
/-- `Multicofork.toSigmaCofork` as a functor. -/
@[simps]
noncomputable def toSigmaCoforkFunctor : Multicofork I ⥤ Cofork I.fstSigmaMap I.sndSigmaMap where
  obj := Multicofork.toSigmaCofork
  map {K₁ K₂} f :=
  { hom := f.hom
    w := by
      rintro (_|_)
      all_goals {
        apply colimit.hom_ext
        rintro ⟨j⟩
        

Proof state:
case one.w.mk
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
j : I.R
⊢ colimit.ι (Discrete.functor I.right) { as := j } ≫
      (Multicofork.toSigmaCofork K₁).ι.app WalkingParallelPair.one ≫ f.hom =
    colimit.ι (Discrete.functor I.right) { as := j } ≫ (Multicofork.toSigmaCofork K₂).ι.app WalkingParallelPair.one

Next tactic:
simp
/-- `Multicofork.ofSigmaCofork` as a functor. -/
@[simps]
noncomputable def ofSigmaCoforkFunctor : Cofork I.fstSigmaMap I.sndSigmaMap ⥤ Multicofork I where
  obj := Multicofork.ofSigmaCofork I
  map {K₁ K₂} f :=
    { hom := f.hom
      w := by --sorry --by rintro (_ | _) <;> simp
        

Proof state:
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Cofork (fstSigmaMap I) (sndSigmaMap I)
f : K₁ ⟶ K₂
⊢ ∀ (j : WalkingMultispan I.fstFrom I.sndFrom),
    (Multicofork.ofSigmaCofork I K₁).ι.app j ≫ f.hom = (Multicofork.ofSigmaCofork I K₂).ι.app j

Next tactic:
rintro (_ | _)