ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Stream'.WSeq.head_terminates_of_mem
theorem head_terminates_of_mem {s : WSeq α} {a} (h : a ∈ s) : Terminates (head s) 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α} (h : a ∈ s)
Goal: s.head.Terminates
-- Stream'.WSeq.of_mem_append
theorem of_mem_append {s₁ s₂ : WSeq α} {a : α} : a ∈ append s₁ s₂ → a ∈ s₁ ∨ a ∈ s₂ 
Arguments: {α : Type u} {s₁ s₂ : Stream'.WSeq α} {a : α}
Goal: a ∈ s₁.append s₂ → a ∈ s₁ ∨ a ∈ s₂
-- Stream'.WSeq.mem_append_left
theorem mem_append_left {s₁ s₂ : WSeq α} {a : α} : a ∈ s₁ → a ∈ append s₁ s₂ 
Arguments: {α : Type u} {s₁ s₂ : Stream'.WSeq α} {a : α}
Goal: a ∈ s₁ → a ∈ s₁.append s₂
-- Stream'.WSeq.exists_of_mem_map
theorem exists_of_mem_map {f} {b : β} : ∀ {s : WSeq α}, b ∈ map f s → ∃ a, a ∈ s ∧ f a = b
  
Arguments: {α : Type u} {β : Type v} {f : α → β} {b : β} {s : Stream'.WSeq α}
Goal: b ∈ Stream'.WSeq.map f s → ∃ a, a ∈ s ∧ f a = b
-- Stream'.WSeq.liftRel_nil
@[simp]
theorem liftRel_nil (R : α → β → Prop) : LiftRel R nil nil 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop)
Goal: Stream'.WSeq.LiftRel R Stream'.WSeq.nil Stream'.WSeq.nil
-- Stream'.WSeq.liftRel_cons
@[simp]
theorem liftRel_cons (R : α → β → Prop) (a b s t) :
    LiftRel R (cons a s) (cons b t) ↔ R a b ∧ LiftRel R s t 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (a : α) (b : β) (s : Stream'.WSeq α) (t : Stream'.WSeq β)
Goal: Stream'.WSeq.LiftRel R (Stream'.WSeq.cons a s) (Stream'.WSeq.cons b t) ↔ R a b ∧ Stream'.WSeq.LiftRel R s t
-- Stream'.WSeq.liftRel_think_left
@[simp]
theorem liftRel_think_left (R : α → β → Prop) (s t) : LiftRel R (think s) t ↔ LiftRel R s t 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (s : Stream'.WSeq α) (t : Stream'.WSeq β)
Goal: Stream'.WSeq.LiftRel R s.think t ↔ Stream'.WSeq.LiftRel R s t
-- Stream'.WSeq.liftRel_think_right
@[simp]
theorem liftRel_think_right (R : α → β → Prop) (s t) : LiftRel R s (think t) ↔ LiftRel R s t 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (s : Stream'.WSeq α) (t : Stream'.WSeq β)
Goal: Stream'.WSeq.LiftRel R s t.think ↔ Stream'.WSeq.LiftRel R s t
-- Stream'.WSeq.cons_congr
theorem cons_congr {s t : WSeq α} (a : α) (h : s ~ʷ t) : cons a s ~ʷ cons a t 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (a : α) (h : s ~ʷ t)
Goal: Stream'.WSeq.cons a s ~ʷ Stream'.WSeq.cons a t
-- Stream'.WSeq.think_equiv
theorem think_equiv (s : WSeq α) : think s ~ʷ s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.think ~ʷ s
-- Stream'.WSeq.think_congr
theorem think_congr {s t : WSeq α} (h : s ~ʷ t) : think s ~ʷ think t 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (h : s ~ʷ t)
Goal: s.think ~ʷ t.think
-- Stream'.WSeq.head_congr
theorem head_congr : ∀ {s t : WSeq α}, s ~ʷ t → head s ~ head t 
Arguments: {α : Type u} {s t : Stream'.WSeq α}
Goal: s ~ʷ t → s.head.Equiv t.head
-- Stream'.WSeq.flatten_equiv
theorem flatten_equiv {c : Computation (WSeq α)} {s} (h : s ∈ c) : flatten c ~ʷ s 
Arguments: {α : Type u} {c : Computation (Stream'.WSeq α)} {s : Stream'.WSeq α} (h : s ∈ c)
Goal: Stream'.WSeq.flatten c ~ʷ s
-- Stream'.WSeq.liftRel_flatten
theorem liftRel_flatten {R : α → β → Prop} {c1 : Computation (WSeq α)} {c2 : Computation (WSeq β)}
    (h : c1.LiftRel (LiftRel R) c2) : LiftRel R (flatten c1) (flatten c2) 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {c1 : Computation (Stream'.WSeq α)} {c2 : Computation (Stream'.WSeq β)} (h : Computation.LiftRel (Stream'.WSeq.LiftRel R) c1 c2)
Goal: Stream'.WSeq.LiftRel R (Stream'.WSeq.flatten c1) (Stream'.WSeq.flatten c2)
-- Stream'.WSeq.flatten_congr
theorem flatten_congr {c1 c2 : Computation (WSeq α)} :
    Computation.LiftRel Equiv c1 c2 → flatten c1 ~ʷ flatten c2 
Arguments: {α : Type u} {c1 c2 : Computation (Stream'.WSeq α)}
Goal: Computation.LiftRel Stream'.WSeq.Equiv c1 c2 → Stream'.WSeq.flatten c1 ~ʷ Stream'.WSeq.flatten c2
-- Stream'.WSeq.tail_congr
theorem tail_congr {s t : WSeq α} (h : s ~ʷ t) : tail s ~ʷ tail t 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (h : s ~ʷ t)
Goal: s.tail ~ʷ t.tail
-- Stream'.WSeq.dropn_congr
theorem dropn_congr {s t : WSeq α} (h : s ~ʷ t) (n) : drop s n ~ʷ drop t n 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (h : s ~ʷ t) (n : ℕ)
Goal: s.drop n ~ʷ t.drop n
-- Stream'.WSeq.get?_congr
theorem get?_congr {s t : WSeq α} (h : s ~ʷ t) (n) : get? s n ~ get? t n 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (h : s ~ʷ t) (n : ℕ)
Goal: (s.get? n).Equiv (t.get? n)
-- Stream'.WSeq.mem_congr
theorem mem_congr {s t : WSeq α} (h : s ~ʷ t) (a) : a ∈ s ↔ a ∈ t 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (h : s ~ʷ t) (a : α)
Goal: a ∈ s ↔ a ∈ t
-- Stream'.WSeq.productive_congr
theorem productive_congr {s t : WSeq α} (h : s ~ʷ t) : Productive s ↔ Productive t 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (h : s ~ʷ t)
Goal: s.Productive ↔ t.Productive
-- Stream'.WSeq.Equiv.ext
theorem Equiv.ext {s t : WSeq α} (h : ∀ n, get? s n ~ get? t n) : s ~ʷ t 
Arguments: {α : Type u} {s t : Stream'.WSeq α} (h : ∀ (n : ℕ), (s.get? n).Equiv (t.get? n))
Goal: s ~ʷ t
-- Stream'.WSeq.length_eq_map
theorem length_eq_map (s : WSeq α) : length s = Computation.map List.length (toList s) 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.length = Computation.map List.length s.toList
-- Stream'.WSeq.ofList_nil
@[simp]
theorem ofList_nil : ofList [] = (nil : WSeq α) 
Arguments: {α : Type u}
Goal: ↑[] = Stream'.WSeq.nil
-- Stream'.WSeq.ofList_cons
@[simp]
theorem ofList_cons (a : α) (l) : ofList (a::l) = cons a (ofList l) 
Arguments: {α : Type u} (a : α) (l : List α)
Goal: ↑(a :: l) = Stream'.WSeq.cons a ↑l
-- Stream'.WSeq.toList'_nil
@[simp]
theorem toList'_nil (l : List α) :
    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, nil) = Computation.pure l.reverse 
Arguments: {α : Type u} (l : List α)
Goal: Computation.corec
    (fun x =>
      match x with
      | (l, s) =>
        match Stream'.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, Stream'.WSeq.nil) =
  Computation.pure l.reverse
-- Stream'.WSeq.toList'_cons
@[simp]
theorem toList'_cons (l : List α) (s : WSeq α) (a : α) :
    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, cons a s) =
      (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')) (a::l, s)).think 
Arguments: {α : Type u} (l : List α) (s : Stream'.WSeq α) (a : α)
Goal: Computation.corec
    (fun x =>
      match x with
      | (l, s) =>
        match Stream'.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, Stream'.WSeq.cons a s) =
  (Computation.corec
      (fun x =>
        match x with
        | (l, s) =>
          match Stream'.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'))
      (a :: l, s)).think
-- Stream'.WSeq.toList'_think
@[simp]
theorem toList'_think (l : List α) (s : WSeq α) :
    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, think s) =
      (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)).think 
Arguments: {α : Type u} (l : List α) (s : Stream'.WSeq α)
Goal: Computation.corec
    (fun x =>
      match x with
      | (l, s) =>
        match Stream'.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.think) =
  (Computation.corec
      (fun x =>
        match x with
        | (l, s) =>
          match Stream'.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)).think
-- Stream'.WSeq.toList'_map
theorem toList'_map (l : List α) (s : WSeq α) :
    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) = (l.reverse ++ ·) <$> toList s 
Arguments: {α : Type u} (l : List α) (s : Stream'.WSeq α)
Goal: Computation.corec
    (fun x =>
      match x with
      | (l, s) =>
        match Stream'.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) =
  (fun x => l.reverse ++ x) <$> s.toList
-- Stream'.WSeq.toList_cons
@[simp]
theorem toList_cons (a : α) (s) : toList (cons a s) = (List.cons a <$> toList s).think 
Arguments: {α : Type u} (a : α) (s : Stream'.WSeq α)
Goal: (Stream'.WSeq.cons a s).toList = (List.cons a <$> s.toList).think
-- Stream'.WSeq.toList_nil
@[simp]
theorem toList_nil : toList (nil : WSeq α) = Computation.pure [] 
Arguments: {α : Type u}
Goal: Stream'.WSeq.nil.toList = Computation.pure []
-- Stream'.WSeq.toList_ofList
theorem toList_ofList (l : List α) : l ∈ toList (ofList l) 
Arguments: {α : Type u} (l : List α)
Goal: l ∈ (↑l).toList
-- Stream'.WSeq.destruct_ofSeq
@[simp]
theorem destruct_ofSeq (s : Seq α) :
    destruct (ofSeq s) = Computation.pure (s.head.map fun a => (a, ofSeq s.tail)) 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: (↑s).destruct = Computation.pure (Option.map (fun a => (a, ↑s.tail)) s.head)
-- Stream'.WSeq.head_ofSeq
@[simp]
theorem head_ofSeq (s : Seq α) : head (ofSeq s) = Computation.pure s.head 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: (↑s).head = Computation.pure s.head
-- Stream'.WSeq.tail_ofSeq
@[simp]
theorem tail_ofSeq (s : Seq α) : tail (ofSeq s) = ofSeq s.tail 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: (↑s).tail = ↑s.tail
-- Stream'.WSeq.dropn_ofSeq
@[simp]
theorem dropn_ofSeq (s : Seq α) : ∀ n, drop (ofSeq s) n = ofSeq (s.drop n)
  
Arguments: {α : Type u} (s : Stream'.Seq α) (n : ℕ)
Goal: (↑s).drop n = ↑(s.drop n)
-- Stream'.WSeq.get?_ofSeq
theorem get?_ofSeq (s : Seq α) (n) : get? (ofSeq s) n = Computation.pure (Seq.get? s n) 
Arguments: {α : Type u} (s : Stream'.Seq α) (n : ℕ)
Goal: (↑s).get? n = Computation.pure (s.get? n)
-- Stream'.WSeq.toSeq_ofSeq
theorem toSeq_ofSeq (s : Seq α) : toSeq (ofSeq s) = s 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: (↑s).toSeq = s
-- Stream'.WSeq.map_nil
@[simp]
theorem map_nil (f : α → β) : map f nil = nil 
Arguments: {α : Type u} {β : Type v} (f : α → β)
Goal: Stream'.WSeq.map f Stream'.WSeq.nil = Stream'.WSeq.nil
-- Stream'.WSeq.map_cons
@[simp]
theorem map_cons (f : α → β) (a s) : map f (cons a s) = cons (f a) (map f s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α) (s : Stream'.WSeq α)
Goal: Stream'.WSeq.map f (Stream'.WSeq.cons a s) = Stream'.WSeq.cons (f a) (Stream'.WSeq.map f s)
-- Stream'.WSeq.map_think
@[simp]
theorem map_think (f : α → β) (s) : map f (think s) = think (map f s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream'.WSeq α)
Goal: Stream'.WSeq.map f s.think = (Stream'.WSeq.map f s).think
-- Stream'.WSeq.map_id
@[simp]
theorem map_id (s : WSeq α) : map id s = s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: Stream'.WSeq.map id s = s
-- Stream'.WSeq.map_ret
@[simp]
theorem map_ret (f : α → β) (a) : map f (ret a) = ret (f a) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α)
Goal: Stream'.WSeq.map f (Stream'.WSeq.ret a) = Stream'.WSeq.ret (f a)
-- Stream'.WSeq.map_append
@[simp]
theorem map_append (f : α → β) (s t) : map f (append s t) = append (map f s) (map f t) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s t : Stream'.WSeq α)
Goal: Stream'.WSeq.map f (s.append t) = (Stream'.WSeq.map f s).append (Stream'.WSeq.map f t)
-- Stream'.WSeq.map_comp
theorem map_comp (f : α → β) (g : β → γ) (s : WSeq α) : map (g ∘ f) s = map g (map f s) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (s : Stream'.WSeq α)
Goal: Stream'.WSeq.map (g ∘ f) s = Stream'.WSeq.map g (Stream'.WSeq.map f s)
-- Stream'.WSeq.mem_map
theorem mem_map (f : α → β) {a : α} {s : WSeq α} : a ∈ s → f a ∈ map f s 
Arguments: {α : Type u} {β : Type v} (f : α → β) {a : α} {s : Stream'.WSeq α}
Goal: a ∈ s → f a ∈ Stream'.WSeq.map f s
-- Stream'.WSeq.exists_of_mem_join
theorem exists_of_mem_join {a : α} : ∀ {S : WSeq (WSeq α)}, a ∈ join S → ∃ s, s ∈ S ∧ a ∈ s 
Arguments: {α : Type u} {a : α} {S : Stream'.WSeq (Stream'.WSeq α)}
Goal: a ∈ S.join → ∃ s, s ∈ S ∧ a ∈ s
-- Stream'.WSeq.exists_of_mem_bind
theorem exists_of_mem_bind {s : WSeq α} {f : α → WSeq β} {b} (h : b ∈ bind s f) :
    ∃ a ∈ s, b ∈ f a 
Arguments: {α : Type u} {β : Type v} {s : Stream'.WSeq α} {f : α → Stream'.WSeq β} {b : β} (h : b ∈ s.bind f)
Goal: ∃ a, a ∈ s ∧ b ∈ f a
-- Stream'.WSeq.destruct_map
theorem destruct_map (f : α → β) (s : WSeq α) :
    destruct (map f s) = Computation.map (Option.map (Prod.map f (map f))) (destruct s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream'.WSeq α)
Goal: (Stream'.WSeq.map f s).destruct = Computation.map (Option.map (Prod.map f (Stream'.WSeq.map f))) s.destruct
-- Stream'.WSeq.liftRel_map
theorem liftRel_map {δ} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : WSeq α} {s2 : WSeq β}
    {f1 : α → γ} {f2 : β → δ} (h1 : LiftRel R s1 s2) (h2 : ∀ {a b}, R a b → S (f1 a) (f2 b)) :
    LiftRel S (map f1 s1) (map f2 s2) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : Stream'.WSeq α} {s2 : Stream'.WSeq β} {f1 : α → γ} {f2 : β → δ} (h1 : Stream'.WSeq.LiftRel R s1 s2) (h2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b))
Goal: Stream'.WSeq.LiftRel S (Stream'.WSeq.map f1 s1) (Stream'.WSeq.map f2 s2)
-- Stream'.WSeq.map_congr
theorem map_congr (f : α → β) {s t : WSeq α} (h : s ~ʷ t) : map f s ~ʷ map f t 
Arguments: {α : Type u} {β : Type v} (f : α → β) {s t : Stream'.WSeq α} (h : s ~ʷ t)
Goal: Stream'.WSeq.map f s ~ʷ Stream'.WSeq.map f t
-- Stream'.WSeq.destruct_append
theorem destruct_append (s t : WSeq α) :
    destruct (append s t) = (destruct s).bind (destruct_append.aux t) 
Arguments: {α : Type u} (s t : Stream'.WSeq α)
Goal: (s.append t).destruct = s.destruct.bind (Stream'.WSeq.destruct_append.aux t)
-- Stream'.WSeq.destruct_join
theorem destruct_join (S : WSeq (WSeq α)) :
    destruct (join S) = (destruct S).bind destruct_join.aux 
Arguments: {α : Type u} (S : Stream'.WSeq (Stream'.WSeq α))
Goal: S.join.destruct = S.destruct.bind Stream'.WSeq.destruct_join.aux
-- Stream'.WSeq.liftRel_append
theorem liftRel_append (R : α → β → Prop) {s1 s2 : WSeq α} {t1 t2 : WSeq β} (h1 : LiftRel R s1 t1)
    (h2 : LiftRel R s2 t2) : LiftRel R (append s1 s2) (append t1 t2) 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) {s1 s2 : Stream'.WSeq α} {t1 t2 : Stream'.WSeq β} (h1 : Stream'.WSeq.LiftRel R s1 t1) (h2 : Stream'.WSeq.LiftRel R s2 t2)
Goal: Stream'.WSeq.LiftRel R (s1.append s2) (t1.append t2)
-- Stream'.WSeq.liftRel_join.lem
theorem liftRel_join.lem (R : α → β → Prop) {S T} {U : WSeq α → WSeq β → Prop}
    (ST : LiftRel (LiftRel R) S T)
    (HU :
      ∀ s1 s2,
        (∃ s t S T,
            s1 = append s (join S) ∧
              s2 = append t (join T) ∧ LiftRel R s t ∧ LiftRel (LiftRel R) S T) →
          U s1 s2)
    {a} (ma : a ∈ destruct (join S)) : ∃ b, b ∈ destruct (join T) ∧ LiftRelO R U a b 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) {S : Stream'.WSeq (Stream'.WSeq α)} {T : Stream'.WSeq (Stream'.WSeq β)} {U : Stream'.WSeq α → Stream'.WSeq β → Prop} (ST : Stream'.WSeq.LiftRel (Stream'.WSeq.LiftRel R) S T) (HU :
  ∀ (s1 : Stream'.WSeq α) (s2 : Stream'.WSeq β),
    (∃ s t S T,
        s1 = s.append S.join ∧
          s2 = t.append T.join ∧ Stream'.WSeq.LiftRel R s t ∧ Stream'.WSeq.LiftRel (Stream'.WSeq.LiftRel R) S T) →
      U s1 s2) {a : Option (α × Stream'.WSeq α)} (ma : a ∈ S.join.destruct)
Goal: ∃ b, b ∈ T.join.destruct ∧ Stream'.WSeq.LiftRelO R U a b
-- Stream'.WSeq.liftRel_join
theorem liftRel_join (R : α → β → Prop) {S : WSeq (WSeq α)} {T : WSeq (WSeq β)}
    (h : LiftRel (LiftRel R) S T) : LiftRel R (join S) (join T) 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) {S : Stream'.WSeq (Stream'.WSeq α)} {T : Stream'.WSeq (Stream'.WSeq β)} (h : Stream'.WSeq.LiftRel (Stream'.WSeq.LiftRel R) S T)
Goal: Stream'.WSeq.LiftRel R S.join T.join
-- Stream'.WSeq.join_congr
theorem join_congr {S T : WSeq (WSeq α)} (h : LiftRel Equiv S T) : join S ~ʷ join T 
Arguments: {α : Type u} {S T : Stream'.WSeq (Stream'.WSeq α)} (h : Stream'.WSeq.LiftRel Stream'.WSeq.Equiv S T)
Goal: S.join ~ʷ T.join
-- Stream'.WSeq.liftRel_bind
theorem liftRel_bind {δ} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : WSeq α} {s2 : WSeq β}
    {f1 : α → WSeq γ} {f2 : β → WSeq δ} (h1 : LiftRel R s1 s2)
    (h2 : ∀ {a b}, R a b → LiftRel S (f1 a) (f2 b)) : LiftRel S (bind s1 f1) (bind s2 f2) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} (R : α → β → Prop) (S : γ → δ → Prop) {s1 : Stream'.WSeq α} {s2 : Stream'.WSeq β} {f1 : α → Stream'.WSeq γ} {f2 : β → Stream'.WSeq δ} (h1 : Stream'.WSeq.LiftRel R s1 s2) (h2 : ∀ {a : α} {b : β}, R a b → Stream'.WSeq.LiftRel S (f1 a) (f2 b))
Goal: Stream'.WSeq.LiftRel S (s1.bind f1) (s2.bind f2)
-- Stream'.WSeq.bind_congr
theorem bind_congr {s1 s2 : WSeq α} {f1 f2 : α → WSeq β} (h1 : s1 ~ʷ s2) (h2 : ∀ a, f1 a ~ʷ f2 a) :
    bind s1 f1 ~ʷ bind s2 f2 
Arguments: {α : Type u} {β : Type v} {s1 s2 : Stream'.WSeq α} {f1 f2 : α → Stream'.WSeq β} (h1 : s1 ~ʷ s2) (h2 : ∀ (a : α), f1 a ~ʷ f2 a)
Goal: s1.bind f1 ~ʷ s2.bind f2
-- Stream'.WSeq.join_ret
@[simp]
theorem join_ret (s : WSeq α) : join (ret s) ~ʷ s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: (Stream'.WSeq.ret s).join ~ʷ s
-- Stream'.WSeq.join_map_ret
@[simp]
theorem join_map_ret (s : WSeq α) : join (map ret s) ~ʷ s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: (Stream'.WSeq.map Stream'.WSeq.ret s).join ~ʷ s
-- Stream'.WSeq.join_append
@[simp]
theorem join_append (S T : WSeq (WSeq α)) : join (append S T) ~ʷ append (join S) (join T) 
Arguments: {α : Type u} (S T : Stream'.WSeq (Stream'.WSeq α))
Goal: (S.append T).join ~ʷ S.join.append T.join
-- Stream'.WSeq.bind_ret
@[simp]
theorem bind_ret (f : α → β) (s) : bind s (ret ∘ f) ~ʷ map f s 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream'.WSeq α)
Goal: s.bind (Stream'.WSeq.ret ∘ f) ~ʷ Stream'.WSeq.map f s
-- Stream'.WSeq.ret_bind
@[simp]
theorem ret_bind (a : α) (f : α → WSeq β) : bind (ret a) f ~ʷ f a 
Arguments: {α : Type u} {β : Type v} (a : α) (f : α → Stream'.WSeq β)
Goal: (Stream'.WSeq.ret a).bind f ~ʷ f a
-- Stream'.WSeq.map_join
@[simp]
theorem map_join (f : α → β) (S) : map f (join S) = join (map (map f) S) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (S : Stream'.WSeq (Stream'.WSeq α))
Goal: Stream'.WSeq.map f S.join = (Stream'.WSeq.map (Stream'.WSeq.map f) S).join
-- Stream'.WSeq.join_join
@[simp]
theorem join_join (SS : WSeq (WSeq (WSeq α))) : join (join SS) ~ʷ join (map join SS) 
Arguments: {α : Type u} (SS : Stream'.WSeq (Stream'.WSeq (Stream'.WSeq α)))
Goal: SS.join.join ~ʷ (Stream'.WSeq.map Stream'.WSeq.join SS).join
-- Stream'.WSeq.bind_assoc
@[simp]
theorem bind_assoc (s : WSeq α) (f : α → WSeq β) (g : β → WSeq γ) :
    bind (bind s f) g ~ʷ bind s fun x : α => bind (f x) g 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.WSeq α) (f : α → Stream'.WSeq β) (g : β → Stream'.WSeq γ)
Goal: (s.bind f).bind g ~ʷ s.bind fun x => (f x).bind g
-- Complex.coe_algebraMap
@[simp]
theorem coe_algebraMap : (algebraMap ℝ ℂ : ℝ → ℂ) = ((↑) : ℝ → ℂ) 
Goal: ⇑(algebraMap ℝ ℂ) = Complex.ofReal'
-- AlgHom.map_coe_real_complex
@[simp]
theorem _root_.AlgHom.map_coe_real_complex (f : ℂ →ₐ[ℝ] A) (x : ℝ) : f x = algebraMap ℝ A x 
Arguments: {A : Type u_3} [Semiring A] [Algebra ℝ A] (f : ℂ →ₐ[ℝ] A) (x : ℝ)
Goal: f ↑x = (algebraMap ℝ A) x
-- Complex.algHom_ext
@[ext]
theorem algHom_ext ⦃f g : ℂ →ₐ[ℝ] A⦄ (h : f I = g I) : f = g 
Arguments: {A : Type u_3} [Semiring A] [Algebra ℝ A] ⦃f g : ℂ →ₐ[ℝ] A⦄ (h : f Complex.I = g Complex.I)
Goal: f = g
-- Complex.coe_basisOneI_repr
@[simp]
theorem coe_basisOneI_repr (z : ℂ) : ⇑(basisOneI.repr z) = ![z.re, z.im] 
Arguments: (z : ℂ)
Goal: ⇑(Complex.basisOneI.repr z) = ![z.re, z.im]
-- Complex.coe_basisOneI
@[simp]
theorem coe_basisOneI : ⇑basisOneI = ![1, I] 
Goal: ⇑Complex.basisOneI = ![1, Complex.I]
-- Complex.coe_smul
@[simp, norm_cast]
theorem Complex.coe_smul {E : Type*} [AddCommGroup E] [Module ℂ E] (x : ℝ) (y : E) :
    (x : ℂ) • y = x • y 
Arguments: {E : Type u_1} [AddCommGroup E] [Module ℂ E] (x : ℝ) (y : E)
Goal: ↑x • y = x • y
-- Complex.reLm_coe
@[simp]
theorem reLm_coe : ⇑reLm = re 
Goal: ⇑Complex.reLm = Complex.re
-- Complex.imLm_coe
@[simp]
theorem imLm_coe : ⇑imLm = im 
Goal: ⇑Complex.imLm = Complex.im
-- Complex.ofRealAm_coe
@[simp]
theorem ofRealAm_coe : ⇑ofRealAm = ((↑) : ℝ → ℂ) 
Goal: ⇑Complex.ofRealAm = Complex.ofReal'
-- Complex.conjAe_coe
@[simp]
theorem conjAe_coe : ⇑conjAe = conj 
Goal: ⇑Complex.conjAe = ⇑(starRingEnd ℂ)
-- Complex.toMatrix_conjAe
@[simp]
theorem toMatrix_conjAe :
    LinearMap.toMatrix basisOneI basisOneI conjAe.toLinearMap = !![1, 0; 0, -1] 
Goal: (LinearMap.toMatrix Complex.basisOneI Complex.basisOneI) Complex.conjAe.toLinearMap = !![1, 0; 0, -1]
-- Complex.real_algHom_eq_id_or_conj
theorem real_algHom_eq_id_or_conj (f : ℂ →ₐ[ℝ] ℂ) : f = AlgHom.id ℝ ℂ ∨ f = conjAe 
Arguments: (f : ℂ →ₐ[ℝ] ℂ)
Goal: f = AlgHom.id ℝ ℂ ∨ f = ↑Complex.conjAe
-- Complex.equivRealProdLm_symm_apply_im
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdLm : ℂ ≃ₗ[ℝ] ℝ × ℝ 
Goal: ∀ (a : ℝ × ℝ), (Complex.equivRealProdLm.symm a).im = a.2
-- Complex.equivRealProdLm_symm_apply_re
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdLm : ℂ ≃ₗ[ℝ] ℝ × ℝ 
Goal: ∀ (a : ℝ × ℝ), (Complex.equivRealProdLm.symm a).re = a.1
-- Complex.equivRealProdLm_apply
@[simps! (config := { simpRhs := true }) apply symm_apply_re symm_apply_im]
def equivRealProdLm : ℂ ≃ₗ[ℝ] ℝ × ℝ 
Goal: ∀ (a : ℂ), Complex.equivRealProdLm a = (a.re, a.im)
-- Complex.equivRealProdLm_symm_apply
theorem equivRealProdLm_symm_apply (p : ℝ × ℝ) :
    Complex.equivRealProdLm.symm p = p.1 + p.2 * Complex.I 
Arguments: (p : ℝ × ℝ)
Goal: Complex.equivRealProdLm.symm p = ↑p.1 + ↑p.2 * Complex.I
-- Complex.liftAux_apply
@[simp]
theorem liftAux_apply (I' : A) (hI') (z : ℂ) : liftAux I' hI' z = algebraMap ℝ A z.re + z.im • I' 
Arguments: {A : Type u_1} [Ring A] [Algebra ℝ A] (I' : A) (hI' : I' * I' = -1) (z : ℂ)
Goal: (Complex.liftAux I' hI') z = (algebraMap ℝ A) z.re + z.im • I'
-- Complex.liftAux_apply_I
theorem liftAux_apply_I (I' : A) (hI') : liftAux I' hI' I = I' 
Arguments: {A : Type u_1} [Ring A] [Algebra ℝ A] (I' : A) (hI' : I' * I' = -1)
Goal: (Complex.liftAux I' hI') Complex.I = I'
-- Complex.lift_symm_apply_coe
@[simps (config := { simpRhs := true })]
def lift : { I' : A // I' * I' = -1 } ≃ (ℂ →ₐ[ℝ] A) 
Arguments: {A : Type u_1} [Ring A] [Algebra ℝ A] (F : ℂ →ₐ[ℝ] A)
Goal: ↑(Complex.lift.symm F) = F Complex.I
-- Complex.lift_apply
@[simps (config := { simpRhs := true })]
def lift : { I' : A // I' * I' = -1 } ≃ (ℂ →ₐ[ℝ] A) 
Arguments: {A : Type u_1} [Ring A] [Algebra ℝ A] (I' : { I' // I' * I' = -1 })
Goal: Complex.lift I' = Complex.liftAux ↑I' ⋯
-- Complex.liftAux_I
@[simp]
theorem liftAux_I : liftAux I I_mul_I = AlgHom.id ℝ ℂ 
Goal: Complex.liftAux Complex.I Complex.I_mul_I = AlgHom.id ℝ ℂ
-- Complex.liftAux_neg_I
@[simp]
theorem liftAux_neg_I : liftAux (-I) ((neg_mul_neg _ _).trans I_mul_I) = conjAe 
Goal: Complex.liftAux (-Complex.I) ⋯ = ↑Complex.conjAe
-- skewAdjoint.negISMul_apply_coe
@[simps]
def skewAdjoint.negISMul : skewAdjoint A →ₗ[ℝ] selfAdjoint A 
Arguments: {A : Type u_1} [AddCommGroup A] [Module ℂ A] [StarAddMonoid A] [StarModule ℂ A] (a : ↥(skewAdjoint A))
Goal: ↑(skewAdjoint.negISMul a) = -Complex.I • ↑a