l3lab/ntp-mathlib huggingface dataset:
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x : ↑(Functor.sections (MulticospanIndex.multicospan I ⋙ forget C))
i : I.R
a :
  (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst i)
      (↑x (WalkingMulticospan.left (MulticospanIndex.fstTo I i))) =
    ↑x (WalkingMulticospan.right i)
⊢ (MulticospanIndex.fst I i) ((fun i => ↑x (WalkingMulticospan.left i)) (MulticospanIndex.fstTo I i)) =
    (MulticospanIndex.snd I i) ((fun i => ↑x (WalkingMulticospan.left i)) (MulticospanIndex.sndTo I i))

Next tactic:
have b := x.2 (WalkingMulticospan.Hom.snd i)
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x : ↑(Functor.sections (MulticospanIndex.multicospan I ⋙ forget C))
i : I.R
a :
  (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst i)
      (↑x (WalkingMulticospan.left (MulticospanIndex.fstTo I i))) =
    ↑x (WalkingMulticospan.right i)
b :
  (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd i)
      (↑x (WalkingMulticospan.left (MulticospanIndex.sndTo I i))) =
    ↑x (WalkingMulticospan.right i)
⊢ (MulticospanIndex.fst I i) ((fun i => ↑x (WalkingMulticospan.left i)) (MulticospanIndex.fstTo I i)) =
    (MulticospanIndex.snd I i) ((fun i => ↑x (WalkingMulticospan.left i)) (MulticospanIndex.sndTo I i))

Next tactic:
rw [← b] at a
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x : ↑(Functor.sections (MulticospanIndex.multicospan I ⋙ forget C))
i : I.R
a :
  (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst i)
      (↑x (WalkingMulticospan.left (MulticospanIndex.fstTo I i))) =
    (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd i)
      (↑x (WalkingMulticospan.left (MulticospanIndex.sndTo I i)))
b :
  (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd i)
      (↑x (WalkingMulticospan.left (MulticospanIndex.sndTo I i))) =
    ↑x (WalkingMulticospan.right i)
⊢ (MulticospanIndex.fst I i) ((fun i => ↑x (WalkingMulticospan.left i)) (MulticospanIndex.fstTo I i)) =
    (MulticospanIndex.snd I i) ((fun i => ↑x (WalkingMulticospan.left i)) (MulticospanIndex.sndTo I i))

Next tactic:
exact a
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x :
  { x //
    ∀ (i : I.R),
      (MulticospanIndex.fst I i) (x (MulticospanIndex.fstTo I i)) =
        (MulticospanIndex.snd I i) (x (MulticospanIndex.sndTo I i)) }
⊢ (fun j =>
      match j with
      | WalkingMulticospan.left a => ↑x a
      | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b))) ∈
    Functor.sections (MulticospanIndex.multicospan I ⋙ forget C)

Next tactic:
rintro (a | b) (a' | b') (f | f | f)
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · 

Proof state:
case left.left.id
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x :
  { x //
    ∀ (i : I.R),
      (MulticospanIndex.fst I i) (x (MulticospanIndex.fstTo I i)) =
        (MulticospanIndex.snd I i) (x (MulticospanIndex.sndTo I i)) }
a : I.L
⊢ (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.id (WalkingMulticospan.left a))
      ((fun j =>
          match j with
          | WalkingMulticospan.left a => ↑x a
          | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
        (WalkingMulticospan.left a)) =
    (fun j =>
        match j with
        | WalkingMulticospan.left a => ↑x a
        | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
      (WalkingMulticospan.left a)

Next tactic:
simp
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · 

Proof state:
case left.right.fst
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x :
  { x //
    ∀ (i : I.R),
      (MulticospanIndex.fst I i) (x (MulticospanIndex.fstTo I i)) =
        (MulticospanIndex.snd I i) (x (MulticospanIndex.sndTo I i)) }
b' : I.R
⊢ (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst b')
      ((fun j =>
          match j with
          | WalkingMulticospan.left a => ↑x a
          | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
        (WalkingMulticospan.left (MulticospanIndex.fstTo I b'))) =
    (fun j =>
        match j with
        | WalkingMulticospan.left a => ↑x a
        | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
      (WalkingMulticospan.right b')

Next tactic:
rfl
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · rfl
        · 

Proof state:
case left.right.snd
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x :
  { x //
    ∀ (i : I.R),
      (MulticospanIndex.fst I i) (x (MulticospanIndex.fstTo I i)) =
        (MulticospanIndex.snd I i) (x (MulticospanIndex.sndTo I i)) }
b' : I.R
⊢ (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd b')
      ((fun j =>
          match j with
          | WalkingMulticospan.left a => ↑x a
          | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
        (WalkingMulticospan.left (MulticospanIndex.sndTo I b'))) =
    (fun j =>
        match j with
        | WalkingMulticospan.left a => ↑x a
        | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
      (WalkingMulticospan.right b')

Next tactic:
dsimp
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · rfl
        · dsimp
          

Proof state:
case left.right.snd
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x :
  { x //
    ∀ (i : I.R),
      (MulticospanIndex.fst I i) (x (MulticospanIndex.fstTo I i)) =
        (MulticospanIndex.snd I i) (x (MulticospanIndex.sndTo I i)) }
b' : I.R
⊢ (forget C).map (MulticospanIndex.snd I b') (↑x (MulticospanIndex.sndTo I b')) =
    (MulticospanIndex.fst I b') (↑x (MulticospanIndex.fstTo I b'))

Next tactic:
exact (x.2 b').symm
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · rfl
        · dsimp
          exact (x.2 b').symm
        · 

Proof state:
case right.right.id
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x :
  { x //
    ∀ (i : I.R),
      (MulticospanIndex.fst I i) (x (MulticospanIndex.fstTo I i)) =
        (MulticospanIndex.snd I i) (x (MulticospanIndex.sndTo I i)) }
b : I.R
⊢ (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.id (WalkingMulticospan.right b))
      ((fun j =>
          match j with
          | WalkingMulticospan.left a => ↑x a
          | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
        (WalkingMulticospan.right b)) =
    (fun j =>
        match j with
        | WalkingMulticospan.left a => ↑x a
        | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
      (WalkingMulticospan.right b)

Next tactic:
simp
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · rfl
        · dsimp
          exact (x.2 b').symm
        · simp }
  left_inv := by
    

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
⊢ Function.LeftInverse
    (fun x =>
      {
        val := fun j =>
          match j with
          | WalkingMulticospan.left a => ↑x a
          | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)),
        property :=
          (_ :
            ∀ {j j' : WalkingMulticospan I.fstTo I.sndTo} (f : j ⟶ j'),
              (MulticospanIndex.multicospan I ⋙ forget C).map f
                  ((fun j =>
                      match j with
                      | WalkingMulticospan.left a => ↑x a
                      | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                    j) =
                (fun j =>
                    match j with
                    | WalkingMulticospan.left a => ↑x a
                    | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                  j') })
    fun x =>
    { val := fun i => ↑x (WalkingMulticospan.left i),
      property :=
        (_ :
          ∀ (i : I.R),
            (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst i)
                (↑x (WalkingMulticospan.left (MulticospanIndex.fstTo I i))) =
              (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd i)
                (↑x (WalkingMulticospan.left (MulticospanIndex.sndTo I i)))) }

Next tactic:
intro x
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · rfl
        · dsimp
          exact (x.2 b').symm
        · simp }
  left_inv := by
    intro x; 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x : ↑(Functor.sections (MulticospanIndex.multicospan I ⋙ forget C))
⊢ (fun x =>
        {
          val := fun j =>
            match j with
            | WalkingMulticospan.left a => ↑x a
            | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)),
          property :=
            (_ :
              ∀ {j j' : WalkingMulticospan I.fstTo I.sndTo} (f : j ⟶ j'),
                (MulticospanIndex.multicospan I ⋙ forget C).map f
                    ((fun j =>
                        match j with
                        | WalkingMulticospan.left a => ↑x a
                        | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                      j) =
                  (fun j =>
                      match j with
                      | WalkingMulticospan.left a => ↑x a
                      | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                    j') })
      ((fun x =>
          { val := fun i => ↑x (WalkingMulticospan.left i),
            property :=
              (_ :
                ∀ (i : I.R),
                  (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst i)
                      (↑x (WalkingMulticospan.left (MulticospanIndex.fstTo I i))) =
                    (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd i)
                      (↑x (WalkingMulticospan.left (MulticospanIndex.sndTo I i)))) })
        x) =
    x

Next tactic:
ext (a | b)
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · rfl
        · dsimp
          exact (x.2 b').symm
        · simp }
  left_inv := by
    intro x; ext (a | b)
    · 

Proof state:
case a.h.left
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x : ↑(Functor.sections (MulticospanIndex.multicospan I ⋙ forget C))
a : I.L
⊢ ↑((fun x =>
            {
              val := fun j =>
                match j with
                | WalkingMulticospan.left a => ↑x a
                | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)),
              property :=
                (_ :
                  ∀ {j j' : WalkingMulticospan I.fstTo I.sndTo} (f : j ⟶ j'),
                    (MulticospanIndex.multicospan I ⋙ forget C).map f
                        ((fun j =>
                            match j with
                            | WalkingMulticospan.left a => ↑x a
                            | WalkingMulticospan.right b =>
                              (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                          j) =
                      (fun j =>
                          match j with
                          | WalkingMulticospan.left a => ↑x a
                          | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                        j') })
          ((fun x =>
              { val := fun i => ↑x (WalkingMulticospan.left i),
                property :=
                  (_ :
                    ∀ (i : I.R),
                      (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst i)
                          (↑x (WalkingMulticospan.left (MulticospanIndex.fstTo I i))) =
                        (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd i)
                          (↑x (WalkingMulticospan.left (MulticospanIndex.sndTo I i)))) })
            x))
      (WalkingMulticospan.left a) =
    ↑x (WalkingMulticospan.left a)

Next tactic:
rfl
/-- An auxiliary equivalence to be used in `multiequalizerEquiv` below.-/
def multiequalizerEquivAux (I : MulticospanIndex C) :
    (I.multicospan ⋙ forget C).sections ≃
    { x : ∀ i : I.L, I.left i // ∀ i : I.R, I.fst i (x _) = I.snd i (x _) } where
  toFun x :=
    ⟨fun i => x.1 (WalkingMulticospan.left _), fun i => by
      have a := x.2 (WalkingMulticospan.Hom.fst i)
      have b := x.2 (WalkingMulticospan.Hom.snd i)
      rw [← b] at a
      exact a⟩
  invFun x :=
    { val := fun j =>
        match j with
        | WalkingMulticospan.left a => x.1 _
        | WalkingMulticospan.right b => I.fst b (x.1 _)
      property := by
        rintro (a | b) (a' | b') (f | f | f)
        · simp
        · rfl
        · dsimp
          exact (x.2 b').symm
        · simp }
  left_inv := by
    intro x; ext (a | b)
    · rfl
    · 

Proof state:
case a.h.right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
I : MulticospanIndex C
x : ↑(Functor.sections (MulticospanIndex.multicospan I ⋙ forget C))
b : I.R
⊢ ↑((fun x =>
            {
              val := fun j =>
                match j with
                | WalkingMulticospan.left a => ↑x a
                | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)),
              property :=
                (_ :
                  ∀ {j j' : WalkingMulticospan I.fstTo I.sndTo} (f : j ⟶ j'),
                    (MulticospanIndex.multicospan I ⋙ forget C).map f
                        ((fun j =>
                            match j with
                            | WalkingMulticospan.left a => ↑x a
                            | WalkingMulticospan.right b =>
                              (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                          j) =
                      (fun j =>
                          match j with
                          | WalkingMulticospan.left a => ↑x a
                          | WalkingMulticospan.right b => (MulticospanIndex.fst I b) (↑x (MulticospanIndex.fstTo I b)))
                        j') })
          ((fun x =>
              { val := fun i => ↑x (WalkingMulticospan.left i),
                property :=
                  (_ :
                    ∀ (i : I.R),
                      (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.fst i)
                          (↑x (WalkingMulticospan.left (MulticospanIndex.fstTo I i))) =
                        (MulticospanIndex.multicospan I ⋙ forget C).map (WalkingMulticospan.Hom.snd i)
                          (↑x (WalkingMulticospan.left (MulticospanIndex.sndTo I i)))) })
            x))
      (WalkingMulticospan.right b) =
    ↑x (WalkingMulticospan.right b)

Next tactic:
rw [← x.2 (WalkingMulticospan.Hom.fst b)]