l3lab/ntp-mathlib huggingface dataset:
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; 

Proof state:
α : Type u
β : Type v
γ : Type w
s : WSeq α
s1 s2 : Computation ℕ
h :
  ∃ l s,
    s1 =
        Computation.corec
          (fun x =>
            match x with
            | (n, s) =>
              match Seq.destruct s with
              | none => Sum.inl n
              | some (none, s') => Sum.inr (n, s')
              | some (some val, s') => Sum.inr (n + 1, s'))
          (List.length l, s) ∧
      s2 =
        Computation.map List.length
          (Computation.corec
            (fun x =>
              match x with
              | (l, s) =>
                match Seq.destruct s with
                | none => Sum.inl (List.reverse l)
                | some (none, s') => Sum.inr (l, s')
                | some (some a, s') => Sum.inr (a :: l, s'))
            (l, s))
⊢ Computation.BisimO
    (fun c1 c2 =>
      ∃ l s,
        c1 =
            Computation.corec
              (fun x =>
                match x with
                | (n, s) =>
                  match Seq.destruct s with
                  | none => Sum.inl n
                  | some (none, s') => Sum.inr (n, s')
                  | some (some val, s') => Sum.inr (n + 1, s'))
              (List.length l, s) ∧
          c2 =
            Computation.map List.length
              (Computation.corec
                (fun x =>
                  match x with
                  | (l, s) =>
                    match Seq.destruct s with
                    | none => Sum.inl (List.reverse l)
                    | some (none, s') => Sum.inr (l, s')
                    | some (some a, s') => Sum.inr (a :: l, s'))
                (l, s)))
    (Computation.destruct s1) (Computation.destruct s2)

Next tactic:
rcases h with ⟨l, s, h⟩
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; 

Proof state:
case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, s))
⊢ Computation.BisimO
    (fun c1 c2 =>
      ∃ l s,
        c1 =
            Computation.corec
              (fun x =>
                match x with
                | (n, s) =>
                  match Seq.destruct s with
                  | none => Sum.inl n
                  | some (none, s') => Sum.inr (n, s')
                  | some (some val, s') => Sum.inr (n + 1, s'))
              (List.length l, s) ∧
          c2 =
            Computation.map List.length
              (Computation.corec
                (fun x =>
                  match x with
                  | (l, s) =>
                    match Seq.destruct s with
                    | none => Sum.inl (List.reverse l)
                    | some (none, s') => Sum.inr (l, s')
                    | some (some a, s') => Sum.inr (a :: l, s'))
                (l, s)))
    (Computation.destruct s1) (Computation.destruct s2)

Next tactic:
rw [h.left, h.right]
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; rw [h.left, h.right]
  

Proof state:
case intro.intro
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, s))
⊢ Computation.BisimO
    (fun c1 c2 =>
      ∃ l s,
        c1 =
            Computation.corec
              (fun x =>
                match x with
                | (n, s) =>
                  match Seq.destruct s with
                  | none => Sum.inl n
                  | some (none, s') => Sum.inr (n, s')
                  | some (some val, s') => Sum.inr (n + 1, s'))
              (List.length l, s) ∧
          c2 =
            Computation.map List.length
              (Computation.corec
                (fun x =>
                  match x with
                  | (l, s) =>
                    match Seq.destruct s with
                    | none => Sum.inl (List.reverse l)
                    | some (none, s') => Sum.inr (l, s')
                    | some (some a, s') => Sum.inr (a :: l, s'))
                (l, s)))
    (Computation.destruct
      (Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, s)))
    (Computation.destruct
      (Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, s))))

Next tactic:
induction' s using WSeq.recOn with a s s
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; rw [h.left, h.right]
  induction' s using WSeq.recOn with a s s <;> simp [toList, nil, cons, think, length]
  · 

Proof state:
case intro.intro.h2
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
a : α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, cons a s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, cons a s))
⊢ ∃ l_1 s_1,
    Computation.corec
          (fun x =>
            match Seq.destruct x.2 with
            | none => Sum.inl x.1
            | some (none, s') => Sum.inr (x.1, s')
            | some (some val, s') => Sum.inr (x.1 + 1, s'))
          (List.length l + 1, s) =
        Computation.corec
          (fun x =>
            match Seq.destruct x.2 with
            | none => Sum.inl x.1
            | some (none, s') => Sum.inr (x.1, s')
            | some (some val, s') => Sum.inr (x.1 + 1, s'))
          (List.length l_1, s_1) ∧
      Computation.map List.length
          (Computation.corec
            (fun x =>
              match Seq.destruct x.2 with
              | none => Sum.inl (List.reverse x.1)
              | some (none, s') => Sum.inr (x.1, s')
              | some (some a, s') => Sum.inr (a :: x.1, s'))
            (a :: l, s)) =
        Computation.map List.length
          (Computation.corec
            (fun x =>
              match Seq.destruct x.2 with
              | none => Sum.inl (List.reverse x.1)
              | some (none, s') => Sum.inr (x.1, s')
              | some (some a, s') => Sum.inr (a :: x.1, s'))
            (l_1, s_1))

Next tactic:
refine' ⟨a::l, s, _, _⟩
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; rw [h.left, h.right]
  induction' s using WSeq.recOn with a s s <;> simp [toList, nil, cons, think, length]
  · refine' ⟨a::l, s, _, _⟩ <;> 

Proof state:
case intro.intro.h2.refine'_1
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
a : α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, cons a s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, cons a s))
⊢ Computation.corec
      (fun x =>
        match Seq.destruct x.2 with
        | none => Sum.inl x.1
        | some (none, s') => Sum.inr (x.1, s')
        | some (some val, s') => Sum.inr (x.1 + 1, s'))
      (List.length l + 1, s) =
    Computation.corec
      (fun x =>
        match Seq.destruct x.2 with
        | none => Sum.inl x.1
        | some (none, s') => Sum.inr (x.1, s')
        | some (some val, s') => Sum.inr (x.1 + 1, s'))
      (List.length (a :: l), s)

Next tactic:
simp
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; rw [h.left, h.right]
  induction' s using WSeq.recOn with a s s <;> simp [toList, nil, cons, think, length]
  · refine' ⟨a::l, s, _, _⟩ <;> 

Proof state:
case intro.intro.h2.refine'_2
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
a : α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, cons a s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, cons a s))
⊢ Computation.map List.length
      (Computation.corec
        (fun x =>
          match Seq.destruct x.2 with
          | none => Sum.inl (List.reverse x.1)
          | some (none, s') => Sum.inr (x.1, s')
          | some (some a, s') => Sum.inr (a :: x.1, s'))
        (a :: l, s)) =
    Computation.map List.length
      (Computation.corec
        (fun x =>
          match Seq.destruct x.2 with
          | none => Sum.inl (List.reverse x.1)
          | some (none, s') => Sum.inr (x.1, s')
          | some (some a, s') => Sum.inr (a :: x.1, s'))
        (a :: l, s))

Next tactic:
simp
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; rw [h.left, h.right]
  induction' s using WSeq.recOn with a s s <;> simp [toList, nil, cons, think, length]
  · refine' ⟨a::l, s, _, _⟩ <;> simp
  · 

Proof state:
case intro.intro.h3
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, think s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, think s))
⊢ ∃ l_1 s_1,
    Computation.corec
          (fun x =>
            match Seq.destruct x.2 with
            | none => Sum.inl x.1
            | some (none, s') => Sum.inr (x.1, s')
            | some (some val, s') => Sum.inr (x.1 + 1, s'))
          (List.length l, s) =
        Computation.corec
          (fun x =>
            match Seq.destruct x.2 with
            | none => Sum.inl x.1
            | some (none, s') => Sum.inr (x.1, s')
            | some (some val, s') => Sum.inr (x.1 + 1, s'))
          (List.length l_1, s_1) ∧
      Computation.map List.length
          (Computation.corec
            (fun x =>
              match Seq.destruct x.2 with
              | none => Sum.inl (List.reverse x.1)
              | some (none, s') => Sum.inr (x.1, s')
              | some (some a, s') => Sum.inr (a :: x.1, s'))
            (l, s)) =
        Computation.map List.length
          (Computation.corec
            (fun x =>
              match Seq.destruct x.2 with
              | none => Sum.inl (List.reverse x.1)
              | some (none, s') => Sum.inr (x.1, s')
              | some (some a, s') => Sum.inr (a :: x.1, s'))
            (l_1, s_1))

Next tactic:
refine' ⟨l, s, _, _⟩
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; rw [h.left, h.right]
  induction' s using WSeq.recOn with a s s <;> simp [toList, nil, cons, think, length]
  · refine' ⟨a::l, s, _, _⟩ <;> simp
  · refine' ⟨l, s, _, _⟩ <;> 

Proof state:
case intro.intro.h3.refine'_1
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, think s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, think s))
⊢ Computation.corec
      (fun x =>
        match Seq.destruct x.2 with
        | none => Sum.inl x.1
        | some (none, s') => Sum.inr (x.1, s')
        | some (some val, s') => Sum.inr (x.1 + 1, s'))
      (List.length l, s) =
    Computation.corec
      (fun x =>
        match Seq.destruct x.2 with
        | none => Sum.inl x.1
        | some (none, s') => Sum.inr (x.1, s')
        | some (some val, s') => Sum.inr (x.1 + 1, s'))
      (List.length l, s)

Next tactic:
simp
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) := by
  refine'
    Computation.eq_of_bisim
      (fun c1 c2 =>
        ∃ (l : List α) (s : WSeq α),
          c1 = Computation.corec (fun ⟨n, s⟩ =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some _, s') => Sum.inr (n + 1, s')) (l.length, s) ∧
            c2 = Computation.map List.length (Computation.corec (fun ⟨l, s⟩ =>
              match Seq.destruct s with
              | none => Sum.inl l.reverse
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a::l, s')) (l, s)))
      _ ⟨[], s, rfl, rfl⟩
  intro s1 s2 h; rcases h with ⟨l, s, h⟩; rw [h.left, h.right]
  induction' s using WSeq.recOn with a s s <;> simp [toList, nil, cons, think, length]
  · refine' ⟨a::l, s, _, _⟩ <;> simp
  · refine' ⟨l, s, _, _⟩ <;> 

Proof state:
case intro.intro.h3.refine'_2
α : Type u
β : Type v
γ : Type w
s✝ : WSeq α
s1 s2 : Computation ℕ
l : List α
s : WSeq α
h :
  s1 =
      Computation.corec
        (fun x =>
          match x with
          | (n, s) =>
            match Seq.destruct s with
            | none => Sum.inl n
            | some (none, s') => Sum.inr (n, s')
            | some (some val, s') => Sum.inr (n + 1, s'))
        (List.length l, think s) ∧
    s2 =
      Computation.map List.length
        (Computation.corec
          (fun x =>
            match x with
            | (l, s) =>
              match Seq.destruct s with
              | none => Sum.inl (List.reverse l)
              | some (none, s') => Sum.inr (l, s')
              | some (some a, s') => Sum.inr (a :: l, s'))
          (l, think s))
⊢ Computation.map List.length
      (Computation.corec
        (fun x =>
          match Seq.destruct x.2 with
          | none => Sum.inl (List.reverse x.1)
          | some (none, s') => Sum.inr (x.1, s')
          | some (some a, s') => Sum.inr (a :: x.1, s'))
        (l, s)) =
    Computation.map List.length
      (Computation.corec
        (fun x =>
          match Seq.destruct x.2 with
          | none => Sum.inl (List.reverse x.1)
          | some (none, s') => Sum.inr (x.1, s')
          | some (some a, s') => Sum.inr (a :: x.1, s'))
        (l, s))

Next tactic:
simp
@[simp]
theorem ofList_cons (a : α) (l) : ofList (a::l) = cons a (ofList l) :=
  show Seq.map some (Seq.ofList (a::l)) = Seq.cons (some a) (Seq.map some (Seq.ofList l)) by 

Proof state:
α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ Seq.map some ↑(a :: l) = Seq.cons (some a) (Seq.map some ↑l)

Next tactic:
simp