l3lab/ntp-mathlib huggingface dataset:
/-- The multicospan associated to `I : MulticospanIndex`. -/
def multicospan : WalkingMulticospan I.fstTo I.sndTo ⥤ C where
  obj x :=
    match x with
    | WalkingMulticospan.left a => I.left a
    | WalkingMulticospan.right b => I.right b
  map {x y} f :=
    match x, y, f with
    | _, _, WalkingMulticospan.Hom.id x => 𝟙 _
    | _, _, WalkingMulticospan.Hom.fst b => I.fst _
    | _, _, WalkingMulticospan.Hom.snd b => I.snd _
  map_id := by
    rintro (_ | _) <;> 

Proof state:
case left
C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
a✝ : I.L
⊢ {
          obj := fun x =>
            match x with
            | WalkingMulticospan.left a => left I a
            | WalkingMulticospan.right b => right I b,
          map := fun {x y} f =>
            match x, y, f with
            | x, .(x), WalkingMulticospan.Hom.id .(x) =>
              𝟙
                ((fun x =>
                    match x with
                    | WalkingMulticospan.left a => left I a
                    | WalkingMulticospan.right b => right I b)
                  x)
            | .(WalkingMulticospan.left (fstTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
              fst I b
            | .(WalkingMulticospan.left (sndTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
              snd I b }.map
      (𝟙 (WalkingMulticospan.left a✝)) =
    𝟙
      ({
            obj := fun x =>
              match x with
              | WalkingMulticospan.left a => left I a
              | WalkingMulticospan.right b => right I b,
            map := fun {x y} f =>
              match x, y, f with
              | x, .(x), WalkingMulticospan.Hom.id .(x) =>
                𝟙
                  ((fun x =>
                      match x with
                      | WalkingMulticospan.left a => left I a
                      | WalkingMulticospan.right b => right I b)
                    x)
              | .(WalkingMulticospan.left (fstTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
                fst I b
              | .(WalkingMulticospan.left (sndTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
                snd I b }.obj
        (WalkingMulticospan.left a✝))

Next tactic:
rfl
/-- The multicospan associated to `I : MulticospanIndex`. -/
def multicospan : WalkingMulticospan I.fstTo I.sndTo ⥤ C where
  obj x :=
    match x with
    | WalkingMulticospan.left a => I.left a
    | WalkingMulticospan.right b => I.right b
  map {x y} f :=
    match x, y, f with
    | _, _, WalkingMulticospan.Hom.id x => 𝟙 _
    | _, _, WalkingMulticospan.Hom.fst b => I.fst _
    | _, _, WalkingMulticospan.Hom.snd b => I.snd _
  map_id := by
    rintro (_ | _) <;> 

Proof state:
case right
C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
a✝ : I.R
⊢ {
          obj := fun x =>
            match x with
            | WalkingMulticospan.left a => left I a
            | WalkingMulticospan.right b => right I b,
          map := fun {x y} f =>
            match x, y, f with
            | x, .(x), WalkingMulticospan.Hom.id .(x) =>
              𝟙
                ((fun x =>
                    match x with
                    | WalkingMulticospan.left a => left I a
                    | WalkingMulticospan.right b => right I b)
                  x)
            | .(WalkingMulticospan.left (fstTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
              fst I b
            | .(WalkingMulticospan.left (sndTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
              snd I b }.map
      (𝟙 (WalkingMulticospan.right a✝)) =
    𝟙
      ({
            obj := fun x =>
              match x with
              | WalkingMulticospan.left a => left I a
              | WalkingMulticospan.right b => right I b,
            map := fun {x y} f =>
              match x, y, f with
              | x, .(x), WalkingMulticospan.Hom.id .(x) =>
                𝟙
                  ((fun x =>
                      match x with
                      | WalkingMulticospan.left a => left I a
                      | WalkingMulticospan.right b => right I b)
                    x)
              | .(WalkingMulticospan.left (fstTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
                fst I b
              | .(WalkingMulticospan.left (sndTo I b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
                snd I b }.obj
        (WalkingMulticospan.right a✝))

Next tactic:
rfl
@[reassoc (attr := simp)]
theorem fstPiMap_π (b) : I.fstPiMap ≫ Pi.π I.right b = Pi.π I.left _ ≫ I.fst b := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
b : I.R
⊢ fstPiMap I ≫ Pi.π I.right b = Pi.π I.left (fstTo I b) ≫ fst I b

Next tactic:
simp [fstPiMap]
@[reassoc (attr := simp)]
theorem sndPiMap_π (b) : I.sndPiMap ≫ Pi.π I.right b = Pi.π I.left _ ≫ I.snd b := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
b : I.R
⊢ sndPiMap I ≫ Pi.π I.right b = Pi.π I.left (sndTo I b) ≫ snd I b

Next tactic:
simp [sndPiMap]
/-- The multispan associated to `I : MultispanIndex`. -/
def multispan : WalkingMultispan I.fstFrom I.sndFrom ⥤ C where
  obj x :=
    match x with
    | WalkingMultispan.left a => I.left a
    | WalkingMultispan.right b => I.right b
  map {x y} f :=
    match x, y, f with
    | _, _, WalkingMultispan.Hom.id x => 𝟙 _
    | _, _, WalkingMultispan.Hom.fst b => I.fst _
    | _, _, WalkingMultispan.Hom.snd b => I.snd _
  map_id := by
    

Proof state:
C : Type u
inst✝ : Category.{v, u} C
I : MultispanIndex C
⊢ ∀ (X : WalkingMultispan I.fstFrom I.sndFrom),
    {
            obj := fun x =>
              match x with
              | WalkingMultispan.left a => left I a
              | WalkingMultispan.right b => right I b,
            map := fun {x y} f =>
              match x, y, f with
              | x, .(x), WalkingMultispan.Hom.id .(x) =>
                𝟙
                  ((fun x =>
                      match x with
                      | WalkingMultispan.left a => left I a
                      | WalkingMultispan.right b => right I b)
                    x)
              | .(WalkingMultispan.left b), .(WalkingMultispan.right (fstFrom I b)), WalkingMultispan.Hom.fst b =>
                fst I b
              | .(WalkingMultispan.left b), .(WalkingMultispan.right (sndFrom I b)), WalkingMultispan.Hom.snd b =>
                snd I b }.map
        (𝟙 X) =
      𝟙
        ({
              obj := fun x =>
                match x with
                | WalkingMultispan.left a => left I a
                | WalkingMultispan.right b => right I b,
              map := fun {x y} f =>
                match x, y, f with
                | x, .(x), WalkingMultispan.Hom.id .(x) =>
                  𝟙
                    ((fun x =>
                        match x with
                        | WalkingMultispan.left a => left I a
                        | WalkingMultispan.right b => right I b)
                      x)
                | .(WalkingMultispan.left b), .(WalkingMultispan.right (fstFrom I b)), WalkingMultispan.Hom.fst b =>
                  fst I b
                | .(WalkingMultispan.left b), .(WalkingMultispan.right (sndFrom I b)), WalkingMultispan.Hom.snd b =>
                  snd I b }.obj
          X)

Next tactic:
rintro (_ | _)
/-- The multispan associated to `I : MultispanIndex`. -/
def multispan : WalkingMultispan I.fstFrom I.sndFrom ⥤ C where
  obj x :=
    match x with
    | WalkingMultispan.left a => I.left a
    | WalkingMultispan.right b => I.right b
  map {x y} f :=
    match x, y, f with
    | _, _, WalkingMultispan.Hom.id x => 𝟙 _
    | _, _, WalkingMultispan.Hom.fst b => I.fst _
    | _, _, WalkingMultispan.Hom.snd b => I.snd _
  map_id := by
    rintro (_ | _) <;> 

Proof state:
case left
C : Type u
inst✝ : Category.{v, u} C
I : MultispanIndex C
a✝ : I.L
⊢ {
          obj := fun x =>
            match x with
            | WalkingMultispan.left a => left I a
            | WalkingMultispan.right b => right I b,
          map := fun {x y} f =>
            match x, y, f with
            | x, .(x), WalkingMultispan.Hom.id .(x) =>
              𝟙
                ((fun x =>
                    match x with
                    | WalkingMultispan.left a => left I a
                    | WalkingMultispan.right b => right I b)
                  x)
            | .(WalkingMultispan.left b), .(WalkingMultispan.right (fstFrom I b)), WalkingMultispan.Hom.fst b => fst I b
            | .(WalkingMultispan.left b), .(WalkingMultispan.right (sndFrom I b)), WalkingMultispan.Hom.snd b =>
              snd I b }.map
      (𝟙 (WalkingMultispan.left a✝)) =
    𝟙
      ({
            obj := fun x =>
              match x with
              | WalkingMultispan.left a => left I a
              | WalkingMultispan.right b => right I b,
            map := fun {x y} f =>
              match x, y, f with
              | x, .(x), WalkingMultispan.Hom.id .(x) =>
                𝟙
                  ((fun x =>
                      match x with
                      | WalkingMultispan.left a => left I a
                      | WalkingMultispan.right b => right I b)
                    x)
              | .(WalkingMultispan.left b), .(WalkingMultispan.right (fstFrom I b)), WalkingMultispan.Hom.fst b =>
                fst I b
              | .(WalkingMultispan.left b), .(WalkingMultispan.right (sndFrom I b)), WalkingMultispan.Hom.snd b =>
                snd I b }.obj
        (WalkingMultispan.left a✝))

Next tactic:
rfl
/-- The multispan associated to `I : MultispanIndex`. -/
def multispan : WalkingMultispan I.fstFrom I.sndFrom ⥤ C where
  obj x :=
    match x with
    | WalkingMultispan.left a => I.left a
    | WalkingMultispan.right b => I.right b
  map {x y} f :=
    match x, y, f with
    | _, _, WalkingMultispan.Hom.id x => 𝟙 _
    | _, _, WalkingMultispan.Hom.fst b => I.fst _
    | _, _, WalkingMultispan.Hom.snd b => I.snd _
  map_id := by
    rintro (_ | _) <;> 

Proof state:
case right
C : Type u
inst✝ : Category.{v, u} C
I : MultispanIndex C
a✝ : I.R
⊢ {
          obj := fun x =>
            match x with
            | WalkingMultispan.left a => left I a
            | WalkingMultispan.right b => right I b,
          map := fun {x y} f =>
            match x, y, f with
            | x, .(x), WalkingMultispan.Hom.id .(x) =>
              𝟙
                ((fun x =>
                    match x with
                    | WalkingMultispan.left a => left I a
                    | WalkingMultispan.right b => right I b)
                  x)
            | .(WalkingMultispan.left b), .(WalkingMultispan.right (fstFrom I b)), WalkingMultispan.Hom.fst b => fst I b
            | .(WalkingMultispan.left b), .(WalkingMultispan.right (sndFrom I b)), WalkingMultispan.Hom.snd b =>
              snd I b }.map
      (𝟙 (WalkingMultispan.right a✝)) =
    𝟙
      ({
            obj := fun x =>
              match x with
              | WalkingMultispan.left a => left I a
              | WalkingMultispan.right b => right I b,
            map := fun {x y} f =>
              match x, y, f with
              | x, .(x), WalkingMultispan.Hom.id .(x) =>
                𝟙
                  ((fun x =>
                      match x with
                      | WalkingMultispan.left a => left I a
                      | WalkingMultispan.right b => right I b)
                    x)
              | .(WalkingMultispan.left b), .(WalkingMultispan.right (fstFrom I b)), WalkingMultispan.Hom.fst b =>
                fst I b
              | .(WalkingMultispan.left b), .(WalkingMultispan.right (sndFrom I b)), WalkingMultispan.Hom.snd b =>
                snd I b }.obj
        (WalkingMultispan.right a✝))

Next tactic:
rfl
@[reassoc (attr := simp)]
theorem ι_fstSigmaMap (b) : Sigma.ι I.left b ≫ I.fstSigmaMap = I.fst b ≫ Sigma.ι I.right _ := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.L
⊢ Sigma.ι I.left b ≫ fstSigmaMap I = fst I b ≫ Sigma.ι I.right (fstFrom I b)

Next tactic:
simp [fstSigmaMap]
@[reassoc (attr := simp)]
theorem ι_sndSigmaMap (b) : Sigma.ι I.left b ≫ I.sndSigmaMap = I.snd b ≫ Sigma.ι I.right _ := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b : I.L
⊢ Sigma.ι I.left b ≫ sndSigmaMap I = snd I b ≫ Sigma.ι I.right (sndFrom I b)

Next tactic:
simp [sndSigmaMap]
@[simp]
theorem app_right_eq_ι_comp_fst (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.fstTo b) ≫ I.fst b := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.right b) = ι K (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b

Next tactic:
rw [← K.w (WalkingMulticospan.Hom.fst b)]
@[simp]
theorem app_right_eq_ι_comp_fst (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.fstTo b) ≫ I.fst b := by
  rw [← K.w (WalkingMulticospan.Hom.fst b)]
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (MulticospanIndex.fstTo I b)) ≫
      (MulticospanIndex.multicospan I).map (WalkingMulticospan.Hom.fst b) =
    ι K (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b

Next tactic:
rfl
@[reassoc]
theorem app_right_eq_ι_comp_snd (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.sndTo b) ≫ I.snd b := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.right b) = ι K (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b

Next tactic:
rw [← K.w (WalkingMulticospan.Hom.snd b)]
@[reassoc]
theorem app_right_eq_ι_comp_snd (b) :
    K.π.app (WalkingMulticospan.right b) = K.ι (I.sndTo b) ≫ I.snd b := by
  rw [← K.w (WalkingMulticospan.Hom.snd b)]
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (MulticospanIndex.sndTo I b)) ≫
      (MulticospanIndex.multicospan I).map (WalkingMulticospan.Hom.snd b) =
    ι K (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b

Next tactic:
rfl
/-- 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 where
  pt := P
  π :=
    { app := fun x =>
        match x with
        | WalkingMulticospan.left a => ι _
        | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b
      naturality := by
        

Proof state:
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ MulticospanIndex.left I a
w :
  ∀ (b : I.R),
    ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
      ι (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
⊢ ∀ ⦃X Y : WalkingMulticospan I.fstTo I.sndTo⦄ (f : X ⟶ Y),
    ((Functor.const (WalkingMulticospan I.fstTo I.sndTo)).obj P).map f ≫
        (fun x =>
            match x with
            | WalkingMulticospan.left a => ι a
            | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
          Y =
      (fun x =>
            match x with
            | WalkingMulticospan.left a => ι a
            | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
          X ≫
        (MulticospanIndex.multicospan I).map f

Next tactic:
rintro (_ | _) (_ | _) (_ | _ | _)
/-- 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 where
  pt := P
  π :=
    { app := fun x =>
        match x with
        | WalkingMulticospan.left a => ι _
        | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;>
          

Proof state:
case left.left.id
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ MulticospanIndex.left I a
w :
  ∀ (b : I.R),
    ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
      ι (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
a✝ : I.L
⊢ ((Functor.const (WalkingMulticospan I.fstTo I.sndTo)).obj P).map
        (WalkingMulticospan.Hom.id (WalkingMulticospan.left a✝)) ≫
      (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.left a✝) =
    (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.left a✝) ≫
      (MulticospanIndex.multicospan I).map (WalkingMulticospan.Hom.id (WalkingMulticospan.left a✝))

Next tactic:
dsimp
/-- 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 where
  pt := P
  π :=
    { app := fun x =>
        match x with
        | WalkingMulticospan.left a => ι _
        | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;>
          

Proof state:
case left.right.fst
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ MulticospanIndex.left I a
w :
  ∀ (b : I.R),
    ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
      ι (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
a✝ : I.R
⊢ ((Functor.const (WalkingMulticospan I.fstTo I.sndTo)).obj P).map (WalkingMulticospan.Hom.fst a✝) ≫
      (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.right a✝) =
    (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.left (MulticospanIndex.fstTo I a✝)) ≫
      (MulticospanIndex.multicospan I).map (WalkingMulticospan.Hom.fst a✝)

Next tactic:
dsimp
/-- 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 where
  pt := P
  π :=
    { app := fun x =>
        match x with
        | WalkingMulticospan.left a => ι _
        | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;>
          

Proof state:
case left.right.snd
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ MulticospanIndex.left I a
w :
  ∀ (b : I.R),
    ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
      ι (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
a✝ : I.R
⊢ ((Functor.const (WalkingMulticospan I.fstTo I.sndTo)).obj P).map (WalkingMulticospan.Hom.snd a✝) ≫
      (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.right a✝) =
    (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.left (MulticospanIndex.sndTo I a✝)) ≫
      (MulticospanIndex.multicospan I).map (WalkingMulticospan.Hom.snd a✝)

Next tactic:
dsimp
/-- 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 where
  pt := P
  π :=
    { app := fun x =>
        match x with
        | WalkingMulticospan.left a => ι _
        | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;>
          

Proof state:
case right.right.id
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ MulticospanIndex.left I a
w :
  ∀ (b : I.R),
    ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
      ι (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
a✝ : I.R
⊢ ((Functor.const (WalkingMulticospan I.fstTo I.sndTo)).obj P).map
        (WalkingMulticospan.Hom.id (WalkingMulticospan.right a✝)) ≫
      (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.right a✝) =
    (fun x =>
          match x with
          | WalkingMulticospan.left a => ι a
          | WalkingMulticospan.right b => ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b)
        (WalkingMulticospan.right a✝) ≫
      (MulticospanIndex.multicospan I).map (WalkingMulticospan.Hom.id (WalkingMulticospan.right a✝))

Next tactic:
dsimp
/-- 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 where
  pt := P
  π :=
    { app := fun x =>
        match x with
        | WalkingMulticospan.left a => ι _
        | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;>
          dsimp <;>
          

Proof state:
case left.left.id
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ MulticospanIndex.left I a
w :
  ∀ (b : I.R),
    ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
      ι (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
a✝ : I.L
⊢ 𝟙 P ≫ ι a✝ = ι a✝ ≫ (MulticospanIndex.multicospan I).map (𝟙 (WalkingMulticospan.left a✝))

Next tactic:
simp only [Category.id_comp, Category.comp_id, Functor.map_id,
            MulticospanIndex.multicospan_obj_left, MulticospanIndex.multicospan_obj_right]
/-- 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 where
  pt := P
  π :=
    { app := fun x =>
        match x with
        | WalkingMulticospan.left a => ι _
        | WalkingMulticospan.right b => ι (I.fstTo b) ≫ I.fst b
      naturality := by
        rintro (_ | _) (_ | _) (_ | _ | _) <;>
          dsimp <;>
          

Proof state:
case left.right.fst
C : Type u
inst✝ : Category.{v, u} C
I✝ : MulticospanIndex C
K : Multifork I✝
I : MulticospanIndex C
P : C
ι : (a : I.L) → P ⟶ MulticospanIndex.left I a
w :
  ∀ (b : I.R),
    ι (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b =
      ι (MulticospanIndex.sndTo I b) ≫ MulticospanIndex.snd I b
a✝ : I.R
⊢ 𝟙 P ≫ ι (MulticospanIndex.fstTo I a✝) ≫ MulticospanIndex.fst I a✝ =
    ι (MulticospanIndex.fstTo I a✝) ≫ MulticospanIndex.fst I a✝

Next tactic:
simp only [Category.id_comp, Category.comp_id, Functor.map_id,
            MulticospanIndex.multicospan_obj_left, MulticospanIndex.multicospan_obj_right]