Theorem: CategoryTheory.Limits.MulticospanIndex.multicospan_obj
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
⊢ ∀ (X : WalkingMulticospan I.fstTo I.sndTo),
    {
            obj := fun x =>
              match x with
              | WalkingMulticospan.left a => I.left a
              | WalkingMulticospan.right b => I.right 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 => I.left a
                      | WalkingMulticospan.right b => I.right b)
                    x)
              | .(WalkingMulticospan.left (I.fstTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
                I.fst b
              | .(WalkingMulticospan.left (I.sndTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
                I.snd b }.map
        (𝟙 X) =
      𝟙
        ({
              obj := fun x =>
                match x with
                | WalkingMulticospan.left a => I.left a
                | WalkingMulticospan.right b => I.right 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 => I.left a
                        | WalkingMulticospan.right b => I.right b)
                      x)
                | .(WalkingMulticospan.left (I.fstTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
                  I.fst b
                | .(WalkingMulticospan.left (I.sndTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
                  I.snd b }.obj
          X)
state_after: no goals
tactic: rintro (_ | _) <;> rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
⊢ ∀ {X Y Z : WalkingMulticospan I.fstTo I.sndTo} (f : X ⟶ Y) (g : Y ⟶ Z),
    {
            obj := fun x =>
              match x with
              | WalkingMulticospan.left a => I.left a
              | WalkingMulticospan.right b => I.right 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 => I.left a
                      | WalkingMulticospan.right b => I.right b)
                    x)
              | .(WalkingMulticospan.left (I.fstTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
                I.fst b
              | .(WalkingMulticospan.left (I.sndTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
                I.snd b }.map
        (f ≫ g) =
      {
              obj := fun x =>
                match x with
                | WalkingMulticospan.left a => I.left a
                | WalkingMulticospan.right b => I.right 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 => I.left a
                        | WalkingMulticospan.right b => I.right b)
                      x)
                | .(WalkingMulticospan.left (I.fstTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
                  I.fst b
                | .(WalkingMulticospan.left (I.sndTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
                  I.snd b }.map
          f ≫
        {
              obj := fun x =>
                match x with
                | WalkingMulticospan.left a => I.left a
                | WalkingMulticospan.right b => I.right 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 => I.left a
                        | WalkingMulticospan.right b => I.right b)
                      x)
                | .(WalkingMulticospan.left (I.fstTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.fst b =>
                  I.fst b
                | .(WalkingMulticospan.left (I.sndTo b)), .(WalkingMulticospan.right b), WalkingMulticospan.Hom.snd b =>
                  I.snd b }.map
          g
state_after: no goals
tactic: rintro (_ | _) (_ | _) (_ | _) (_ | _ | _) (_ | _ | _) <;> aesop_cat