ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.concat_cons
theorem concat_cons (a b : α) (l : List α) : concat (a :: l) b = a :: concat l b 
Arguments: {α : Type u_1} (a b : α) (l : List α)
Goal: (a :: l).concat b = a :: l.concat b
-- List.init_eq_of_concat_eq
theorem init_eq_of_concat_eq {a b : α} {l₁ l₂ : List α} : concat l₁ a = concat l₂ b → l₁ = l₂ 
Arguments: {α : Type u_1} {a b : α} {l₁ l₂ : List α}
Goal: l₁.concat a = l₂.concat b → l₁ = l₂
-- List.last_eq_of_concat_eq
theorem last_eq_of_concat_eq {a b : α} {l₁ l₂ : List α} : concat l₁ a = concat l₂ b → a = b 
Arguments: {α : Type u_1} {a b : α} {l₁ l₂ : List α}
Goal: l₁.concat a = l₂.concat b → a = b
-- List.concat_inj_left
theorem concat_inj_left {l l' : List α} (a : α) : concat l a = concat l' a ↔ l = l' 
Arguments: {α : Type u_1} {l l' : List α} (a : α)
Goal: l.concat a = l'.concat a ↔ l = l'
-- List.concat_eq_concat
theorem concat_eq_concat {l l' : List α} {a b : α} : concat l a = concat l' b ↔ l = l' ∧ a = b 
Arguments: {α : Type u_1} {l l' : List α} {a b : α}
Goal: l.concat a = l'.concat b ↔ l = l' ∧ a = b
-- List.concat_ne_nil
theorem concat_ne_nil (a : α) (l : List α) : concat l a ≠ [] 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: l.concat a ≠ []
-- List.concat_append
theorem concat_append (a : α) (l₁ l₂ : List α) : concat l₁ a ++ l₂ = l₁ ++ a :: l₂ 
Arguments: {α : Type u_1} (a : α) (l₁ l₂ : List α)
Goal: l₁.concat a ++ l₂ = l₁ ++ a :: l₂
-- List.append_concat
theorem append_concat (a : α) (l₁ l₂ : List α) : l₁ ++ concat l₂ a = concat (l₁ ++ l₂) a 
Arguments: {α : Type u_1} (a : α) (l₁ l₂ : List α)
Goal: l₁ ++ l₂.concat a = (l₁ ++ l₂).concat a
-- List.map_concat
theorem map_concat (f : α → β) (a : α) (l : List α) : map f (concat l a) = concat (map f l) (f a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (a : α) (l : List α)
Goal: List.map f (l.concat a) = (List.map f l).concat (f a)
-- List.eq_nil_or_concat
theorem eq_nil_or_concat : ∀ l : List α, l = [] ∨ ∃ L b, l = concat L b
  
Arguments: {α : Type u_1} (l : List α)
Goal: l = [] ∨ ∃ L b, l = L.concat b
-- List.mem_join
@[simp] theorem mem_join : ∀ {L : List (List α)}, a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l
  
Arguments: {α : Type u_1} {a : α} {L : List (List α)}
Goal: a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l
-- List.exists_of_mem_join
theorem exists_of_mem_join : a ∈ join L → ∃ l, l ∈ L ∧ a ∈ l 
Goal: ∀ {α : Type u_1} {a : α} {L : List (List α)}, a ∈ L.join → ∃ l, l ∈ L ∧ a ∈ l
-- List.mem_join_of_mem
theorem mem_join_of_mem (lL : l ∈ L) (al : a ∈ l) : a ∈ join L 
Goal: ∀ {α : Type u_1} {l : List α} {L : List (List α)} {a : α}, l ∈ L → a ∈ l → a ∈ L.join
-- List.map_join
@[simp] theorem map_join (f : α → β) (L : List (List α)) : map f (join L) = join (map (map f) L) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (L : List (List α))
Goal: List.map f L.join = (List.map (List.map f) L).join
-- List.append_bind
@[simp] theorem append_bind xs ys (f : α → List β) :
  List.bind (xs ++ ys) f = List.bind xs f ++ List.bind ys f 
Arguments: {α : Type u_1} {β : Type u_2} (xs ys : List α) (f : α → List β)
Goal: (xs ++ ys).bind f = xs.bind f ++ ys.bind f
-- List.bind_id
@[simp] theorem bind_id (l : List (List α)) : List.bind l id = l.join 
Arguments: {α : Type u_1} (l : List (List α))
Goal: l.bind id = l.join
-- List.mem_bind
@[simp] theorem mem_bind {f : α → List β} {b} {l : List α} : b ∈ l.bind f ↔ ∃ a, a ∈ l ∧ b ∈ f a 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → List β} {b : β} {l : List α}
Goal: b ∈ l.bind f ↔ ∃ a, a ∈ l ∧ b ∈ f a
-- List.exists_of_mem_bind
theorem exists_of_mem_bind {b : β} {l : List α} {f : α → List β} :
    b ∈ List.bind l f → ∃ a, a ∈ l ∧ b ∈ f a 
Arguments: {β : Type u_1} {α : Type u_2} {b : β} {l : List α} {f : α → List β}
Goal: b ∈ l.bind f → ∃ a, a ∈ l ∧ b ∈ f a
-- List.mem_bind_of_mem
theorem mem_bind_of_mem {b : β} {l : List α} {f : α → List β} {a} (al : a ∈ l) (h : b ∈ f a) :
    b ∈ List.bind l f 
Arguments: {β : Type u_1} {α : Type u_2} {b : β} {l : List α} {f : α → List β} {a : α} (al : a ∈ l) (h : b ∈ f a)
Goal: b ∈ l.bind f
-- List.bind_singleton
theorem bind_singleton (f : α → List β) (x : α) : [x].bind f = f x 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → List β) (x : α)
Goal: [x].bind f = f x
-- List.bind_singleton'
@[simp] theorem bind_singleton' (l : List α) : (l.bind fun x => [x]) = l 
Arguments: {α : Type u_1} (l : List α)
Goal: (l.bind fun x => [x]) = l
-- List.bind_assoc
theorem bind_assoc {α β} (l : List α) (f : α → List β) (g : β → List γ) :
    (l.bind f).bind g = l.bind fun x => (f x).bind g 
Arguments: {γ : Type u_1} {α : Type u_2} {β : Type u_3} (l : List α) (f : α → List β) (g : β → List γ)
Goal: (l.bind f).bind g = l.bind fun x => (f x).bind g
-- List.map_bind
theorem map_bind (f : β → γ) (g : α → List β) :
    ∀ l : List α, (l.bind g).map f = l.bind fun a => (g a).map f
  
Arguments: {β : Type u_1} {γ : Type u_2} {α : Type u_3} (f : β → γ) (g : α → List β) (l : List α)
Goal: List.map f (l.bind g) = l.bind fun a => List.map f (g a)
-- List.bind_map
theorem bind_map (f : α → β) (g : β → List γ) (l : List α) : (map f l).bind g = l.bind (fun a => g (f a)) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → List γ) (l : List α)
Goal: (List.map f l).bind g = l.bind fun a => g (f a)
-- List.map_eq_bind
theorem map_eq_bind {α β} (f : α → β) (l : List α) : map f l = l.bind fun x => [f x] 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: List.map f l = l.bind fun x => [f x]
-- List.replicate_one
@[simp] theorem replicate_one : replicate 1 a = [a] 
Goal: ∀ {α : Type u_1} {a : α}, List.replicate 1 a = [a]
-- List.contains_replicate
@[simp] theorem contains_replicate [BEq α] {n : Nat} {a b : α} :
    (replicate n b).contains a = (a == b && !n == 0) 
Arguments: {α : Type u_1} [BEq α] {n : Nat} {a b : α}
Goal: (List.replicate n b).contains a = (a == b && !n == 0)
-- List.decide_mem_replicate
@[simp] theorem decide_mem_replicate [BEq α] [LawfulBEq α] {a b : α} :
    ∀ {n}, decide (b ∈ replicate n a) = ((¬ n == 0) && b == a)
  
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α} {n : Nat}
Goal: decide (b ∈ List.replicate n a) = (decide ¬(n == 0) = true && b == a)
-- List.mem_replicate
@[simp] theorem mem_replicate {a b : α} : ∀ {n}, b ∈ replicate n a ↔ n ≠ 0 ∧ b = a
  
Arguments: {α : Type u_1} {a b : α} {n : Nat}
Goal: b ∈ List.replicate n a ↔ n ≠ 0 ∧ b = a
-- List.eq_of_mem_replicate
theorem eq_of_mem_replicate {a b : α} {n} (h : b ∈ replicate n a) : b = a 
Arguments: {α : Type u_1} {a b : α} {n : Nat} (h : b ∈ List.replicate n a)
Goal: b = a
-- List.replicate_succ_ne_nil
@[simp] theorem replicate_succ_ne_nil (n : Nat) (a : α) : replicate (n+1) a ≠ [] 
Arguments: {α : Type u_1} (n : Nat) (a : α)
Goal: List.replicate (n + 1) a ≠ []
-- List.getElem_replicate
@[simp] theorem getElem_replicate (a : α) {n : Nat} {m} (h : m < (replicate n a).length) :
    (replicate n a)[m] = a 
Arguments: {α : Type u_1} (a : α) {n m : Nat} (h : m < (List.replicate n a).length)
Goal: (List.replicate n a)[m] = a
-- List.get_replicate
@[deprecated getElem_replicate (since := "2024-06-12")]
theorem get_replicate (a : α) {n : Nat} (m : Fin _) : (replicate n a).get m = a 
Arguments: {α : Type u_1} (a : α) {n : Nat} (m : Fin (List.replicate n a).length)
Goal: (List.replicate n a).get m = a
-- List.getElem?_replicate
theorem getElem?_replicate : (replicate n a)[m]? = if m < n then some a else none 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {a : α} {m : Nat}, (List.replicate n a)[m]? = if m < n then some a else none
-- List.getElem?_replicate_of_lt
@[simp] theorem getElem?_replicate_of_lt {n : Nat} {m : Nat} (h : m < n) : (replicate n a)[m]? = some a 
Goal: ∀ {α : Type u_1} {a : α} {n m : Nat}, m < n → (List.replicate n a)[m]? = some a
-- List.replicate_inj
@[simp] theorem replicate_inj : replicate n a = replicate m b ↔ n = m ∧ (n = 0 ∨ a = b) 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {a : α} {m : Nat} {b : α}, List.replicate n a = List.replicate m b ↔ n = m ∧ (n = 0 ∨ a = b)
-- List.eq_replicate_of_mem
theorem eq_replicate_of_mem {a : α} :
    ∀ {l : List α}, (∀ (b) (_ : b ∈ l), b = a) → l = replicate l.length a
  
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: (∀ (b : α), b ∈ l → b = a) → l = List.replicate l.length a
-- List.eq_replicate
theorem eq_replicate {a : α} {n} {l : List α} :
    l = replicate n a ↔ length l = n ∧ ∀ (b) (_ : b ∈ l), b = a 
Arguments: {α : Type u_1} {a : α} {n : Nat} {l : List α}
Goal: l = List.replicate n a ↔ l.length = n ∧ ∀ (b : α), b ∈ l → b = a
-- List.map_eq_replicate_iff
theorem map_eq_replicate_iff {l : List α} {f : α → β} {b : β} :
    l.map f = replicate l.length b ↔ ∀ x ∈ l, f x = b 
Arguments: {α : Type u_1} {β : Type u_2} {l : List α} {f : α → β} {b : β}
Goal: List.map f l = List.replicate l.length b ↔ ∀ (x : α), x ∈ l → f x = b
-- List.map_const
@[simp] theorem map_const (l : List α) (b : β) : map (Function.const α b) l = replicate l.length b 
Arguments: {α : Type u_1} {β : Type u_2} (l : List α) (b : β)
Goal: List.map (Function.const α b) l = List.replicate l.length b
-- List.map_const'
theorem map_const' (l : List α) (b : β) : map (fun _ => b) l = replicate l.length b 
Arguments: {α : Type u_1} {β : Type u_2} (l : List α) (b : β)
Goal: List.map (fun x => b) l = List.replicate l.length b
-- List.append_replicate_replicate
@[simp] theorem append_replicate_replicate : replicate n a ++ replicate m a = replicate (n + m) a 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {a : α} {m : Nat}, List.replicate n a ++ List.replicate m a = List.replicate (n + m) a
-- List.map_replicate
@[simp] theorem map_replicate : (replicate n a).map f = replicate n (f a) 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {a : α} {α_1 : Type u_2} {f : α → α_1}, List.map f (List.replicate n a) = List.replicate n (f a)
-- List.filter_replicate
theorem filter_replicate : (replicate n a).filter p = if p a then replicate n a else [] 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {a : α} {p : α → Bool},
  List.filter p (List.replicate n a) = if p a = true then List.replicate n a else []
-- List.filter_replicate_of_pos
@[simp] theorem filter_replicate_of_pos (h : p a) : (replicate n a).filter p = replicate n a 
Goal: ∀ {α : Type u_1} {p : α → Bool} {n : Nat} {a : α}, p a = true → List.filter p (List.replicate n a) = List.replicate n a
-- List.filter_replicate_of_neg
@[simp] theorem filter_replicate_of_neg (h : ¬ p a) : (replicate n a).filter p = [] 
Goal: ∀ {α : Type u_1} {p : α → Bool} {n : Nat} {a : α}, ¬p a = true → List.filter p (List.replicate n a) = []
-- List.filterMap_replicate
theorem filterMap_replicate {f : α → Option β} :
    (replicate n a).filterMap f = match f a with | none => [] | .some b => replicate n b 
Arguments: {α : Type u_1} {β : Type u_2} {n : Nat} {a : α} {f : α → Option β}
Goal: List.filterMap f (List.replicate n a) =
  match f a with
  | none => []
  | some b => List.replicate n b
-- List.filterMap_replicate_of_some
theorem filterMap_replicate_of_some {f : α → Option β} (h : f a = some b) :
    (replicate n a).filterMap f = replicate n b 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β} {n : Nat} {f : α → Option β} (h : f a = some b)
Goal: List.filterMap f (List.replicate n a) = List.replicate n b
-- List.filterMap_replicate_of_isSome
@[simp] theorem filterMap_replicate_of_isSome {f : α → Option β} (h : (f a).isSome) :
    (replicate n a).filterMap f = replicate n (Option.get _ h) 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {n : Nat} {f : α → Option β} (h : (f a).isSome = true)
Goal: List.filterMap f (List.replicate n a) = List.replicate n ((f a).get h)
-- List.filterMap_replicate_of_none
@[simp] theorem filterMap_replicate_of_none {f : α → Option β} (h : f a = none) :
    (replicate n a).filterMap f = [] 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {n : Nat} {f : α → Option β} (h : f a = none)
Goal: List.filterMap f (List.replicate n a) = []
-- List.join_replicate_nil
@[simp] theorem join_replicate_nil : (replicate n ([] : List α)).join = [] 
Arguments: {n : Nat} {α : Type u_1}
Goal: (List.replicate n []).join = []
-- List.join_replicate_singleton
@[simp] theorem join_replicate_singleton : (replicate n [a]).join = replicate n a 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {a : α}, (List.replicate n [a]).join = List.replicate n a
-- List.join_replicate_replicate
@[simp] theorem join_replicate_replicate : (replicate n (replicate m a)).join = replicate (n * m) a 
Arguments: {n m : Nat}
Goal: ∀ {α : Type u_1} {a : α}, (List.replicate n (List.replicate m a)).join = List.replicate (n * m) a
-- List.bind_replicate
theorem bind_replicate {β} (f : α → List β) : (replicate n a).bind f = (replicate n (f a)).join 
Arguments: {α : Type u_1} {n : Nat} {a : α} {β : Type u_2} (f : α → List β)
Goal: (List.replicate n a).bind f = (List.replicate n (f a)).join
-- List.isEmpty_replicate
@[simp] theorem isEmpty_replicate : (replicate n a).isEmpty = decide (n = 0) 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {a : α}, (List.replicate n a).isEmpty = decide (n = 0)
-- List.length_reverse
@[simp] theorem length_reverse (as : List α) : (as.reverse).length = as.length 
Arguments: {α : Type u_1} (as : List α)
Goal: as.reverse.length = as.length
-- List.getElem?_reverse'
theorem getElem?_reverse' : ∀ {l : List α} (i j), i + j + 1 = length l →
    l.reverse[i]? = l[j]?
  
Arguments: {α : Type u_1} {l : List α} (i j : Nat)
Goal: i + j + 1 = l.length → l.reverse[i]? = l[j]?
-- List.get?_reverse'
@[deprecated getElem?_reverse' (since := "2024-06-12")]
theorem get?_reverse' {l : List α} (i j) (h : i + j + 1 = length l) : get? l.reverse i = get? l j 
Arguments: {α : Type u_1} {l : List α} (i j : Nat) (h : i + j + 1 = l.length)
Goal: l.reverse.get? i = l.get? j
-- List.getElem?_reverse
theorem getElem?_reverse {l : List α} {i} (h : i < length l) :
    l.reverse[i]? = l[l.length - 1 - i]? 
Arguments: {α : Type u_1} {l : List α} {i : Nat} (h : i < l.length)
Goal: l.reverse[i]? = l[l.length - 1 - i]?
-- List.get?_reverse
@[deprecated getElem?_reverse (since := "2024-06-12")]
theorem get?_reverse {l : List α} {i} (h : i < length l) :
    get? l.reverse i = get? l (l.length - 1 - i) 
Arguments: {α : Type u_1} {l : List α} {i : Nat} (h : i < l.length)
Goal: l.reverse.get? i = l.get? (l.length - 1 - i)
-- List.reverseAux_reverseAux_nil
theorem reverseAux_reverseAux_nil (as bs : List α) : reverseAux (reverseAux as bs) [] = reverseAux bs as 
Arguments: {α : Type u_1} (as bs : List α)
Goal: (as.reverseAux bs).reverseAux [] = bs.reverseAux as
-- List.reverse_reverse
@[simp] theorem reverse_reverse (as : List α) : as.reverse.reverse = as 
Arguments: {α : Type u_1} (as : List α)
Goal: as.reverse.reverse = as
-- List.getLast?_reverse
@[simp] theorem getLast?_reverse (l : List α) : l.reverse.getLast? = l.head? 
Arguments: {α : Type u_1} (l : List α)
Goal: l.reverse.getLast? = l.head?
-- List.head?_reverse
@[simp] theorem head?_reverse (l : List α) : l.reverse.head? = l.getLast? 
Arguments: {α : Type u_1} (l : List α)
Goal: l.reverse.head? = l.getLast?
-- List.reverse_append
@[simp] theorem reverse_append (as bs : List α) : (as ++ bs).reverse = bs.reverse ++ as.reverse 
Arguments: {α : Type u_1} (as bs : List α)
Goal: (as ++ bs).reverse = bs.reverse ++ as.reverse
-- List.map_reverse
@[simp] theorem map_reverse (f : α → β) (l : List α) : l.reverse.map f = (l.map f).reverse 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: List.map f l.reverse = (List.map f l).reverse
-- List.reverse_map
@[deprecated map_reverse (since := "2024-06-20")]
theorem reverse_map (f : α → β) (l : List α) : (l.map f).reverse = l.reverse.map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: (List.map f l).reverse = List.map f l.reverse
-- List.reverse_eq_nil_iff
@[simp] theorem reverse_eq_nil_iff {xs : List α} : xs.reverse = [] ↔ xs = [] 
Arguments: {α : Type u_1} {xs : List α}
Goal: xs.reverse = [] ↔ xs = []
-- List.mem_reverseAux
@[simp] theorem mem_reverseAux {x : α} : ∀ {as bs}, x ∈ reverseAux as bs ↔ x ∈ as ∨ x ∈ bs
  
Arguments: {α : Type u_1} {x : α} {as bs : List α}
Goal: x ∈ as.reverseAux bs ↔ x ∈ as ∨ x ∈ bs
-- List.mem_reverse
@[simp] theorem mem_reverse {x : α} {as : List α} : x ∈ reverse as ↔ x ∈ as 
Arguments: {α : Type u_1} {x : α} {as : List α}
Goal: x ∈ as.reverse ↔ x ∈ as
-- List.reverseAux_eq
theorem reverseAux_eq (as bs : List α) : reverseAux as bs = reverse as ++ bs 
Arguments: {α : Type u_1} (as bs : List α)
Goal: as.reverseAux bs = as.reverse ++ bs
-- List.foldrM_reverse
@[simp] theorem foldrM_reverse [Monad m] (l : List α) (f : α → β → m β) (b) :
    l.reverse.foldrM f b = l.foldlM (fun x y => f y x) b 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (l : List α) (f : α → β → m β) (b : β)
Goal: List.foldrM f b l.reverse = List.foldlM (fun x y => f y x) b l
-- List.foldl_reverse
@[simp] theorem foldl_reverse (l : List α) (f : β → α → β) (b) :
    l.reverse.foldl f b = l.foldr (fun x y => f y x) b 
Arguments: {α : Type u_1} {β : Type u_2} (l : List α) (f : β → α → β) (b : β)
Goal: List.foldl f b l.reverse = List.foldr (fun x y => f y x) b l
-- List.foldr_reverse
@[simp] theorem foldr_reverse (l : List α) (f : α → β → β) (b) :
    l.reverse.foldr f b = l.foldl (fun x y => f y x) b 
Arguments: {α : Type u_1} {β : Type u_2} (l : List α) (f : α → β → β) (b : β)
Goal: List.foldr f b l.reverse = List.foldl (fun x y => f y x) b l
-- List.reverse_replicate
@[simp] theorem reverse_replicate (n) (a : α) : reverse (replicate n a) = replicate n a 
Arguments: {α : Type u_1} (n : Nat) (a : α)
Goal: (List.replicate n a).reverse = List.replicate n a
-- List.elem_cons_self
@[simp] theorem elem_cons_self [BEq α] [LawfulBEq α] {a : α} : (a::as).elem a = true 
Arguments: {α : Type u_1} {as : List α} [BEq α] [LawfulBEq α] {a : α}
Goal: List.elem a (a :: as) = true
-- List.contains_cons
@[simp] theorem contains_cons [BEq α] :
    (a :: as : List α).contains x = (x == a || as.contains x) 
Arguments: {α : Type u_1} {a : α} {as : List α} {x : α} [BEq α]
Goal: (a :: as).contains x = (x == a || as.contains x)
-- List.contains_eq_any_beq
theorem contains_eq_any_beq [BEq α] (l : List α) (a : α) : l.contains a = l.any (a == ·) 
Arguments: {α : Type u_1} [BEq α] (l : List α) (a : α)
Goal: l.contains a = l.any fun x => a == x
-- List.take_append_drop
@[simp] theorem take_append_drop : ∀ (n : Nat) (l : List α), take n l ++ drop n l = l
  
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.take n l ++ List.drop n l = l
-- List.length_drop
@[simp] theorem length_drop : ∀ (i : Nat) (l : List α), length (drop i l) = length l - i
  
Arguments: {α : Type u_1} (i : Nat) (l : List α)
Goal: (List.drop i l).length = l.length - i
-- List.drop_length_le
theorem drop_length_le {l : List α} (h : l.length ≤ i) : drop i l = [] 
Arguments: {α : Type u_1} {i : Nat} {l : List α} (h : l.length ≤ i)
Goal: List.drop i l = []
-- List.take_length_le
theorem take_length_le {l : List α} (h : l.length ≤ i) : take i l = l 
Arguments: {α : Type u_1} {i : Nat} {l : List α} (h : l.length ≤ i)
Goal: List.take i l = l
-- List.drop_length
@[simp] theorem drop_length (l : List α) : drop l.length l = [] 
Arguments: {α : Type u_1} (l : List α)
Goal: List.drop l.length l = []
-- List.take_length
@[simp] theorem take_length (l : List α) : take l.length l = l 
Arguments: {α : Type u_1} (l : List α)
Goal: List.take l.length l = l
-- List.take_concat_get
theorem take_concat_get (l : List α) (i : Nat) (h : i < l.length) :
    (l.take i).concat l[i] = l.take (i+1) 
Arguments: {α : Type u_1} (l : List α) (i : Nat) (h : i < l.length)
Goal: (List.take i l).concat l[i] = List.take (i + 1) l
-- List.reverse_concat
theorem reverse_concat (l : List α) (a : α) : (l.concat a).reverse = a :: l.reverse 
Arguments: {α : Type u_1} (l : List α) (a : α)
Goal: (l.concat a).reverse = a :: l.reverse
-- List.take_all_of_le
theorem take_all_of_le {n} {l : List α} (h : length l ≤ n) : take n l = l 
Arguments: {α : Type u_1} {n : Nat} {l : List α} (h : l.length ≤ n)
Goal: List.take n l = l
-- List.take_left
@[simp]
theorem take_left : ∀ l₁ l₂ : List α, take (length l₁) (l₁ ++ l₂) = l₁
  
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: List.take l₁.length (l₁ ++ l₂) = l₁
-- List.take_left'
theorem take_left' {l₁ l₂ : List α} {n} (h : length l₁ = n) : take n (l₁ ++ l₂) = l₁ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h : l₁.length = n)
Goal: List.take n (l₁ ++ l₂) = l₁
-- List.map_take
@[simp] theorem map_take (f : α → β) :
    ∀ (L : List α) (i : Nat), (L.take i).map f = (L.map f).take i
  
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (L : List α) (i : Nat)
Goal: List.map f (List.take i L) = List.take i (List.map f L)
-- List.getElem?_take
theorem getElem?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m]? = l[m]? 
Arguments: {α : Type u_1} {l : List α} {n m : Nat} (h : m < n)
Goal: (List.take n l)[m]? = l[m]?
-- List.get?_take
@[deprecated getElem?_take (since := "2024-06-12")]
theorem get?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n).get? m = l.get? m 
Arguments: {α : Type u_1} {l : List α} {n m : Nat} (h : m < n)
Goal: (List.take n l).get? m = l.get? m
-- List.get?_take_of_succ
@[simp]
theorem get?_take_of_succ {l : List α} {n : Nat} : (l.take (n + 1))[n]? = l[n]? 
Arguments: {α : Type u_1} {l : List α} {n : Nat}
Goal: (List.take (n + 1) l)[n]? = l[n]?
-- List.take_succ
theorem take_succ {l : List α} {n : Nat} : l.take (n + 1) = l.take n ++ l[n]?.toList 
Arguments: {α : Type u_1} {l : List α} {n : Nat}
Goal: List.take (n + 1) l = List.take n l ++ l[n]?.toList
-- List.take_eq_nil_iff
@[simp]
theorem take_eq_nil_iff {l : List α} {k : Nat} : l.take k = [] ↔ l = [] ∨ k = 0 
Arguments: {α : Type u_1} {l : List α} {k : Nat}
Goal: List.take k l = [] ↔ l = [] ∨ k = 0
-- List.take_eq_nil_of_eq_nil
theorem take_eq_nil_of_eq_nil : ∀ {as : List α} {i}, as = [] → as.take i = []
  
Arguments: {α : Type u_1} {as : List α} {i : Nat}
Goal: as = [] → List.take i as = []
-- List.ne_nil_of_take_ne_nil
theorem ne_nil_of_take_ne_nil {as : List α} {i : Nat} (h: as.take i ≠ []) : as ≠ [] 
Arguments: {α : Type u_1} {as : List α} {i : Nat} (h : List.take i as ≠ [])
Goal: as ≠ []
-- List.dropLast_eq_take
theorem dropLast_eq_take (l : List α) : l.dropLast = l.take l.length.pred 
Arguments: {α : Type u_1} (l : List α)
Goal: l.dropLast = List.take l.length.pred l
-- List.drop_eq_nil_iff_le
@[simp]
theorem drop_eq_nil_iff_le {l : List α} {k : Nat} : l.drop k = [] ↔ l.length ≤ k 
Arguments: {α : Type u_1} {l : List α} {k : Nat}
Goal: List.drop k l = [] ↔ l.length ≤ k
-- List.drop_sizeOf_le
theorem drop_sizeOf_le [SizeOf α] (l : List α) (n : Nat) : sizeOf (l.drop n) ≤ sizeOf l 
Arguments: {α : Type u_1} [SizeOf α] (l : List α) (n : Nat)
Goal: sizeOf (List.drop n l) ≤ sizeOf l
-- List.drop_drop
@[simp] theorem drop_drop (n : Nat) : ∀ (m) (l : List α), drop n (drop m l) = drop (n + m) l
  
Arguments: {α : Type u_1} (n m : Nat) (l : List α)
Goal: List.drop n (List.drop m l) = List.drop (n + m) l
-- List.take_drop
theorem take_drop : ∀ (m n : Nat) (l : List α), take n (drop m l) = drop m (take (m + n) l)
  
Arguments: {α : Type u_1} (m n : Nat) (l : List α)
Goal: List.take n (List.drop m l) = List.drop m (List.take (m + n) l)
-- List.map_drop
@[simp] theorem map_drop (f : α → β) :
    ∀ (L : List α) (i : Nat), (L.drop i).map f = (L.map f).drop i
  
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (L : List α) (i : Nat)
Goal: List.map f (List.drop i L) = List.drop i (List.map f L)
-- List.getElem_cons_drop
@[simp]
theorem getElem_cons_drop : ∀ (l : List α) (i : Nat) (h : i < l.length),
    l[i] :: drop (i + 1) l = drop i l
  
Arguments: {α : Type u_1} (l : List α) (i : Nat) (h : i < l.length)
Goal: l[i] :: List.drop (i + 1) l = List.drop i l
-- List.get_cons_drop
@[deprecated getElem_cons_drop (since := "2024-06-12")]
theorem get_cons_drop (l : List α) (i) : get l i :: drop (i + 1) l = drop i l 
Arguments: {α : Type u_1} (l : List α) (i : Fin l.length)
Goal: l.get i :: List.drop (↑i + 1) l = List.drop (↑i) l
-- List.drop_eq_getElem_cons
theorem drop_eq_getElem_cons {n} {l : List α} (h) : drop n l = l[n] :: drop (n + 1) l 
Arguments: {α : Type u_1} {n : Nat} {l : List α} (h : n < l.length)
Goal: List.drop n l = l[n] :: List.drop (n + 1) l