ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.drop_eq_get_cons
@[deprecated drop_eq_getElem_cons (since := "2024-06-12")]
theorem drop_eq_get_cons {n} {l : List α} (h) : drop n l = get l ⟨n, h⟩ :: drop (n + 1) l 
Arguments: {α : Type u_1} {n : Nat} {l : List α} (h : n < l.length)
Goal: List.drop n l = l.get ⟨n, h⟩ :: List.drop (n + 1) l
-- List.drop_eq_nil_of_eq_nil
theorem drop_eq_nil_of_eq_nil : ∀ {as : List α} {i}, as = [] → as.drop i = []
  
Arguments: {α : Type u_1} {as : List α} {i : Nat}
Goal: as = [] → List.drop i as = []
-- List.ne_nil_of_drop_ne_nil
theorem ne_nil_of_drop_ne_nil {as : List α} {i : Nat} (h: as.drop i ≠ []) : as ≠ [] 
Arguments: {α : Type u_1} {as : List α} {i : Nat} (h : List.drop i as ≠ [])
Goal: as ≠ []
-- List.drop_add
@[deprecated drop_drop (since := "2024-06-15")]
theorem drop_add (m n) (l : List α) : drop (m + n) l = drop m (drop n l) 
Arguments: {α : Type u_1} (m n : Nat) (l : List α)
Goal: List.drop (m + n) l = List.drop m (List.drop n l)
-- List.drop_left
@[simp]
theorem drop_left : ∀ l₁ l₂ : List α, drop (length l₁) (l₁ ++ l₂) = l₂
  
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: List.drop l₁.length (l₁ ++ l₂) = l₂
-- List.drop_left'
theorem drop_left' {l₁ l₂ : List α} {n} (h : length l₁ = n) : drop n (l₁ ++ l₂) = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h : l₁.length = n)
Goal: List.drop n (l₁ ++ l₂) = l₂
-- List.takeWhile_cons
theorem takeWhile_cons (p : α → Bool) (a : α) (l : List α) :
    (a :: l).takeWhile p = if p a then a :: l.takeWhile p else [] 
Arguments: {α : Type u_1} (p : α → Bool) (a : α) (l : List α)
Goal: List.takeWhile p (a :: l) = if p a = true then a :: List.takeWhile p l else []
-- List.dropWhile_cons
theorem dropWhile_cons :
    (x :: xs : List α).dropWhile p = if p x then xs.dropWhile p else x :: xs 
Arguments: {α : Type u_1} {x : α} {xs : List α} {p : α → Bool}
Goal: List.dropWhile p (x :: xs) = if p x = true then List.dropWhile p xs else x :: xs
-- List.takeWhile_map
theorem takeWhile_map (f : α → β) (p : β → Bool) (l : List α) :
    (l.map f).takeWhile p = (l.takeWhile (p ∘ f)).map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (p : β → Bool) (l : List α)
Goal: List.takeWhile p (List.map f l) = List.map f (List.takeWhile (p ∘ f) l)
-- List.dropWhile_map
theorem dropWhile_map (f : α → β) (p : β → Bool) (l : List α) :
    (l.map f).dropWhile p = (l.dropWhile (p ∘ f)).map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (p : β → Bool) (l : List α)
Goal: List.dropWhile p (List.map f l) = List.map f (List.dropWhile (p ∘ f) l)
-- List.takeWhile_append_dropWhile
@[simp] theorem takeWhile_append_dropWhile (p : α → Bool) :
    ∀ (l : List α), takeWhile p l ++ dropWhile p l = l
  
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.takeWhile p l ++ List.dropWhile p l = l
-- List.dropWhile_append
theorem dropWhile_append {xs ys : List α} :
    (xs ++ ys).dropWhile p =
      if (xs.dropWhile p).isEmpty then ys.dropWhile p else xs.dropWhile p ++ ys 
Arguments: {α : Type u_1} {p : α → Bool} {xs ys : List α}
Goal: List.dropWhile p (xs ++ ys) =
  if (List.dropWhile p xs).isEmpty = true then List.dropWhile p ys else List.dropWhile p xs ++ ys
-- List.takeWhile_replicate_eq_filter
@[simp] theorem takeWhile_replicate_eq_filter (p : α → Bool) :
    (replicate n a).takeWhile p = (replicate n a).filter p 
Arguments: {α : Type u_1} {n : Nat} {a : α} (p : α → Bool)
Goal: List.takeWhile p (List.replicate n a) = List.filter p (List.replicate n a)
-- List.takeWhile_replicate
theorem takeWhile_replicate (p : α → Bool) :
    (replicate n a).takeWhile p = if p a then replicate n a else [] 
Arguments: {α : Type u_1} {n : Nat} {a : α} (p : α → Bool)
Goal: List.takeWhile p (List.replicate n a) = if p a = true then List.replicate n a else []
-- List.dropWhile_replicate_eq_filter_not
@[simp] theorem dropWhile_replicate_eq_filter_not (p : α → Bool) :
    (replicate n a).dropWhile p = (replicate n a).filter (fun a => !p a) 
Arguments: {α : Type u_1} {n : Nat} {a : α} (p : α → Bool)
Goal: List.dropWhile p (List.replicate n a) = List.filter (fun a => !p a) (List.replicate n a)
-- List.dropWhile_replicate
theorem dropWhile_replicate (p : α → Bool) :
    (replicate n a).dropWhile p = if p a then [] else replicate n a 
Arguments: {α : Type u_1} {n : Nat} {a : α} (p : α → Bool)
Goal: List.dropWhile p (List.replicate n a) = if p a = true then [] else List.replicate n a
-- List.partition_eq_filter_filter.aux
@[simp] theorem partition_eq_filter_filter (p : α → Bool) (l : List α) :
    partition p l = (filter p l, filter (not ∘ p) l) 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) {as bs : List α}
Goal: List.partition.loop p l (as, bs) = (as.reverse ++ List.filter p l, bs.reverse ++ List.filter (not ∘ p) l)
-- List.partition_eq_filter_filter
@[simp] theorem partition_eq_filter_filter (p : α → Bool) (l : List α) :
    partition p l = (filter p l, filter (not ∘ p) l) 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.partition p l = (List.filter p l, List.filter (not ∘ p) l)
-- List.length_dropLast
@[simp] theorem length_dropLast : ∀ (xs : List α), xs.dropLast.length = xs.length - 1
  
Arguments: {α : Type u_1} (xs : List α)
Goal: xs.dropLast.length = xs.length - 1
-- List.getElem_dropLast
@[simp] theorem getElem_dropLast : ∀ (xs : List α) (i : Nat) (h : i < xs.dropLast.length),
    xs.dropLast[i] = xs[i]'(Nat.lt_of_lt_of_le h (length_dropLast .. ▸ Nat.pred_le _))
  
Arguments: {α : Type u_1} (xs : List α) (i : Nat) (h : i < xs.dropLast.length)
Goal: xs.dropLast[i] = xs[i]
-- List.get_dropLast
@[deprecated getElem_dropLast (since := "2024-06-12")]
theorem get_dropLast (xs : List α) (i : Fin xs.dropLast.length) :
    xs.dropLast.get i = xs.get ⟨i, Nat.lt_of_lt_of_le i.isLt (length_dropLast .. ▸ Nat.pred_le _)⟩ 
Arguments: {α : Type u_1} (xs : List α) (i : Fin xs.dropLast.length)
Goal: xs.dropLast.get i = xs.get ⟨↑i, ⋯⟩
-- List.dropLast_cons_of_ne_nil
theorem dropLast_cons_of_ne_nil {α : Type u} {x : α}
    {l : List α} (h : l ≠ []) : (x :: l).dropLast = x :: l.dropLast 
Arguments: {α : Type u} {x : α} {l : List α} (h : l ≠ [])
Goal: (x :: l).dropLast = x :: l.dropLast
-- List.dropLast_append_of_ne_nil
@[simp] theorem dropLast_append_of_ne_nil {α : Type u} {l : List α} :
    ∀ (l' : List α) (_ : l ≠ []), (l' ++ l).dropLast = l' ++ l.dropLast
  
Arguments: {α : Type u} {l : List α} (l' : List α)
Goal: l ≠ [] → (l' ++ l).dropLast = l' ++ l.dropLast
-- List.dropLast_append_cons
theorem dropLast_append_cons : dropLast (l₁ ++ b::l₂) = l₁ ++ dropLast (b::l₂) 
Goal: ∀ {α : Type u_1} {l₁ : List α} {b : α} {l₂ : List α}, (l₁ ++ b :: l₂).dropLast = l₁ ++ (b :: l₂).dropLast
-- List.dropLast_concat
@[simp 1100] theorem dropLast_concat : dropLast (l₁ ++ [b]) = l₁ 
Goal: ∀ {α : Type u_1} {l₁ : List α} {b : α}, (l₁ ++ [b]).dropLast = l₁
-- List.map_dropLast
@[simp] theorem map_dropLast (f : α → β) (l : List α) : l.dropLast.map f = (l.map f).dropLast 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: List.map f l.dropLast = (List.map f l).dropLast
-- List.dropLast_replicate
@[simp] theorem dropLast_replicate (n) (a : α) : dropLast (replicate n a) = replicate (n - 1) a 
Arguments: {α : Type u_1} (n : Nat) (a : α)
Goal: (List.replicate n a).dropLast = List.replicate (n - 1) a
-- List.dropLast_cons_self_replicate
@[simp] theorem dropLast_cons_self_replicate (n) (a : α) :
    dropLast (a :: replicate n a) = replicate n a 
Arguments: {α : Type u_1} (n : Nat) (a : α)
Goal: (a :: List.replicate n a).dropLast = List.replicate n a
-- List.isPrefixOf_cons₂_self
@[simp] theorem isPrefixOf_cons₂_self [LawfulBEq α] {a : α} :
    isPrefixOf (a::as) (a::bs) = isPrefixOf as bs 
Arguments: {α : Type u_1} [BEq α] {as bs : List α} [LawfulBEq α] {a : α}
Goal: (a :: as).isPrefixOf (a :: bs) = as.isPrefixOf bs
-- List.isPrefixOf_length_pos_nil
@[simp] theorem isPrefixOf_length_pos_nil {L : List α} (h : 0 < L.length) : isPrefixOf L [] = false 
Arguments: {α : Type u_1} [BEq α] {L : List α} (h : 0 < L.length)
Goal: L.isPrefixOf [] = false
-- List.isPrefixOf_replicate
@[simp] theorem isPrefixOf_replicate {a : α} :
    isPrefixOf l (replicate n a) = (decide (l.length ≤ n) && l.all (· == a)) 
Arguments: {α : Type u_1} [BEq α] {l : List α} {n : Nat} {a : α}
Goal: l.isPrefixOf (List.replicate n a) = (decide (l.length ≤ n) && l.all fun x => x == a)
-- List.isSuffixOf_cons_nil
@[simp] theorem isSuffixOf_cons_nil : isSuffixOf (a::as) ([] : List α) = false 
Arguments: {α : Type u_1} [BEq α] {a : α} {as : List α}
Goal: (a :: as).isSuffixOf [] = false
-- List.isSuffixOf_replicate
@[simp] theorem isSuffixOf_replicate {a : α} :
    isSuffixOf l (replicate n a) = (decide (l.length ≤ n) && l.all (· == a)) 
Arguments: {α : Type u_1} [BEq α] {l : List α} {n : Nat} {a : α}
Goal: l.isSuffixOf (List.replicate n a) = (decide (l.length ≤ n) && l.all fun x => x == a)
-- List.rotateLeft_zero
@[simp] theorem rotateLeft_zero (l : List α) : rotateLeft l 0 = l 
Arguments: {α : Type u_1} (l : List α)
Goal: l.rotateLeft 0 = l
-- List.rotateRight_zero
@[simp] theorem rotateRight_zero (l : List α) : rotateRight l 0 = l 
Arguments: {α : Type u_1} (l : List α)
Goal: l.rotateRight 0 = l
-- List.replace_cons_self
@[simp] theorem replace_cons_self [LawfulBEq α] {a : α} : (a::as).replace a b = b::as 
Arguments: {α : Type u_1} [BEq α] {as : List α} {b : α} [LawfulBEq α] {a : α}
Goal: (a :: as).replace a b = b :: as
-- List.replace_of_not_mem
@[simp] theorem replace_of_not_mem {l : List α} (h : !l.elem a) : l.replace a b = l 
Arguments: {α : Type u_1} [BEq α] {a b : α} {l : List α} (h : (!List.elem a l) = true)
Goal: l.replace a b = l
-- List.replace_replicate_self
@[simp] theorem replace_replicate_self [LawfulBEq α] {a : α} (h : 0 < n) :
    (replicate n a).replace a b = b :: replicate (n - 1) a 
Arguments: {α : Type u_1} [BEq α] {n : Nat} {b : α} [LawfulBEq α] {a : α} (h : 0 < n)
Goal: (List.replicate n a).replace a b = b :: List.replicate (n - 1) a
-- List.replace_replicate_ne
@[simp] theorem replace_replicate_ne {a b c : α} (h : !b == a) :
    (replicate n a).replace b c = replicate n a 
Arguments: {α : Type u_1} [BEq α] {n : Nat} {a b c : α} (h : (!b == a) = true)
Goal: (List.replicate n a).replace b c = List.replicate n a
-- List.insert_nil
@[simp] theorem insert_nil (a : α) : [].insert a = [a] 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a : α)
Goal: List.insert a [] = [a]
-- List.insert_of_mem
@[simp] theorem insert_of_mem {l : List α} (h : a ∈ l) : l.insert a = l 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l : List α} (h : a ∈ l)
Goal: List.insert a l = l
-- List.insert_of_not_mem
@[simp] theorem insert_of_not_mem {l : List α} (h : a ∉ l) : l.insert a = a :: l 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l : List α} (h : ¬a ∈ l)
Goal: List.insert a l = a :: l
-- List.mem_insert_iff
@[simp] theorem mem_insert_iff {l : List α} : a ∈ l.insert b ↔ a = b ∨ a ∈ l 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α} {l : List α}
Goal: a ∈ List.insert b l ↔ a = b ∨ a ∈ l
-- List.mem_insert_self
@[simp 1100] theorem mem_insert_self (a : α) (l : List α) : a ∈ l.insert a 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a : α) (l : List α)
Goal: a ∈ List.insert a l
-- List.mem_insert_of_mem
theorem mem_insert_of_mem {l : List α} (h : a ∈ l) : a ∈ l.insert b 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α} {l : List α} (h : a ∈ l)
Goal: a ∈ List.insert b l
-- List.eq_or_mem_of_mem_insert
theorem eq_or_mem_of_mem_insert {l : List α} (h : a ∈ l.insert b) : a = b ∨ a ∈ l 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α} {l : List α} (h : a ∈ List.insert b l)
Goal: a = b ∨ a ∈ l
-- List.length_insert_of_mem
@[simp] theorem length_insert_of_mem {l : List α} (h : a ∈ l) :
    length (l.insert a) = length l 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l : List α} (h : a ∈ l)
Goal: (List.insert a l).length = l.length
-- List.length_insert_of_not_mem
@[simp] theorem length_insert_of_not_mem {l : List α} (h : a ∉ l) :
    length (l.insert a) = length l + 1 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l : List α} (h : ¬a ∈ l)
Goal: (List.insert a l).length = l.length + 1
-- List.insert_replicate_self
@[simp] theorem insert_replicate_self {a : α} (h : 0 < n) : (replicate n a).insert a = replicate n a 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {n : Nat} {a : α} (h : 0 < n)
Goal: List.insert a (List.replicate n a) = List.replicate n a
-- List.insert_replicate_ne
@[simp] theorem insert_replicate_ne {a b : α} (h : !b == a) :
    (replicate n a).insert b = b :: replicate n a 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {n : Nat} {a b : α} (h : (!b == a) = true)
Goal: List.insert b (List.replicate n a) = b :: List.replicate n a
-- List.erase_cons_head
@[simp] theorem erase_cons_head [LawfulBEq α] (a : α) (l : List α) : (a :: l).erase a = l 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a : α) (l : List α)
Goal: (a :: l).erase a = l
-- List.erase_cons_tail
@[simp] theorem erase_cons_tail {a b : α} (l : List α) (h : ¬(b == a)) :
    (b :: l).erase a = b :: l.erase a 
Arguments: {α : Type u_1} [BEq α] {a b : α} (l : List α) (h : ¬(b == a) = true)
Goal: (b :: l).erase a = b :: l.erase a
-- List.erase_of_not_mem
theorem erase_of_not_mem [LawfulBEq α] {a : α} : ∀ {l : List α}, a ∉ l → l.erase a = l
  
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l : List α}
Goal: ¬a ∈ l → l.erase a = l
-- List.erase_replicate_self
@[simp] theorem erase_replicate_self [LawfulBEq α] {a : α} :
    (replicate n a).erase a = replicate (n - 1) a 
Arguments: {α : Type u_1} [BEq α] {n : Nat} [LawfulBEq α] {a : α}
Goal: (List.replicate n a).erase a = List.replicate (n - 1) a
-- List.erase_replicate_ne
@[simp] theorem erase_replicate_ne [LawfulBEq α] {a b : α} (h : !b == a) :
    (replicate n a).erase b = replicate n a 
Arguments: {α : Type u_1} [BEq α] {n : Nat} [LawfulBEq α] {a b : α} (h : (!b == a) = true)
Goal: (List.replicate n a).erase b = List.replicate n a
-- List.find?_cons_of_pos
@[simp] theorem find?_cons_of_pos (l) (h : p a) : find? p (a :: l) = some a 
Goal: ∀ {α : Type u_1} {p : α → Bool} {a : α} (l : List α), p a = true → List.find? p (a :: l) = some a
-- List.find?_cons_of_neg
@[simp] theorem find?_cons_of_neg (l) (h : ¬p a) : find? p (a :: l) = find? p l 
Goal: ∀ {α : Type u_1} {p : α → Bool} {a : α} (l : List α), ¬p a = true → List.find? p (a :: l) = List.find? p l
-- List.find?_eq_none
@[simp] theorem find?_eq_none : find? p l = none ↔ ∀ x ∈ l, ¬ p x 
Goal: ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.find? p l = none ↔ ∀ (x : α), x ∈ l → ¬p x = true
-- List.find?_some
theorem find?_some : ∀ {l}, find? p l = some a → p a
  
Goal: ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, List.find? p l = some a → p a = true
-- List.mem_of_find?_eq_some
@[simp] theorem mem_of_find?_eq_some : ∀ {l}, find? p l = some a → a ∈ l
  
Goal: ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, List.find? p l = some a → a ∈ l
-- List.find?_map
@[simp] theorem find?_map (f : β → α) (l : List β) : find? p (l.map f) = (l.find? (p ∘ f)).map f 
Arguments: {β : Type u_1} {α : Type u_2} {p : α → Bool} (f : β → α) (l : List β)
Goal: List.find? p (List.map f l) = Option.map f (List.find? (p ∘ f) l)
-- List.find?_replicate
theorem find?_replicate : find? p (replicate n a) = if n = 0 then none else if p a then some a else none 
Goal: ∀ {α : Type u_1} {p : α → Bool} {n : Nat} {a : α},
  List.find? p (List.replicate n a) = if n = 0 then none else if p a = true then some a else none
-- List.find?_replicate_of_length_pos
@[simp] theorem find?_replicate_of_length_pos (h : 0 < n) : find? p (replicate n a) = if p a then some a else none 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {p : α → Bool} {a : α}, 0 < n → List.find? p (List.replicate n a) = if p a = true then some a else none
-- List.find?_replicate_of_pos
@[simp] theorem find?_replicate_of_pos (h : p a) : find? p (replicate n a) = if n = 0 then none else some a 
Goal: ∀ {α : Type u_1} {p : α → Bool} {n : Nat} {a : α},
  p a = true → List.find? p (List.replicate n a) = if n = 0 then none else some a
-- List.find?_replicate_of_neg
@[simp] theorem find?_replicate_of_neg (h : ¬ p a) : find? p (replicate n a) = none 
Goal: ∀ {α : Type u_1} {p : α → Bool} {n : Nat} {a : α}, ¬p a = true → List.find? p (List.replicate n a) = none
-- List.findSome?_cons_of_isSome
@[simp] theorem findSome?_cons_of_isSome (l) (h : (f a).isSome) : findSome? f (a :: l) = f a 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {a : α} (l : List α),
  (f a).isSome = true → List.findSome? f (a :: l) = f a
-- List.findSome?_cons_of_isNone
@[simp] theorem findSome?_cons_of_isNone (l) (h : (f a).isNone) : findSome? f (a :: l) = findSome? f l 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {a : α} (l : List α),
  (f a).isNone = true → List.findSome? f (a :: l) = List.findSome? f l
-- List.exists_of_findSome?_eq_some
theorem exists_of_findSome?_eq_some {l : List α} {f : α → Option β} (w : l.findSome? f = some b) :
    ∃ a, a ∈ l ∧ f a = b 
Arguments: {α : Type u_1} {β : Type u_2} {b : β} {l : List α} {f : α → Option β} (w : List.findSome? f l = some b)
Goal: ∃ a, a ∈ l ∧ f a = some b
-- List.findSome?_map
@[simp] theorem findSome?_map (f : β → γ) (l : List β) : findSome? p (l.map f) = l.findSome? (p ∘ f) 
Arguments: {β : Type u_1} {γ : Type u_2}
Goal: ∀ {α : Type u_3} {p : γ → Option α} (f : β → γ) (l : List β), List.findSome? p (List.map f l) = List.findSome? (p ∘ f) l
-- List.findSome?_replicate
theorem findSome?_replicate : findSome? f (replicate n a) = if n = 0 then none else f a 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {n : Nat} {a : α},
  List.findSome? f (List.replicate n a) = if n = 0 then none else f a
-- List.findSome?_replicate_of_pos
@[simp] theorem findSome?_replicate_of_pos (h : 0 < n) : findSome? f (replicate n a) = f a 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {a : α}, 0 < n → List.findSome? f (List.replicate n a) = f a
-- List.find?_replicate_of_isSome
@[simp] theorem find?_replicate_of_isSome (h : (f a).isSome) : findSome? f (replicate n a) = if n = 0 then none else f a 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {n : Nat} {a : α},
  (f a).isSome = true → List.findSome? f (List.replicate n a) = if n = 0 then none else f a
-- List.find?_replicate_of_isNone
@[simp] theorem find?_replicate_of_isNone (h : (f a).isNone) : findSome? f (replicate n a) = none 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {n : Nat} {a : α},
  (f a).isNone = true → List.findSome? f (List.replicate n a) = none
-- List.lookup_cons_self
@[simp] theorem lookup_cons_self  {k : α} : ((k,b)::es).lookup k = some b 
Arguments: {α : Type u_2} [BEq α] [LawfulBEq α]
Goal: ∀ {β : Type u_1} {b : β} {es : List (α × β)} {k : α}, List.lookup k ((k, b) :: es) = some b
-- List.lookup_replicate
theorem lookup_replicate {k : α} :
    (replicate n (a,b)).lookup k = if n = 0 then none else if k == a then some b else none 
Arguments: {α : Type u_2} [BEq α] [LawfulBEq α] {n : Nat} {a : α}
Goal: ∀ {α_1 : Type u_1} {b : α_1} {k : α},
  List.lookup k (List.replicate n (a, b)) = if n = 0 then none else if (k == a) = true then some b else none
-- List.lookup_replicate_of_pos
theorem lookup_replicate_of_pos {k : α} (h : 0 < n) :
    (replicate n (a,b)).lookup k = if k == a then some b else none 
Arguments: {α : Type u_2} [BEq α] [LawfulBEq α] {n : Nat} {a : α}
Goal: ∀ {α_1 : Type u_1} {b : α_1} {k : α},
  0 < n → List.lookup k (List.replicate n (a, b)) = if (k == a) = true then some b else none
-- List.lookup_replicate_self
theorem lookup_replicate_self {a : α} :
    (replicate n (a, b)).lookup a = if n = 0 then none else some b 
Arguments: {α : Type u_2} [BEq α] [LawfulBEq α] {n : Nat}
Goal: ∀ {α_1 : Type u_1} {b : α_1} {a : α}, List.lookup a (List.replicate n (a, b)) = if n = 0 then none else some b
-- List.lookup_replicate_self_of_pos
@[simp] theorem lookup_replicate_self_of_pos {a : α} (h : 0 < n) :
    (replicate n (a, b)).lookup a = some b 
Arguments: {α : Type u_2} [BEq α] [LawfulBEq α] {n : Nat}
Goal: ∀ {α_1 : Type u_1} {b : α_1} {a : α}, 0 < n → List.lookup a (List.replicate n (a, b)) = some b
-- List.lookup_replicate_ne
@[simp] theorem lookup_replicate_ne {k : α} (h : !k == a) :
    (replicate n (a,b)).lookup k = none 
Arguments: {α : Type u_2} [BEq α] [LawfulBEq α] {a : α} {n : Nat}
Goal: ∀ {α_1 : Type u_1} {b : α_1} {k : α}, (!k == a) = true → List.lookup k (List.replicate n (a, b)) = none
-- List.not_any_eq_all_not
theorem not_any_eq_all_not (l : List α) (p : α → Bool) : (!l.any p) = l.all fun a => !p a 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool)
Goal: (!l.any p) = l.all fun a => !p a
-- List.not_all_eq_any_not
theorem not_all_eq_any_not (l : List α) (p : α → Bool) : (!l.all p) = l.any fun a => !p a 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool)
Goal: (!l.all p) = l.any fun a => !p a
-- List.and_any_distrib_left
theorem and_any_distrib_left (l : List α) (p : α → Bool) (q : Bool) :
    (q && l.any p) = l.any fun a => q && p a 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool) (q : Bool)
Goal: (q && l.any p) = l.any fun a => q && p a
-- List.and_any_distrib_right
theorem and_any_distrib_right (l : List α) (p : α → Bool) (q : Bool) :
    (l.any p && q) = l.any fun a => p a && q 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool) (q : Bool)
Goal: (l.any p && q) = l.any fun a => p a && q
-- List.or_all_distrib_left
theorem or_all_distrib_left (l : List α) (p : α → Bool) (q : Bool) :
    (q || l.all p) = l.all fun a => q || p a 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool) (q : Bool)
Goal: (q || l.all p) = l.all fun a => q || p a
-- List.or_all_distrib_right
theorem or_all_distrib_right (l : List α) (p : α → Bool) (q : Bool) :
    (l.all p || q) = l.all fun a => p a || q 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool) (q : Bool)
Goal: (l.all p || q) = l.all fun a => p a || q
-- List.any_eq_not_all_not
theorem any_eq_not_all_not (l : List α) (p : α → Bool) : l.any p = !l.all (!p .) 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool)
Goal: l.any p = !l.all fun x => !p x
-- List.all_eq_not_any_not
theorem all_eq_not_any_not (l : List α) (p : α → Bool) : l.all p = !l.any (!p .) 
Arguments: {α : Type u_1} (l : List α) (p : α → Bool)
Goal: l.all p = !l.any fun x => !p x
-- List.any_map
theorem any_map (f : α → β) (l : List α) (p : β → Bool) : (l.map f).any p = l.any (p ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) (p : β → Bool)
Goal: (List.map f l).any p = l.any (p ∘ f)
-- List.all_map
theorem all_map (f : α → β) (l : List α) (p : β → Bool) : (l.map f).all p = l.all (p ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) (p : β → Bool)
Goal: (List.map f l).all p = l.all (p ∘ f)
-- List.zip_map
theorem zip_map (f : α → γ) (g : β → δ) :
    ∀ (l₁ : List α) (l₂ : List β), zip (l₁.map f) (l₂.map g) = (zip l₁ l₂).map (Prod.map f g)
  
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} {δ : Type u_4} (f : α → γ) (g : β → δ) (l₁ : List α) (l₂ : List β)
Goal: (List.map f l₁).zip (List.map g l₂) = List.map (Prod.map f g) (l₁.zip l₂)
-- List.zip_map_left
theorem zip_map_left (f : α → γ) (l₁ : List α) (l₂ : List β) :
    zip (l₁.map f) l₂ = (zip l₁ l₂).map (Prod.map f id) 
Arguments: {α : Type u_1} {γ : Type u_2} {β : Type u_3} (f : α → γ) (l₁ : List α) (l₂ : List β)
Goal: (List.map f l₁).zip l₂ = List.map (Prod.map f id) (l₁.zip l₂)
-- List.zip_map_right
theorem zip_map_right (f : β → γ) (l₁ : List α) (l₂ : List β) :
    zip l₁ (l₂.map f) = (zip l₁ l₂).map (Prod.map id f) 
Arguments: {β : Type u_1} {γ : Type u_2} {α : Type u_3} (f : β → γ) (l₁ : List α) (l₂ : List β)
Goal: l₁.zip (List.map f l₂) = List.map (Prod.map id f) (l₁.zip l₂)
-- List.zip_append
theorem zip_append :
    ∀ {l₁ r₁ : List α} {l₂ r₂ : List β} (_h : length l₁ = length l₂),
      zip (l₁ ++ r₁) (l₂ ++ r₂) = zip l₁ l₂ ++ zip r₁ r₂
  
Arguments: {α : Type u_1} {β : Type u_2} {l₁ r₁ : List α} {l₂ r₂ : List β} (_h : l₁.length = l₂.length)
Goal: (l₁ ++ r₁).zip (l₂ ++ r₂) = l₁.zip l₂ ++ r₁.zip r₂
-- List.zip_map'
theorem zip_map' (f : α → β) (g : α → γ) :
    ∀ l : List α, zip (l.map f) (l.map g) = l.map fun a => (f a, g a)
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : α → γ) (l : List α)
Goal: (List.map f l).zip (List.map g l) = List.map (fun a => (f a, g a)) l