ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Stream'.Seq.get?_cons_succ
@[simp]
theorem get?_cons_succ (a : α) (s : Seq α) (n : ℕ) : (cons a s).get? (n + 1) = s.get? n 
Arguments: {α : Type u} (a : α) (s : Stream'.Seq α) (n : ℕ)
Goal: (Stream'.Seq.cons a s).get? (n + 1) = s.get? n
-- Stream'.Seq.ext
@[ext]
protected theorem ext {s t : Seq α} (h : ∀ n : ℕ, s.get? n = t.get? n) : s = t 
Arguments: {α : Type u} {s t : Stream'.Seq α} (h : ∀ (n : ℕ), s.get? n = t.get? n)
Goal: s = t
-- Stream'.Seq.cons_injective2
theorem cons_injective2 : Function.Injective2 (cons : α → Seq α → Seq α) 
Arguments: {α : Type u}
Goal: Function.Injective2 Stream'.Seq.cons
-- Stream'.Seq.cons_left_injective
theorem cons_left_injective (s : Seq α) : Function.Injective fun x => cons x s 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: Function.Injective fun x => Stream'.Seq.cons x s
-- Stream'.Seq.cons_right_injective
theorem cons_right_injective (x : α) : Function.Injective (cons x) 
Arguments: {α : Type u} (x : α)
Goal: Function.Injective (Stream'.Seq.cons x)
-- Stream'.Seq.not_terminates_iff
theorem not_terminates_iff {s : Seq α} : ¬s.Terminates ↔ ∀ n, (s.get? n).isSome 
Arguments: {α : Type u} {s : Stream'.Seq α}
Goal: ¬s.Terminates ↔ ∀ (n : ℕ), (s.get? n).isSome = true
-- Stream'.Seq.le_stable
theorem le_stable (s : Seq α) {m n} (h : m ≤ n) : s.get? m = none → s.get? n = none 
Arguments: {α : Type u} (s : Stream'.Seq α) {m n : ℕ} (h : m ≤ n)
Goal: s.get? m = none → s.get? n = none
-- Stream'.Seq.terminated_stable
theorem terminated_stable : ∀ (s : Seq α) {m n : ℕ}, m ≤ n → s.TerminatedAt m → s.TerminatedAt n 
Arguments: {α : Type u} (s : Stream'.Seq α) {m n : ℕ}
Goal: m ≤ n → s.TerminatedAt m → s.TerminatedAt n
-- Stream'.Seq.ge_stable
theorem ge_stable (s : Seq α) {aₙ : α} {n m : ℕ} (m_le_n : m ≤ n)
    (s_nth_eq_some : s.get? n = some aₙ) : ∃ aₘ : α, s.get? m = some aₘ 
Arguments: {α : Type u} (s : Stream'.Seq α) {aₙ : α} {n m : ℕ} (m_le_n : m ≤ n) (s_nth_eq_some : s.get? n = some aₙ)
Goal: ∃ aₘ, s.get? m = some aₘ
-- Stream'.Seq.not_mem_nil
theorem not_mem_nil (a : α) : a ∉ @nil α 
Arguments: {α : Type u} (a : α)
Goal: ¬a ∈ Stream'.Seq.nil
-- Stream'.Seq.mem_cons
theorem mem_cons (a : α) : ∀ s : Seq α, a ∈ cons a s
  
Arguments: {α : Type u} (a : α) (s : Stream'.Seq α)
Goal: a ∈ Stream'.Seq.cons a s
-- Stream'.Seq.mem_cons_of_mem
theorem mem_cons_of_mem (y : α) {a : α} : ∀ {s : Seq α}, a ∈ s → a ∈ cons y s
  
Arguments: {α : Type u} (y : α) {a : α} {s : Stream'.Seq α}
Goal: a ∈ s → a ∈ Stream'.Seq.cons y s
-- Stream'.Seq.eq_or_mem_of_mem_cons
theorem eq_or_mem_of_mem_cons {a b : α} : ∀ {s : Seq α}, a ∈ cons b s → a = b ∨ a ∈ s
  
Arguments: {α : Type u} {a b : α} {s : Stream'.Seq α}
Goal: a ∈ Stream'.Seq.cons b s → a = b ∨ a ∈ s
-- Stream'.Seq.mem_cons_iff
@[simp]
theorem mem_cons_iff {a b : α} {s : Seq α} : a ∈ cons b s ↔ a = b ∨ a ∈ s 
Arguments: {α : Type u} {a b : α} {s : Stream'.Seq α}
Goal: a ∈ Stream'.Seq.cons b s ↔ a = b ∨ a ∈ s
-- Stream'.Seq.destruct_eq_nil
theorem destruct_eq_nil {s : Seq α} : destruct s = none → s = nil 
Arguments: {α : Type u} {s : Stream'.Seq α}
Goal: s.destruct = none → s = Stream'.Seq.nil
-- Stream'.Seq.destruct_eq_cons
theorem destruct_eq_cons {s : Seq α} {a s'} : destruct s = some (a, s') → s = cons a s' 
Arguments: {α : Type u} {s : Stream'.Seq α} {a : α} {s' : Stream'.Seq α}
Goal: s.destruct = some (a, s') → s = Stream'.Seq.cons a s'
-- Stream'.Seq.destruct_nil
@[simp]
theorem destruct_nil : destruct (nil : Seq α) = none 
Arguments: {α : Type u}
Goal: Stream'.Seq.nil.destruct = none
-- Stream'.Seq.destruct_cons
@[simp]
theorem destruct_cons (a : α) : ∀ s, destruct (cons a s) = some (a, s)
  
Arguments: {α : Type u} (a : α) (s : Stream'.Seq α)
Goal: (Stream'.Seq.cons a s).destruct = some (a, s)
-- Stream'.Seq.head_eq_destruct
theorem head_eq_destruct (s : Seq α) : head.{u} s = Prod.fst.{u} <$> destruct.{u} s 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: s.head = Prod.fst <$> s.destruct
-- Stream'.Seq.head_nil
@[simp]
theorem head_nil : head (nil : Seq α) = none 
Arguments: {α : Type u}
Goal: Stream'.Seq.nil.head = none
-- Stream'.Seq.head_cons
@[simp]
theorem head_cons (a : α) (s) : head (cons a s) = some a 
Arguments: {α : Type u} (a : α) (s : Stream'.Seq α)
Goal: (Stream'.Seq.cons a s).head = some a
-- Stream'.Seq.tail_nil
@[simp]
theorem tail_nil : tail (nil : Seq α) = nil 
Arguments: {α : Type u}
Goal: Stream'.Seq.nil.tail = Stream'.Seq.nil
-- Stream'.Seq.tail_cons
@[simp]
theorem tail_cons (a : α) (s) : tail (cons a s) = s 
Arguments: {α : Type u} (a : α) (s : Stream'.Seq α)
Goal: (Stream'.Seq.cons a s).tail = s
-- Stream'.Seq.get?_tail
@[simp]
theorem get?_tail (s : Seq α) (n) : get? (tail s) n = get? s (n + 1) 
Arguments: {α : Type u} (s : Stream'.Seq α) (n : ℕ)
Goal: s.tail.get? n = s.get? (n + 1)
-- Stream'.Seq.mem_rec_on
theorem mem_rec_on {C : Seq α → Prop} {a s} (M : a ∈ s)
    (h1 : ∀ b s', a = b ∨ C s' → C (cons b s')) : C s 
Arguments: {α : Type u} {C : Stream'.Seq α → Prop} {a : α} {s : Stream'.Seq α} (M : a ∈ s) (h1 : ∀ (b : α) (s' : Stream'.Seq α), a = b ∨ C s' → C (Stream'.Seq.cons b s'))
Goal: C s
-- Stream'.Seq.corec_eq
@[simp]
theorem corec_eq (f : β → Option (α × β)) (b : β) :
    destruct (corec f b) = omap (corec f) (f b) 
Arguments: {α : Type u} {β : Type v} (f : β → Option (α × β)) (b : β)
Goal: (Stream'.Seq.corec f b).destruct = Stream'.Seq.omap (Stream'.Seq.corec f) (f b)
-- Stream'.Seq.eq_of_bisim
theorem eq_of_bisim (bisim : IsBisimulation R) {s₁ s₂} (r : s₁ ~ s₂) : s₁ = s₂ 
Arguments: {α : Type u} (R : Stream'.Seq α → Stream'.Seq α → Prop) (bisim : Stream'.Seq.IsBisimulation R) {s₁ s₂ : Stream'.Seq α} (r : R s₁ s₂)
Goal: s₁ = s₂
-- Stream'.Seq.coinduction
theorem coinduction :
    ∀ {s₁ s₂ : Seq α},
      head s₁ = head s₂ →
        (∀ (β : Type u) (fr : Seq α → β), fr s₁ = fr s₂ → fr (tail s₁) = fr (tail s₂)) → s₁ = s₂
  
Arguments: {α : Type u} {s₁ s₂ : Stream'.Seq α}
Goal: s₁.head = s₂.head → (∀ (β : Type u) (fr : Stream'.Seq α → β), fr s₁ = fr s₂ → fr s₁.tail = fr s₂.tail) → s₁ = s₂
-- Stream'.Seq.coinduction2
theorem coinduction2 (s) (f g : Seq α → Seq β)
    (H :
      ∀ s,
        BisimO (fun s1 s2 : Seq β => ∃ s : Seq α, s1 = f s ∧ s2 = g s) (destruct (f s))
          (destruct (g s))) :
    f s = g s 
Arguments: {α : Type u} {β : Type v} (s : Stream'.Seq α) (f g : Stream'.Seq α → Stream'.Seq β) (H : ∀ (s : Stream'.Seq α), Stream'.Seq.BisimO (fun s1 s2 => ∃ s, s1 = f s ∧ s2 = g s) (f s).destruct (g s).destruct)
Goal: f s = g s
-- Stream'.Seq.ofList_nil
@[simp]
theorem ofList_nil : ofList [] = (nil : Seq α) 
Arguments: {α : Type u}
Goal: ↑[] = Stream'.Seq.nil
-- Stream'.Seq.ofList_get
@[simp]
theorem ofList_get (l : List α) (n : ℕ) : (ofList l).get? n = l.get? n 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: (↑l).get? n = l.get? n
-- Stream'.Seq.ofList_cons
@[simp]
theorem ofList_cons (a : α) (l : List α) : ofList (a::l) = cons a (ofList l) 
Arguments: {α : Type u} (a : α) (l : List α)
Goal: ↑(a :: l) = Stream'.Seq.cons a ↑l
-- Stream'.Seq.nats_get?
@[simp]
theorem nats_get? (n : ℕ) : nats.get? n = some n 
Arguments: (n : ℕ)
Goal: Stream'.Seq.nats.get? n = some n
-- Stream'.Seq.get?_zipWith
@[simp]
theorem get?_zipWith (f : α → β → γ) (s s' n) :
    (zipWith f s s').get? n = Option.map₂ f (s.get? n) (s'.get? n) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β → γ) (s : Stream'.Seq α) (s' : Stream'.Seq β) (n : ℕ)
Goal: (Stream'.Seq.zipWith f s s').get? n = Option.map₂ f (s.get? n) (s'.get? n)
-- Stream'.Seq.get?_zip
theorem get?_zip (s : Seq α) (t : Seq β) (n : ℕ) :
    get? (zip s t) n = Option.map₂ Prod.mk (get? s n) (get? t n) 
Arguments: {α : Type u} {β : Type v} (s : Stream'.Seq α) (t : Stream'.Seq β) (n : ℕ)
Goal: (s.zip t).get? n = Option.map₂ Prod.mk (s.get? n) (t.get? n)
-- Stream'.Seq.get?_enum
@[simp]
theorem get?_enum (s : Seq α) (n : ℕ) : get? (enum s) n = Option.map (Prod.mk n) (get? s n) 
Arguments: {α : Type u} (s : Stream'.Seq α) (n : ℕ)
Goal: s.enum.get? n = Option.map (Prod.mk n) (s.get? n)
-- Stream'.Seq.enum_nil
@[simp]
theorem enum_nil : enum (nil : Seq α) = nil 
Arguments: {α : Type u}
Goal: Stream'.Seq.nil.enum = Stream'.Seq.nil
-- Stream'.Seq.nil_append
@[simp]
theorem nil_append (s : Seq α) : append nil s = s 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: Stream'.Seq.nil.append s = s
-- Stream'.Seq.cons_append
@[simp]
theorem cons_append (a : α) (s t) : append (cons a s) t = cons a (append s t) 
Arguments: {α : Type u} (a : α) (s t : Stream'.Seq α)
Goal: (Stream'.Seq.cons a s).append t = Stream'.Seq.cons a (s.append t)
-- Stream'.Seq.append_nil
@[simp]
theorem append_nil (s : Seq α) : append s nil = s 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: s.append Stream'.Seq.nil = s
-- Stream'.Seq.append_assoc
@[simp]
theorem append_assoc (s t u : Seq α) : append (append s t) u = append s (append t u) 
Arguments: {α : Type u} (s t u : Stream'.Seq α)
Goal: (s.append t).append u = s.append (t.append u)
-- Stream'.Seq.map_nil
@[simp]
theorem map_nil (f : α → β) : map f nil = nil 
Arguments: {α : Type u} {β : Type v} (f : α → β)
Goal: Stream'.Seq.map f Stream'.Seq.nil = Stream'.Seq.nil
-- Stream'.Seq.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'.Seq α)
Goal: Stream'.Seq.map f (Stream'.Seq.cons a s) = Stream'.Seq.cons (f a) (Stream'.Seq.map f s)
-- Stream'.Seq.map_id
@[simp]
theorem map_id : ∀ s : Seq α, map id s = s
  
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: Stream'.Seq.map id s = s
-- Stream'.Seq.map_tail
@[simp]
theorem map_tail (f : α → β) : ∀ s, map f (tail s) = tail (map f s)
  
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream'.Seq α)
Goal: Stream'.Seq.map f s.tail = (Stream'.Seq.map f s).tail
-- Stream'.Seq.map_comp
theorem map_comp (f : α → β) (g : β → γ) : ∀ s : Seq α, map (g ∘ f) s = map g (map f s)
  
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (s : Stream'.Seq α)
Goal: Stream'.Seq.map (g ∘ f) s = Stream'.Seq.map g (Stream'.Seq.map f s)
-- Stream'.Seq.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'.Seq α)
Goal: Stream'.Seq.map f (s.append t) = (Stream'.Seq.map f s).append (Stream'.Seq.map f t)
-- Stream'.Seq.map_get?
@[simp]
theorem map_get? (f : α → β) : ∀ s n, get? (map f s) n = (get? s n).map f
  
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream'.Seq α) (n : ℕ)
Goal: (Stream'.Seq.map f s).get? n = Option.map f (s.get? n)
-- Stream'.Seq.join_nil
@[simp]
theorem join_nil : join nil = (nil : Seq α) 
Arguments: {α : Type u}
Goal: Stream'.Seq.nil.join = Stream'.Seq.nil
-- Stream'.Seq.join_cons_nil
theorem join_cons_nil (a : α) (S) : join (cons (a, nil) S) = cons a (join S) 
Arguments: {α : Type u} (a : α) (S : Stream'.Seq (Stream'.Seq1 α))
Goal: (Stream'.Seq.cons (a, Stream'.Seq.nil) S).join = Stream'.Seq.cons a S.join
-- Stream'.Seq.join_cons_cons
theorem join_cons_cons (a b : α) (s S) :
    join (cons (a, cons b s) S) = cons a (join (cons (b, s) S)) 
Arguments: {α : Type u} (a b : α) (s : Stream'.Seq α) (S : Stream'.Seq (Stream'.Seq1 α))
Goal: (Stream'.Seq.cons (a, Stream'.Seq.cons b s) S).join = Stream'.Seq.cons a (Stream'.Seq.cons (b, s) S).join
-- Stream'.Seq.join_cons
@[simp]
theorem join_cons (a : α) (s S) : join (cons (a, s) S) = cons a (append s (join S)) 
Arguments: {α : Type u} (a : α) (s : Stream'.Seq α) (S : Stream'.Seq (Stream'.Seq1 α))
Goal: (Stream'.Seq.cons (a, s) S).join = Stream'.Seq.cons a (s.append S.join)
-- Stream'.Seq.join_append
@[simp]
theorem join_append (S T : Seq (Seq1 α)) : join (append S T) = append (join S) (join T) 
Arguments: {α : Type u} (S T : Stream'.Seq (Stream'.Seq1 α))
Goal: (S.append T).join = S.join.append T.join
-- Stream'.Seq.ofStream_cons
@[simp]
theorem ofStream_cons (a : α) (s) : ofStream (a::s) = cons a (ofStream s) 
Arguments: {α : Type u} (a : α) (s : Stream' α)
Goal: ↑(Stream'.cons a s) = Stream'.Seq.cons a ↑s
-- Stream'.Seq.ofList_append
@[simp]
theorem ofList_append (l l' : List α) : ofList (l ++ l') = append (ofList l) (ofList l') 
Arguments: {α : Type u} (l l' : List α)
Goal: ↑(l ++ l') = (↑l).append ↑l'
-- Stream'.Seq.ofStream_append
@[simp]
theorem ofStream_append (l : List α) (s : Stream' α) :
    ofStream (l ++ₛ s) = append (ofList l) (ofStream s) 
Arguments: {α : Type u} (l : List α) (s : Stream' α)
Goal: ↑(l ++ₛ s) = (↑l).append ↑s
-- Stream'.Seq.dropn_add
theorem dropn_add (s : Seq α) (m) : ∀ n, drop s (m + n) = drop (drop s m) n
  
Arguments: {α : Type u} (s : Stream'.Seq α) (m n : ℕ)
Goal: s.drop (m + n) = (s.drop m).drop n
-- Stream'.Seq.dropn_tail
theorem dropn_tail (s : Seq α) (n) : drop (tail s) n = drop s (n + 1) 
Arguments: {α : Type u} (s : Stream'.Seq α) (n : ℕ)
Goal: s.tail.drop n = s.drop (n + 1)
-- Stream'.Seq.head_dropn
@[simp]
theorem head_dropn (s : Seq α) (n) : head (drop s n) = get? s n 
Arguments: {α : Type u} (s : Stream'.Seq α) (n : ℕ)
Goal: (s.drop n).head = s.get? n
-- Stream'.Seq.mem_map
theorem mem_map (f : α → β) {a : α} : ∀ {s : Seq α}, a ∈ s → f a ∈ map f s
  
Arguments: {α : Type u} {β : Type v} (f : α → β) {a : α} {s : Stream'.Seq α}
Goal: a ∈ s → f a ∈ Stream'.Seq.map f s
-- Stream'.Seq.exists_of_mem_map
theorem exists_of_mem_map {f} {b : β} : ∀ {s : Seq α}, b ∈ map f s → ∃ a, a ∈ s ∧ f a = b 
Arguments: {α : Type u} {β : Type v} {f : α → β} {b : β} {s : Stream'.Seq α}
Goal: b ∈ Stream'.Seq.map f s → ∃ a, a ∈ s ∧ f a = b
-- Stream'.Seq.of_mem_append
theorem of_mem_append {s₁ s₂ : Seq α} {a : α} (h : a ∈ append s₁ s₂) : a ∈ s₁ ∨ a ∈ s₂ 
Arguments: {α : Type u} {s₁ s₂ : Stream'.Seq α} {a : α} (h : a ∈ s₁.append s₂)
Goal: a ∈ s₁ ∨ a ∈ s₂
-- Stream'.Seq.mem_append_left
theorem mem_append_left {s₁ s₂ : Seq α} {a : α} (h : a ∈ s₁) : a ∈ append s₁ s₂ 
Arguments: {α : Type u} {s₁ s₂ : Stream'.Seq α} {a : α} (h : a ∈ s₁)
Goal: a ∈ s₁.append s₂
-- Stream'.Seq.enum_cons
@[simp]
theorem enum_cons (s : Seq α) (x : α) :
    enum (cons x s) = cons (0, x) (map (Prod.map Nat.succ id) (enum s)) 
Arguments: {α : Type u} (s : Stream'.Seq α) (x : α)
Goal: (Stream'.Seq.cons x s).enum = Stream'.Seq.cons (0, x) (Stream'.Seq.map (Prod.map Nat.succ id) s.enum)
-- Stream'.Seq1.map_pair
theorem map_pair {f : α → β} {a s} : map f (a, s) = (f a, Seq.map f s) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {a : α} {s : Stream'.Seq α}
Goal: Stream'.Seq1.map f (a, s) = (f a, Stream'.Seq.map f s)
-- Stream'.Seq1.map_id
theorem map_id : ∀ s : Seq1 α, map id s = s
  
Arguments: {α : Type u} (s : Stream'.Seq1 α)
Goal: Stream'.Seq1.map id s = s
-- Stream'.Seq1.join_nil
@[simp]
theorem join_nil (a : α) (S) : join ((a, nil), S) = (a, Seq.join S) 
Arguments: {α : Type u} (a : α) (S : Stream'.Seq (Stream'.Seq1 α))
Goal: Stream'.Seq1.join ((a, Stream'.Seq.nil), S) = (a, S.join)
-- Stream'.Seq1.join_cons
@[simp]
theorem join_cons (a b : α) (s S) :
    join ((a, Seq.cons b s), S) = (a, Seq.join (Seq.cons (b, s) S)) 
Arguments: {α : Type u} (a b : α) (s : Stream'.Seq α) (S : Stream'.Seq (Stream'.Seq1 α))
Goal: Stream'.Seq1.join ((a, Stream'.Seq.cons b s), S) = (a, (Stream'.Seq.cons (b, s) S).join)
-- Stream'.Seq1.join_map_ret
@[simp]
theorem join_map_ret (s : Seq α) : Seq.join (Seq.map ret s) = s 
Arguments: {α : Type u} (s : Stream'.Seq α)
Goal: (Stream'.Seq.map Stream'.Seq1.ret s).join = s
-- Stream'.Seq1.bind_ret
@[simp]
theorem bind_ret (f : α → β) : ∀ s, bind s (ret ∘ f) = map f s
  
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream'.Seq1 α)
Goal: s.bind (Stream'.Seq1.ret ∘ f) = Stream'.Seq1.map f s
-- Stream'.Seq1.ret_bind
@[simp]
theorem ret_bind (a : α) (f : α → Seq1 β) : bind (ret a) f = f a 
Arguments: {α : Type u} {β : Type v} (a : α) (f : α → Stream'.Seq1 β)
Goal: (Stream'.Seq1.ret a).bind f = f a
-- Stream'.Seq1.map_join'
@[simp]
theorem map_join' (f : α → β) (S) : Seq.map f (Seq.join S) = Seq.join (Seq.map (map f) S) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (S : Stream'.Seq (Stream'.Seq1 α))
Goal: Stream'.Seq.map f S.join = (Stream'.Seq.map (Stream'.Seq1.map f) S).join
-- Stream'.Seq1.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'.Seq1 (Stream'.Seq1 α))
Goal: Stream'.Seq1.map f S.join = (Stream'.Seq1.map (Stream'.Seq1.map f) S).join
-- Stream'.Seq1.join_join
@[simp]
theorem join_join (SS : Seq (Seq1 (Seq1 α))) :
    Seq.join (Seq.join SS) = Seq.join (Seq.map join SS) 
Arguments: {α : Type u} (SS : Stream'.Seq (Stream'.Seq1 (Stream'.Seq1 α)))
Goal: SS.join.join = (Stream'.Seq.map Stream'.Seq1.join SS).join
-- Stream'.Seq1.bind_assoc
@[simp]
theorem bind_assoc (s : Seq1 α) (f : α → Seq1 β) (g : β → Seq1 γ) :
    bind (bind s f) g = bind s fun x : α => bind (f x) g 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.Seq1 α) (f : α → Stream'.Seq1 β) (g : β → Stream'.Seq1 γ)
Goal: (s.bind f).bind g = s.bind fun x => (f x).bind g
-- Finsupp.toMultiset_zero
theorem toMultiset_zero : toMultiset (0 : α →₀ ℕ) = 0 
Arguments: {α : Type u_1}
Goal: Finsupp.toMultiset 0 = 0
-- Finsupp.toMultiset_add
theorem toMultiset_add (m n : α →₀ ℕ) : toMultiset (m + n) = toMultiset m + toMultiset n 
Arguments: {α : Type u_1} (m n : α →₀ ℕ)
Goal: Finsupp.toMultiset (m + n) = Finsupp.toMultiset m + Finsupp.toMultiset n
-- Finsupp.toMultiset_apply
theorem toMultiset_apply (f : α →₀ ℕ) : toMultiset f = f.sum fun a n => n • {a} 
Arguments: {α : Type u_1} (f : α →₀ ℕ)
Goal: Finsupp.toMultiset f = f.sum fun a n => n • {a}
-- Finsupp.toMultiset_single
@[simp]
theorem toMultiset_single (a : α) (n : ℕ) : toMultiset (single a n) = n • {a} 
Arguments: {α : Type u_1} (a : α) (n : ℕ)
Goal: Finsupp.toMultiset (Finsupp.single a n) = n • {a}
-- Finsupp.toMultiset_sum
theorem toMultiset_sum {f : ι → α →₀ ℕ} (s : Finset ι) :
    Finsupp.toMultiset (∑ i ∈ s, f i) = ∑ i ∈ s, Finsupp.toMultiset (f i) 
Arguments: {α : Type u_1} {ι : Type u_3} {f : ι → α →₀ ℕ} (s : Finset ι)
Goal: Finsupp.toMultiset (∑ i ∈ s, f i) = ∑ i ∈ s, Finsupp.toMultiset (f i)
-- Finsupp.toMultiset_sum_single
theorem toMultiset_sum_single (s : Finset ι) (n : ℕ) :
    Finsupp.toMultiset (∑ i ∈ s, single i n) = n • s.val 
Arguments: {ι : Type u_3} (s : Finset ι) (n : ℕ)
Goal: Finsupp.toMultiset (∑ i ∈ s, Finsupp.single i n) = n • s.val
-- Finsupp.card_toMultiset
@[simp]
theorem card_toMultiset (f : α →₀ ℕ) : Multiset.card (toMultiset f) = f.sum fun _ => id 
Arguments: {α : Type u_1} (f : α →₀ ℕ)
Goal: Multiset.card (Finsupp.toMultiset f) = f.sum fun x => id
-- Finsupp.toMultiset_map
theorem toMultiset_map (f : α →₀ ℕ) (g : α → β) :
    f.toMultiset.map g = toMultiset (f.mapDomain g) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α →₀ ℕ) (g : α → β)
Goal: Multiset.map g (Finsupp.toMultiset f) = Finsupp.toMultiset (Finsupp.mapDomain g f)
-- Finsupp.sum_toMultiset
@[to_additive (attr := simp)]
theorem prod_toMultiset [CommMonoid α] (f : α →₀ ℕ) :
    f.toMultiset.prod = f.prod fun a n => a ^ n 
Arguments: {α : Type u_1} [AddCommMonoid α] (f : α →₀ ℕ)
Goal: (Finsupp.toMultiset f).sum = f.sum fun a n => n • a
-- Finsupp.prod_toMultiset
@[to_additive (attr := simp)]
theorem prod_toMultiset [CommMonoid α] (f : α →₀ ℕ) :
    f.toMultiset.prod = f.prod fun a n => a ^ n 
Arguments: {α : Type u_1} [CommMonoid α] (f : α →₀ ℕ)
Goal: (Finsupp.toMultiset f).prod = f.prod fun a n => a ^ n
-- Finsupp.toFinset_toMultiset
@[simp]
theorem toFinset_toMultiset [DecidableEq α] (f : α →₀ ℕ) : f.toMultiset.toFinset = f.support 
Arguments: {α : Type u_1} [DecidableEq α] (f : α →₀ ℕ)
Goal: (Finsupp.toMultiset f).toFinset = f.support
-- Finsupp.count_toMultiset
@[simp]
theorem count_toMultiset [DecidableEq α] (f : α →₀ ℕ) (a : α) : (toMultiset f).count a = f a 
Arguments: {α : Type u_1} [DecidableEq α] (f : α →₀ ℕ) (a : α)
Goal: Multiset.count a (Finsupp.toMultiset f) = f a
-- Finsupp.toMultiset_sup
theorem toMultiset_sup [DecidableEq α] (f g : α →₀ ℕ) :
    toMultiset (f ⊔ g) = toMultiset f ∪ toMultiset g 
Arguments: {α : Type u_1} [DecidableEq α] (f g : α →₀ ℕ)
Goal: Finsupp.toMultiset (f ⊔ g) = Finsupp.toMultiset f ∪ Finsupp.toMultiset g
-- Finsupp.toMultiset_inf
theorem toMultiset_inf [DecidableEq α] (f g : α →₀ ℕ) :
    toMultiset (f ⊓ g) = toMultiset f ∩ toMultiset g 
Arguments: {α : Type u_1} [DecidableEq α] (f g : α →₀ ℕ)
Goal: Finsupp.toMultiset (f ⊓ g) = Finsupp.toMultiset f ∩ Finsupp.toMultiset g
-- Finsupp.mem_toMultiset
@[simp]
theorem mem_toMultiset (f : α →₀ ℕ) (i : α) : i ∈ toMultiset f ↔ i ∈ f.support 
Arguments: {α : Type u_1} (f : α →₀ ℕ) (i : α)
Goal: i ∈ Finsupp.toMultiset f ↔ i ∈ f.support
-- Multiset.toFinsupp_symm_apply
@[simps symm_apply]
def toFinsupp : Multiset α ≃+ (α →₀ ℕ) 
Arguments: {α : Type u_1} [DecidableEq α] (f : α →₀ ℕ)
Goal: Multiset.toFinsupp.symm f = Finsupp.toMultiset f
-- Multiset.toFinsupp_support
@[simp]
theorem toFinsupp_support (s : Multiset α) : s.toFinsupp.support = s.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: (Multiset.toFinsupp s).support = s.toFinset
-- Multiset.toFinsupp_apply
@[simp]
theorem toFinsupp_apply (s : Multiset α) (a : α) : toFinsupp s a = s.count a 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (a : α)
Goal: (Multiset.toFinsupp s) a = Multiset.count a s
-- Multiset.toFinsupp_zero
theorem toFinsupp_zero : toFinsupp (0 : Multiset α) = 0 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Multiset.toFinsupp 0 = 0
-- Multiset.toFinsupp_add
theorem toFinsupp_add (s t : Multiset α) : toFinsupp (s + t) = toFinsupp s + toFinsupp t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: Multiset.toFinsupp (s + t) = Multiset.toFinsupp s + Multiset.toFinsupp t
-- Multiset.toFinsupp_singleton
@[simp]
theorem toFinsupp_singleton (a : α) : toFinsupp ({a} : Multiset α) = Finsupp.single a 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: Multiset.toFinsupp {a} = Finsupp.single a 1
-- Multiset.toFinsupp_toMultiset
@[simp]
theorem toFinsupp_toMultiset (s : Multiset α) : Finsupp.toMultiset (toFinsupp s) = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: Finsupp.toMultiset (Multiset.toFinsupp s) = s
-- Multiset.toFinsupp_eq_iff
theorem toFinsupp_eq_iff {s : Multiset α} {f : α →₀ ℕ} :
    toFinsupp s = f ↔ s = Finsupp.toMultiset f 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} {f : α →₀ ℕ}
Goal: Multiset.toFinsupp s = f ↔ s = Finsupp.toMultiset f
-- Multiset.toFinsupp_union
theorem toFinsupp_union (s t : Multiset α) : toFinsupp (s ∪ t) = toFinsupp s ⊔ toFinsupp t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: Multiset.toFinsupp (s ∪ t) = Multiset.toFinsupp s ⊔ Multiset.toFinsupp t
-- Multiset.toFinsupp_inter
theorem toFinsupp_inter (s t : Multiset α) : toFinsupp (s ∩ t) = toFinsupp s ⊓ toFinsupp t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: Multiset.toFinsupp (s ∩ t) = Multiset.toFinsupp s ⊓ Multiset.toFinsupp t
-- Multiset.toFinsupp_sum_eq
@[simp]
theorem toFinsupp_sum_eq (s : Multiset α) : s.toFinsupp.sum (fun _ ↦ id) = Multiset.card s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: ((Multiset.toFinsupp s).sum fun x => id) = Multiset.card s
-- Finsupp.toMultiset_toFinsupp
@[simp]
theorem Finsupp.toMultiset_toFinsupp [DecidableEq α] (f : α →₀ ℕ) :
    Multiset.toFinsupp (Finsupp.toMultiset f) = f 
Arguments: {α : Type u_1} [DecidableEq α] (f : α →₀ ℕ)
Goal: Multiset.toFinsupp (Finsupp.toMultiset f) = f
-- Finsupp.toMultiset_eq_iff
theorem Finsupp.toMultiset_eq_iff [DecidableEq α] {f : α →₀ ℕ} {s : Multiset α} :
    Finsupp.toMultiset f = s ↔ f = Multiset.toFinsupp s 
Arguments: {α : Type u_1} [DecidableEq α] {f : α →₀ ℕ} {s : Multiset α}
Goal: Finsupp.toMultiset f = s ↔ f = Multiset.toFinsupp s
-- Finsupp.coe_orderIsoMultiset
@[simp]
theorem coe_orderIsoMultiset [DecidableEq ι] : ⇑(@orderIsoMultiset ι _) = toMultiset 
Arguments: {ι : Type u_3} [DecidableEq ι]
Goal: ⇑Finsupp.orderIsoMultiset = ⇑Finsupp.toMultiset
-- Finsupp.coe_orderIsoMultiset_symm
@[simp]
theorem coe_orderIsoMultiset_symm [DecidableEq ι] :
    ⇑(@orderIsoMultiset ι).symm = Multiset.toFinsupp 
Arguments: {ι : Type u_3} [DecidableEq ι]
Goal: ⇑Finsupp.orderIsoMultiset.symm = ⇑Multiset.toFinsupp
-- Finsupp.toMultiset_strictMono
theorem toMultiset_strictMono : StrictMono (@toMultiset ι) 
Arguments: {ι : Type u_3}
Goal: StrictMono ⇑Finsupp.toMultiset