theorem exists_of_mem_parallel {S : WSeq (Computation α)} {a} (h : a ∈ parallel S) :
    ∃ c ∈ S, a ∈ c := by
  suffices
    ∀ C, a ∈ C → ∀ (l : List (Computation α)) (S),
      corec parallel.aux1 (l, S) = C → ∃ c, (c ∈ l ∨ c ∈ S) ∧ a ∈ c from
    let ⟨c, h1, h2⟩ := this _ h [] S rfl
    ⟨c, h1.resolve_left <| List.not_mem_nil _, h2⟩
  let F : List (Computation α) → Sum α (List (Computation α)) → Prop := by
    intro l a
    cases' a with a l'
    exact ∃ c ∈ l, a ∈ c
    exact ∀ a', (∃ c ∈ l', a' ∈ c) → ∃ c ∈ l, a' ∈ c
  have lem1 : ∀ l : List (Computation α), F l (parallel.aux2 l) := by
    intro l
    induction' l with c l IH <;> simp only [parallel.aux2, List.foldr]
    · intro a h
      rcases h with ⟨c, hn, _⟩
      exact False.elim <| List.not_mem_nil _ hn
    · simp only [parallel.aux2] at IH
      -- Porting note: `revert IH` & `intro IH` are required.
      revert IH
      

Proof state:
case cons
α : Type u
β : Type v
S : WSeq (Computation α)
a : α
h : a ∈ parallel S
F : List (Computation α) → α ⊕ List (Computation α) → Prop :=
  fun l a =>
    Sum.casesOn (motive := fun t => a = t → Prop) a (fun a_1 h => ∃ c, c ∈ l ∧ a_1 ∈ c)
      (fun l' h => ∀ (a' : α), (∃ c, c ∈ l' ∧ a' ∈ c) → ∃ c, c ∈ l ∧ a' ∈ c) (_ : a = a)
c : Computation α
l : List (Computation α)
⊢ Sum.rec (motive := fun t =>
      List.foldr
            (fun c o =>
              match o with
              | Sum.inl a => Sum.inl a
              | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
            (Sum.inr []) l =
          t →
        Prop)
      (fun val h => ∃ c, c ∈ l ∧ val ∈ c) (fun val h => ∀ (a' : α), (∃ c, c ∈ val ∧ a' ∈ c) → ∃ c, c ∈ l ∧ a' ∈ c)
      (List.foldr
        (fun c o =>
          match o with
          | Sum.inl a => Sum.inl a
          | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
        (Sum.inr []) l)
      (_ :
        List.foldr
            (fun c o =>
              match o with
              | Sum.inl a => Sum.inl a
              | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
            (Sum.inr []) l =
          List.foldr
            (fun c o =>
              match o with
              | Sum.inl a => Sum.inl a
              | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
            (Sum.inr []) l) →
    Sum.rec (motive := fun t =>
      (match
            List.foldr
              (fun c o =>
                match o with
                | Sum.inl a => Sum.inl a
                | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
              (Sum.inr []) l with
          | Sum.inl a => Sum.inl a
          | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c)) =
          t →
        Prop)
      (fun val h => ∃ c_1, c_1 ∈ c :: l ∧ val ∈ c_1)
      (fun val h => ∀ (a' : α), (∃ c, c ∈ val ∧ a' ∈ c) → ∃ c_1, c_1 ∈ c :: l ∧ a' ∈ c_1)
      (match
        List.foldr
          (fun c o =>
            match o with
            | Sum.inl a => Sum.inl a
            | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
          (Sum.inr []) l with
      | Sum.inl a => Sum.inl a
      | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
      (_ :
        (match
            List.foldr
              (fun c o =>
                match o with
                | Sum.inl a => Sum.inl a
                | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
              (Sum.inr []) l with
          | Sum.inl a => Sum.inl a
          | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c)) =
          match
            List.foldr
              (fun c o =>
                match o with
                | Sum.inl a => Sum.inl a
                | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
              (Sum.inr []) l with
          | Sum.inl a => Sum.inl a
          | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))

Next tactic:
cases' List.foldr (fun c o =>
        match o with
        | Sum.inl a => Sum.inl a
        | Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c)) (Sum.inr List.nil) l with a ls