ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Stream'.drop_zero
@[simp] theorem drop_zero {s : Stream' α} : s.drop 0 = s 
Arguments: {α : Type u} {s : Stream' α}
Goal: Stream'.drop 0 s = s
-- Stream'.drop_succ
theorem drop_succ (n : ℕ) (s : Stream' α) : drop (succ n) s = drop n (tail s) 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: Stream'.drop n.succ s = Stream'.drop n s.tail
-- Stream'.head_drop
theorem head_drop (a : Stream' α) (n : ℕ) : (a.drop n).head = a.get n 
Arguments: {α : Type u} (a : Stream' α) (n : ℕ)
Goal: (Stream'.drop n a).head = a.get n
-- Stream'.cons_injective2
theorem cons_injective2 : Function.Injective2 (cons : α → Stream' α → Stream' α) 
Arguments: {α : Type u}
Goal: Function.Injective2 Stream'.cons
-- Stream'.cons_injective_left
theorem cons_injective_left (s : Stream' α) : Function.Injective fun x => cons x s 
Arguments: {α : Type u} (s : Stream' α)
Goal: Function.Injective fun x => Stream'.cons x s
-- Stream'.cons_injective_right
theorem cons_injective_right (x : α) : Function.Injective (cons x) 
Arguments: {α : Type u} (x : α)
Goal: Function.Injective (Stream'.cons x)
-- Stream'.all_def
theorem all_def (p : α → Prop) (s : Stream' α) : All p s = ∀ n, p (get s n) 
Arguments: {α : Type u} (p : α → Prop) (s : Stream' α)
Goal: Stream'.All p s = ∀ (n : ℕ), p (s.get n)
-- Stream'.any_def
theorem any_def (p : α → Prop) (s : Stream' α) : Any p s = ∃ n, p (get s n) 
Arguments: {α : Type u} (p : α → Prop) (s : Stream' α)
Goal: Stream'.Any p s = ∃ n, p (s.get n)
-- Stream'.mem_cons
@[simp]
theorem mem_cons (a : α) (s : Stream' α) : a ∈ a::s 
Arguments: {α : Type u} (a : α) (s : Stream' α)
Goal: a ∈ Stream'.cons a s
-- Stream'.mem_cons_of_mem
theorem mem_cons_of_mem {a : α} {s : Stream' α} (b : α) : a ∈ s → a ∈ b::s 
Arguments: {α : Type u} {a : α} {s : Stream' α} (b : α)
Goal: a ∈ s → a ∈ Stream'.cons b s
-- Stream'.eq_or_mem_of_mem_cons
theorem eq_or_mem_of_mem_cons {a b : α} {s : Stream' α} : (a ∈ b::s) → a = b ∨ a ∈ s 
Arguments: {α : Type u} {a b : α} {s : Stream' α}
Goal: a ∈ Stream'.cons b s → a = b ∨ a ∈ s
-- Stream'.mem_of_get_eq
theorem mem_of_get_eq {n : ℕ} {s : Stream' α} {a : α} : a = get s n → a ∈ s 
Arguments: {α : Type u} {n : ℕ} {s : Stream' α} {a : α}
Goal: a = s.get n → a ∈ s
-- Stream'.drop_map
theorem drop_map (n : ℕ) (s : Stream' α) : drop n (map f s) = map f (drop n s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (n : ℕ) (s : Stream' α)
Goal: Stream'.drop n (Stream'.map f s) = Stream'.map f (Stream'.drop n s)
-- Stream'.get_map
@[simp]
theorem get_map (n : ℕ) (s : Stream' α) : get (map f s) n = f (get s n) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (n : ℕ) (s : Stream' α)
Goal: (Stream'.map f s).get n = f (s.get n)
-- Stream'.tail_map
theorem tail_map (s : Stream' α) : tail (map f s) = map f (tail s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream' α)
Goal: (Stream'.map f s).tail = Stream'.map f s.tail
-- Stream'.head_map
@[simp]
theorem head_map (s : Stream' α) : head (map f s) = f (head s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream' α)
Goal: (Stream'.map f s).head = f s.head
-- Stream'.map_eq
theorem map_eq (s : Stream' α) : map f s = f (head s)::map f (tail s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream' α)
Goal: Stream'.map f s = Stream'.cons (f s.head) (Stream'.map f s.tail)
-- Stream'.map_cons
theorem map_cons (a : α) (s : Stream' α) : map f (a::s) = f a::map f s 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α) (s : Stream' α)
Goal: Stream'.map f (Stream'.cons a s) = Stream'.cons (f a) (Stream'.map f s)
-- Stream'.map_id
@[simp]
theorem map_id (s : Stream' α) : map id s = s 
Arguments: {α : Type u} (s : Stream' α)
Goal: Stream'.map id s = s
-- Stream'.map_map
@[simp]
theorem map_map (g : β → δ) (f : α → β) (s : Stream' α) : map g (map f s) = map (g ∘ f) s 
Arguments: {α : Type u} {β : Type v} {δ : Type w} (g : β → δ) (f : α → β) (s : Stream' α)
Goal: Stream'.map g (Stream'.map f s) = Stream'.map (g ∘ f) s
-- Stream'.map_tail
@[simp]
theorem map_tail (s : Stream' α) : map f (tail s) = tail (map f s) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream' α)
Goal: Stream'.map f s.tail = (Stream'.map f s).tail
-- Stream'.mem_map
theorem mem_map {a : α} {s : Stream' α} : a ∈ s → f a ∈ map f s 
Arguments: {α : Type u} {β : Type v} (f : α → β) {a : α} {s : Stream' α}
Goal: a ∈ s → f a ∈ Stream'.map f s
-- Stream'.exists_of_mem_map
theorem exists_of_mem_map {f} {b : β} {s : Stream' α} : b ∈ map f s → ∃ a, a ∈ s ∧ f a = b 
Arguments: {α : Type u} {β : Type v} {f : α → β} {b : β} {s : Stream' α}
Goal: b ∈ Stream'.map f s → ∃ a, a ∈ s ∧ f a = b
-- Stream'.drop_zip
theorem drop_zip (n : ℕ) (s₁ : Stream' α) (s₂ : Stream' β) :
    drop n (zip f s₁ s₂) = zip f (drop n s₁) (drop n s₂) 
Arguments: {α : Type u} {β : Type v} {δ : Type w} (f : α → β → δ) (n : ℕ) (s₁ : Stream' α) (s₂ : Stream' β)
Goal: Stream'.drop n (Stream'.zip f s₁ s₂) = Stream'.zip f (Stream'.drop n s₁) (Stream'.drop n s₂)
-- Stream'.get_zip
@[simp]
theorem get_zip (n : ℕ) (s₁ : Stream' α) (s₂ : Stream' β) :
    get (zip f s₁ s₂) n = f (get s₁ n) (get s₂ n) 
Arguments: {α : Type u} {β : Type v} {δ : Type w} (f : α → β → δ) (n : ℕ) (s₁ : Stream' α) (s₂ : Stream' β)
Goal: (Stream'.zip f s₁ s₂).get n = f (s₁.get n) (s₂.get n)
-- Stream'.head_zip
theorem head_zip (s₁ : Stream' α) (s₂ : Stream' β) : head (zip f s₁ s₂) = f (head s₁) (head s₂) 
Arguments: {α : Type u} {β : Type v} {δ : Type w} (f : α → β → δ) (s₁ : Stream' α) (s₂ : Stream' β)
Goal: (Stream'.zip f s₁ s₂).head = f s₁.head s₂.head
-- Stream'.tail_zip
theorem tail_zip (s₁ : Stream' α) (s₂ : Stream' β) :
    tail (zip f s₁ s₂) = zip f (tail s₁) (tail s₂) 
Arguments: {α : Type u} {β : Type v} {δ : Type w} (f : α → β → δ) (s₁ : Stream' α) (s₂ : Stream' β)
Goal: (Stream'.zip f s₁ s₂).tail = Stream'.zip f s₁.tail s₂.tail
-- Stream'.zip_eq
theorem zip_eq (s₁ : Stream' α) (s₂ : Stream' β) :
    zip f s₁ s₂ = f (head s₁) (head s₂)::zip f (tail s₁) (tail s₂) 
Arguments: {α : Type u} {β : Type v} {δ : Type w} (f : α → β → δ) (s₁ : Stream' α) (s₂ : Stream' β)
Goal: Stream'.zip f s₁ s₂ = Stream'.cons (f s₁.head s₂.head) (Stream'.zip f s₁.tail s₂.tail)
-- Stream'.get_enum
@[simp]
theorem get_enum (s : Stream' α) (n : ℕ) : get (enum s) n = (n, s.get n) 
Arguments: {α : Type u} (s : Stream' α) (n : ℕ)
Goal: s.enum.get n = (n, s.get n)
-- Stream'.enum_eq_zip
theorem enum_eq_zip (s : Stream' α) : enum s = zip Prod.mk nats s 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.enum = Stream'.zip Prod.mk Stream'.nats s
-- Stream'.mem_const
@[simp]
theorem mem_const (a : α) : a ∈ const a 
Arguments: {α : Type u} (a : α)
Goal: a ∈ Stream'.const a
-- Stream'.const_eq
theorem const_eq (a : α) : const a = a::const a 
Arguments: {α : Type u} (a : α)
Goal: Stream'.const a = Stream'.cons a (Stream'.const a)
-- Stream'.tail_const
@[simp]
theorem tail_const (a : α) : tail (const a) = const a 
Arguments: {α : Type u} (a : α)
Goal: (Stream'.const a).tail = Stream'.const a
-- Stream'.map_const
@[simp]
theorem map_const (f : α → β) (a : α) : map f (const a) = const (f a) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α)
Goal: Stream'.map f (Stream'.const a) = Stream'.const (f a)
-- Stream'.get_const
@[simp]
theorem get_const (n : ℕ) (a : α) : get (const a) n = a 
Arguments: {α : Type u} (n : ℕ) (a : α)
Goal: (Stream'.const a).get n = a
-- Stream'.drop_const
@[simp]
theorem drop_const (n : ℕ) (a : α) : drop n (const a) = const a 
Arguments: {α : Type u} (n : ℕ) (a : α)
Goal: Stream'.drop n (Stream'.const a) = Stream'.const a
-- Stream'.head_iterate
@[simp]
theorem head_iterate (f : α → α) (a : α) : head (iterate f a) = a 
Arguments: {α : Type u} (f : α → α) (a : α)
Goal: (Stream'.iterate f a).head = a
-- Stream'.get_succ_iterate'
theorem get_succ_iterate' (n : ℕ) (f : α → α) (a : α) :
    get (iterate f a) (succ n) = f (get (iterate f a) n) 
Arguments: {α : Type u} (n : ℕ) (f : α → α) (a : α)
Goal: (Stream'.iterate f a).get n.succ = f ((Stream'.iterate f a).get n)
-- Stream'.tail_iterate
theorem tail_iterate (f : α → α) (a : α) : tail (iterate f a) = iterate f (f a) 
Arguments: {α : Type u} (f : α → α) (a : α)
Goal: (Stream'.iterate f a).tail = Stream'.iterate f (f a)
-- Stream'.iterate_eq
theorem iterate_eq (f : α → α) (a : α) : iterate f a = a::iterate f (f a) 
Arguments: {α : Type u} (f : α → α) (a : α)
Goal: Stream'.iterate f a = Stream'.cons a (Stream'.iterate f (f a))
-- Stream'.get_zero_iterate
@[simp]
theorem get_zero_iterate (f : α → α) (a : α) : get (iterate f a) 0 = a 
Arguments: {α : Type u} (f : α → α) (a : α)
Goal: (Stream'.iterate f a).get 0 = a
-- Stream'.get_succ_iterate
theorem get_succ_iterate (n : ℕ) (f : α → α) (a : α) :
    get (iterate f a) (succ n) = get (iterate f (f a)) n 
Arguments: {α : Type u} (n : ℕ) (f : α → α) (a : α)
Goal: (Stream'.iterate f a).get n.succ = (Stream'.iterate f (f a)).get n
-- Stream'.get_of_bisim
theorem get_of_bisim (bisim : IsBisimulation R) :
    ∀ {s₁ s₂} (n), s₁ ~ s₂ → get s₁ n = get s₂ n ∧ drop (n + 1) s₁ ~ drop (n + 1) s₂
  
Arguments: {α : Type u} (R : Stream' α → Stream' α → Prop) (bisim : Stream'.IsBisimulation R) {s₁ s₂ : Stream' α} (n : ℕ)
Goal: R s₁ s₂ → s₁.get n = s₂.get n ∧ R (Stream'.drop (n + 1) s₁) (Stream'.drop (n + 1) s₂)
-- Stream'.eq_of_bisim
theorem eq_of_bisim (bisim : IsBisimulation R) : ∀ {s₁ s₂}, s₁ ~ s₂ → s₁ = s₂ 
Arguments: {α : Type u} (R : Stream' α → Stream' α → Prop) (bisim : Stream'.IsBisimulation R) {s₁ s₂ : Stream' α}
Goal: R s₁ s₂ → s₁ = s₂
-- Stream'.bisim_simple
theorem bisim_simple (s₁ s₂ : Stream' α) :
    head s₁ = head s₂ → s₁ = tail s₁ → s₂ = tail s₂ → s₁ = s₂ 
Arguments: {α : Type u} (s₁ s₂ : Stream' α)
Goal: s₁.head = s₂.head → s₁ = s₁.tail → s₂ = s₂.tail → s₁ = s₂
-- Stream'.coinduction
theorem coinduction {s₁ s₂ : Stream' α} :
    head s₁ = head s₂ →
      (∀ (β : Type u) (fr : Stream' α → β),
      fr s₁ = fr s₂ → fr (tail s₁) = fr (tail s₂)) → s₁ = s₂ 
Arguments: {α : Type u} {s₁ s₂ : Stream' α}
Goal: s₁.head = s₂.head → (∀ (β : Type u) (fr : Stream' α → β), fr s₁ = fr s₂ → fr s₁.tail = fr s₂.tail) → s₁ = s₂
-- Stream'.iterate_id
@[simp]
theorem iterate_id (a : α) : iterate id a = const a 
Arguments: {α : Type u} (a : α)
Goal: Stream'.iterate id a = Stream'.const a
-- Stream'.map_iterate
theorem map_iterate (f : α → α) (a : α) : iterate f (f a) = map f (iterate f a) 
Arguments: {α : Type u} (f : α → α) (a : α)
Goal: Stream'.iterate f (f a) = Stream'.map f (Stream'.iterate f a)
-- Stream'.corec_def
theorem corec_def (f : α → β) (g : α → α) (a : α) : corec f g a = map f (iterate g a) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (g : α → α) (a : α)
Goal: Stream'.corec f g a = Stream'.map f (Stream'.iterate g a)
-- Stream'.corec_eq
theorem corec_eq (f : α → β) (g : α → α) (a : α) : corec f g a = f a::corec f g (g a) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (g : α → α) (a : α)
Goal: Stream'.corec f g a = Stream'.cons (f a) (Stream'.corec f g (g a))
-- Stream'.corec_id_id_eq_const
theorem corec_id_id_eq_const (a : α) : corec id id a = const a 
Arguments: {α : Type u} (a : α)
Goal: Stream'.corec id id a = Stream'.const a
-- Stream'.corec_id_f_eq_iterate
theorem corec_id_f_eq_iterate (f : α → α) (a : α) : corec id f a = iterate f a 
Arguments: {α : Type u} (f : α → α) (a : α)
Goal: Stream'.corec id f a = Stream'.iterate f a
-- Stream'.corec'_eq
theorem corec'_eq (f : α → β × α) (a : α) : corec' f a = (f a).1::corec' f (f a).2 
Arguments: {α : Type u} {β : Type v} (f : α → β × α) (a : α)
Goal: Stream'.corec' f a = Stream'.cons (f a).1 (Stream'.corec' f (f a).2)
-- Stream'.unfolds_eq
theorem unfolds_eq (g : α → β) (f : α → α) (a : α) : unfolds g f a = g a::unfolds g f (f a) 
Arguments: {α : Type u} {β : Type v} (g : α → β) (f : α → α) (a : α)
Goal: Stream'.unfolds g f a = Stream'.cons (g a) (Stream'.unfolds g f (f a))
-- Stream'.get_unfolds_head_tail
theorem get_unfolds_head_tail : ∀ (n : ℕ) (s : Stream' α),
    get (unfolds head tail s) n = get s n 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: (Stream'.unfolds Stream'.head Stream'.tail s).get n = s.get n
-- Stream'.unfolds_head_eq
theorem unfolds_head_eq : ∀ s : Stream' α, unfolds head tail s = s 
Arguments: {α : Type u} (s : Stream' α)
Goal: Stream'.unfolds Stream'.head Stream'.tail s = s
-- Stream'.interleave_eq
theorem interleave_eq (s₁ s₂ : Stream' α) : s₁ ⋈ s₂ = head s₁::head s₂::(tail s₁ ⋈ tail s₂) 
Arguments: {α : Type u} (s₁ s₂ : Stream' α)
Goal: s₁ ⋈ s₂ = Stream'.cons s₁.head (Stream'.cons s₂.head (s₁.tail ⋈ s₂.tail))
-- Stream'.tail_interleave
theorem tail_interleave (s₁ s₂ : Stream' α) : tail (s₁ ⋈ s₂) = s₂ ⋈ tail s₁ 
Arguments: {α : Type u} (s₁ s₂ : Stream' α)
Goal: (s₁ ⋈ s₂).tail = s₂ ⋈ s₁.tail
-- Stream'.interleave_tail_tail
theorem interleave_tail_tail (s₁ s₂ : Stream' α) : tail s₁ ⋈ tail s₂ = tail (tail (s₁ ⋈ s₂)) 
Arguments: {α : Type u} (s₁ s₂ : Stream' α)
Goal: s₁.tail ⋈ s₂.tail = (s₁ ⋈ s₂).tail.tail
-- Stream'.get_interleave_left
theorem get_interleave_left : ∀ (n : ℕ) (s₁ s₂ : Stream' α),
    get (s₁ ⋈ s₂) (2 * n) = get s₁ n
  
Arguments: {α : Type u} (n : ℕ) (s₁ s₂ : Stream' α)
Goal: (s₁ ⋈ s₂).get (2 * n) = s₁.get n
-- Stream'.get_interleave_right
theorem get_interleave_right : ∀ (n : ℕ) (s₁ s₂ : Stream' α),
    get (s₁ ⋈ s₂) (2 * n + 1) = get s₂ n
  
Arguments: {α : Type u} (n : ℕ) (s₁ s₂ : Stream' α)
Goal: (s₁ ⋈ s₂).get (2 * n + 1) = s₂.get n
-- Stream'.mem_interleave_left
theorem mem_interleave_left {a : α} {s₁ : Stream' α} (s₂ : Stream' α) : a ∈ s₁ → a ∈ s₁ ⋈ s₂ 
Arguments: {α : Type u} {a : α} {s₁ : Stream' α} (s₂ : Stream' α)
Goal: a ∈ s₁ → a ∈ s₁ ⋈ s₂
-- Stream'.mem_interleave_right
theorem mem_interleave_right {a : α} {s₁ : Stream' α} (s₂ : Stream' α) : a ∈ s₂ → a ∈ s₁ ⋈ s₂ 
Arguments: {α : Type u} {a : α} {s₁ : Stream' α} (s₂ : Stream' α)
Goal: a ∈ s₂ → a ∈ s₁ ⋈ s₂
-- Stream'.odd_eq
theorem odd_eq (s : Stream' α) : odd s = even (tail s) 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.odd = s.tail.even
-- Stream'.head_even
@[simp]
theorem head_even (s : Stream' α) : head (even s) = head s 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.even.head = s.head
-- Stream'.tail_even
theorem tail_even (s : Stream' α) : tail (even s) = even (tail (tail s)) 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.even.tail = s.tail.tail.even
-- Stream'.even_cons_cons
theorem even_cons_cons (a₁ a₂ : α) (s : Stream' α) : even (a₁::a₂::s) = a₁::even s 
Arguments: {α : Type u} (a₁ a₂ : α) (s : Stream' α)
Goal: (Stream'.cons a₁ (Stream'.cons a₂ s)).even = Stream'.cons a₁ s.even
-- Stream'.even_tail
theorem even_tail (s : Stream' α) : even (tail s) = odd s 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.tail.even = s.odd
-- Stream'.even_interleave
theorem even_interleave (s₁ s₂ : Stream' α) : even (s₁ ⋈ s₂) = s₁ 
Arguments: {α : Type u} (s₁ s₂ : Stream' α)
Goal: (s₁ ⋈ s₂).even = s₁
-- Stream'.interleave_even_odd
theorem interleave_even_odd (s₁ : Stream' α) : even s₁ ⋈ odd s₁ = s₁ 
Arguments: {α : Type u} (s₁ : Stream' α)
Goal: s₁.even ⋈ s₁.odd = s₁
-- Stream'.get_even
theorem get_even : ∀ (n : ℕ) (s : Stream' α), get (even s) n = get s (2 * n)
  
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: s.even.get n = s.get (2 * n)
-- Stream'.get_odd
theorem get_odd : ∀ (n : ℕ) (s : Stream' α), get (odd s) n = get s (2 * n + 1) 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: s.odd.get n = s.get (2 * n + 1)
-- Stream'.mem_of_mem_even
theorem mem_of_mem_even (a : α) (s : Stream' α) : a ∈ even s → a ∈ s 
Arguments: {α : Type u} (a : α) (s : Stream' α)
Goal: a ∈ s.even → a ∈ s
-- Stream'.mem_of_mem_odd
theorem mem_of_mem_odd (a : α) (s : Stream' α) : a ∈ odd s → a ∈ s 
Arguments: {α : Type u} (a : α) (s : Stream' α)
Goal: a ∈ s.odd → a ∈ s
-- Stream'.nil_append_stream
theorem nil_append_stream (s : Stream' α) : appendStream' [] s = s 
Arguments: {α : Type u} (s : Stream' α)
Goal: [] ++ₛ s = s
-- Stream'.cons_append_stream
theorem cons_append_stream (a : α) (l : List α) (s : Stream' α) :
    appendStream' (a::l) s = a::appendStream' l s 
Arguments: {α : Type u} (a : α) (l : List α) (s : Stream' α)
Goal: a :: l ++ₛ s = Stream'.cons a (l ++ₛ s)
-- Stream'.append_append_stream
theorem append_append_stream : ∀ (l₁ l₂ : List α) (s : Stream' α),
    l₁ ++ l₂ ++ₛ s = l₁ ++ₛ (l₂ ++ₛ s)
  
Arguments: {α : Type u} (l₁ l₂ : List α) (s : Stream' α)
Goal: l₁ ++ l₂ ++ₛ s = l₁ ++ₛ (l₂ ++ₛ s)
-- Stream'.map_append_stream
theorem map_append_stream (f : α → β) :
    ∀ (l : List α) (s : Stream' α), map f (l ++ₛ s) = List.map f l ++ₛ map f s
  
Arguments: {α : Type u} {β : Type v} (f : α → β) (l : List α) (s : Stream' α)
Goal: Stream'.map f (l ++ₛ s) = List.map f l ++ₛ Stream'.map f s
-- Stream'.drop_append_stream
theorem drop_append_stream : ∀ (l : List α) (s : Stream' α), drop l.length (l ++ₛ s) = s
  
Arguments: {α : Type u} (l : List α) (s : Stream' α)
Goal: Stream'.drop l.length (l ++ₛ s) = s
-- Stream'.append_stream_head_tail
theorem append_stream_head_tail (s : Stream' α) : [head s] ++ₛ tail s = s 
Arguments: {α : Type u} (s : Stream' α)
Goal: [s.head] ++ₛ s.tail = s
-- Stream'.mem_append_stream_right
theorem mem_append_stream_right : ∀ {a : α} (l : List α) {s : Stream' α}, a ∈ s → a ∈ l ++ₛ s
  
Arguments: {α : Type u} {a : α} (l : List α) {s : Stream' α}
Goal: a ∈ s → a ∈ l ++ₛ s
-- Stream'.mem_append_stream_left
theorem mem_append_stream_left : ∀ {a : α} {l : List α} (s : Stream' α), a ∈ l → a ∈ l ++ₛ s
  
Arguments: {α : Type u} {a : α} {l : List α} (s : Stream' α)
Goal: a ∈ l → a ∈ l ++ₛ s
-- Stream'.take_zero
@[simp]
theorem take_zero (s : Stream' α) : take 0 s = [] 
Arguments: {α : Type u} (s : Stream' α)
Goal: Stream'.take 0 s = []
-- Stream'.take_succ
theorem take_succ (n : ℕ) (s : Stream' α) : take (succ n) s = head s::take n (tail s) 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: Stream'.take n.succ s = s.head :: Stream'.take n s.tail
-- Stream'.take_succ_cons
@[simp] theorem take_succ_cons {a : α} (n : ℕ) (s : Stream' α) :
    take (n+1) (a::s) = a :: take n s 
Arguments: {α : Type u} {a : α} (n : ℕ) (s : Stream' α)
Goal: Stream'.take (n + 1) (Stream'.cons a s) = a :: Stream'.take n s
-- Stream'.take_succ'
theorem take_succ' {s : Stream' α} : ∀ n, s.take (n+1) = s.take n ++ [s.get n]
  
Arguments: {α : Type u} {s : Stream' α} (n : ℕ)
Goal: Stream'.take (n + 1) s = Stream'.take n s ++ [s.get n]
-- Stream'.length_take
@[simp]
theorem length_take (n : ℕ) (s : Stream' α) : (take n s).length = n 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: (Stream'.take n s).length = n
-- Stream'.take_take
@[simp]
theorem take_take {s : Stream' α} : ∀ {m n}, (s.take n).take m = s.take (min n m)
  
Arguments: {α : Type u} {s : Stream' α} {m n : ℕ}
Goal: List.take m (Stream'.take n s) = Stream'.take (min n m) s
-- Stream'.concat_take_get
@[simp] theorem concat_take_get {n : ℕ} {s : Stream' α} : s.take n ++ [s.get n] = s.take (n+1) 
Arguments: {α : Type u} {n : ℕ} {s : Stream' α}
Goal: Stream'.take n s ++ [s.get n] = Stream'.take (n + 1) s
-- Stream'.get?_take
theorem get?_take {s : Stream' α} : ∀ {k n}, k < n → (s.take n).get? k = s.get k
  
Arguments: {α : Type u} {s : Stream' α} {k n : ℕ}
Goal: k < n → (Stream'.take n s).get? k = some (s.get k)
-- Stream'.get?_take_succ
theorem get?_take_succ (n : ℕ) (s : Stream' α) :
    List.get? (take (succ n) s) n = some (get s n) 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: (Stream'.take n.succ s).get? n = some (s.get n)
-- Stream'.dropLast_take
@[simp] theorem dropLast_take {n : ℕ} {xs : Stream' α} :
    (Stream'.take n xs).dropLast = Stream'.take (n-1) xs 
Arguments: {α : Type u} {n : ℕ} {xs : Stream' α}
Goal: (Stream'.take n xs).dropLast = Stream'.take (n - 1) xs
-- Stream'.append_take_drop
@[simp]
theorem append_take_drop : ∀ (n : ℕ) (s : Stream' α),
    appendStream' (take n s) (drop n s) = s 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: Stream'.take n s ++ₛ Stream'.drop n s = s
-- Stream'.take_theorem
theorem take_theorem (s₁ s₂ : Stream' α) : (∀ n : ℕ, take n s₁ = take n s₂) → s₁ = s₂ 
Arguments: {α : Type u} (s₁ s₂ : Stream' α)
Goal: (∀ (n : ℕ), Stream'.take n s₁ = Stream'.take n s₂) → s₁ = s₂
-- Stream'.cycle_g_cons
protected theorem cycle_g_cons (a : α) (a₁ : α) (l₁ : List α) (a₀ : α) (l₀ : List α) :
    Stream'.cycleG (a, a₁::l₁, a₀, l₀) = (a₁, l₁, a₀, l₀) 
Arguments: {α : Type u} (a a₁ : α) (l₁ : List α) (a₀ : α) (l₀ : List α)
Goal: Stream'.cycleG (a, a₁ :: l₁, a₀, l₀) = (a₁, l₁, a₀, l₀)
-- Stream'.cycle_eq
theorem cycle_eq : ∀ (l : List α) (h : l ≠ []), cycle l h = l ++ₛ cycle l h
  
Arguments: {α : Type u} (l : List α) (h : l ≠ [])
Goal: Stream'.cycle l h = l ++ₛ Stream'.cycle l h
-- Stream'.mem_cycle
theorem mem_cycle {a : α} {l : List α} : ∀ h : l ≠ [], a ∈ l → a ∈ cycle l h 
Arguments: {α : Type u} {a : α} {l : List α} (h : l ≠ [])
Goal: a ∈ l → a ∈ Stream'.cycle l h
-- Stream'.cycle_singleton
@[simp]
theorem cycle_singleton (a : α) : cycle [a] (by simp) = const a 
Arguments: {α : Type u} (a : α)
Goal: Stream'.cycle [a] ⋯ = Stream'.const a
-- Stream'.tails_eq
theorem tails_eq (s : Stream' α) : tails s = tail s::tails (tail s) 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.tails = Stream'.cons s.tail s.tail.tails
-- Stream'.get_tails
@[simp]
theorem get_tails : ∀ (n : ℕ) (s : Stream' α), get (tails s) n = drop n (tail s) 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: s.tails.get n = Stream'.drop n s.tail
-- Stream'.tails_eq_iterate
theorem tails_eq_iterate (s : Stream' α) : tails s = iterate tail (tail s) 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.tails = Stream'.iterate Stream'.tail s.tail
-- Stream'.inits_core_eq
theorem inits_core_eq (l : List α) (s : Stream' α) :
    initsCore l s = l::initsCore (l ++ [head s]) (tail s) 
Arguments: {α : Type u} (l : List α) (s : Stream' α)
Goal: Stream'.initsCore l s = Stream'.cons l (Stream'.initsCore (l ++ [s.head]) s.tail)
-- Stream'.tail_inits
theorem tail_inits (s : Stream' α) :
    tail (inits s) = initsCore [head s, head (tail s)] (tail (tail s)) 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.inits.tail = Stream'.initsCore [s.head, s.tail.head] s.tail.tail
-- Stream'.inits_tail
theorem inits_tail (s : Stream' α) : inits (tail s) = initsCore [head (tail s)] (tail (tail s)) 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.tail.inits = Stream'.initsCore [s.tail.head] s.tail.tail
-- Stream'.cons_get_inits_core
theorem cons_get_inits_core :
    ∀ (a : α) (n : ℕ) (l : List α) (s : Stream' α),
      (a::get (initsCore l s) n) = get (initsCore (a::l) s) n 
Arguments: {α : Type u} (a : α) (n : ℕ) (l : List α) (s : Stream' α)
Goal: a :: (Stream'.initsCore l s).get n = (Stream'.initsCore (a :: l) s).get n
-- Stream'.get_inits
@[simp]
theorem get_inits : ∀ (n : ℕ) (s : Stream' α), get (inits s) n = take (succ n) s 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: s.inits.get n = Stream'.take n.succ s
-- Stream'.inits_eq
theorem inits_eq (s : Stream' α) :
    inits s = [head s]::map (List.cons (head s)) (inits (tail s)) 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.inits = Stream'.cons [s.head] (Stream'.map (List.cons s.head) s.tail.inits)
-- Stream'.zip_inits_tails
theorem zip_inits_tails (s : Stream' α) : zip appendStream' (inits s) (tails s) = const s 
Arguments: {α : Type u} (s : Stream' α)
Goal: Stream'.zip Stream'.appendStream' s.inits s.tails = Stream'.const s
-- Stream'.identity
theorem identity (s : Stream' α) : pure id ⊛ s = s 
Arguments: {α : Type u} (s : Stream' α)
Goal: Stream'.pure id ⊛ s = s
-- Stream'.composition
theorem composition (g : Stream' (β → δ)) (f : Stream' (α → β)) (s : Stream' α) :
    pure comp ⊛ g ⊛ f ⊛ s = g ⊛ (f ⊛ s) 
Arguments: {α : Type u} {β : Type v} {δ : Type w} (g : Stream' (β → δ)) (f : Stream' (α → β)) (s : Stream' α)
Goal: Stream'.pure Function.comp ⊛ g ⊛ f ⊛ s = g ⊛ (f ⊛ s)
-- Stream'.homomorphism
theorem homomorphism (f : α → β) (a : α) : pure f ⊛ pure a = pure (f a) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α)
Goal: Stream'.pure f ⊛ Stream'.pure a = Stream'.pure (f a)
-- Stream'.interchange
theorem interchange (fs : Stream' (α → β)) (a : α) :
    fs ⊛ pure a = (pure fun f : α → β => f a) ⊛ fs 
Arguments: {α : Type u} {β : Type v} (fs : Stream' (α → β)) (a : α)
Goal: fs ⊛ Stream'.pure a = (Stream'.pure fun f => f a) ⊛ fs
-- Stream'.map_eq_apply
theorem map_eq_apply (f : α → β) (s : Stream' α) : map f s = pure f ⊛ s 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Stream' α)
Goal: Stream'.map f s = Stream'.pure f ⊛ s