ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.map_nil
@[simp] theorem map_nil {f : α → β} : map f [] = [] 
Arguments: {α : Type u} {β : Type v} {f : α → β}
Goal: List.map f List.nil = List.nil
-- List.map_cons
@[simp] theorem map_cons (f : α → β) a l : map f (a :: l) = f a :: map f l 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α) (l : List α)
Goal: List.map f (a :: l) = f a :: List.map f l
-- List.filter_nil
@[simp] theorem filter_nil (p : α → Bool) : filter p [] = [] 
Arguments: {α : Type u} (p : α → Bool)
Goal: List.filter p List.nil = List.nil
-- List.filterMap_nil
@[simp] theorem filterMap_nil (f : α → Option β) : filterMap f [] = [] 
Arguments: {α : Type u} {β : Type v} (f : α → Option β)
Goal: List.filterMap f List.nil = List.nil
-- List.filterMap_cons
theorem filterMap_cons (f : α → Option β) (a : α) (l : List α) :
    filterMap f (a :: l) =
      match f a with
      | none => filterMap f l
      | some b => b :: filterMap f l 
Arguments: {α : Type u} {β : Type v} (f : α → Option β) (a : α) (l : List α)
Goal: List.filterMap f (a :: l) =
  match f a with
  | none => List.filterMap f l
  | some b => b :: List.filterMap f l
-- List.foldr_nil
@[simp] theorem foldr_nil : [].foldr f b = b 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → α_1 → α_1} {b : α_1}, List.foldr f b List.nil = b
-- List.foldr_cons
@[simp] theorem foldr_cons (l : List α) : (a :: l).foldr f b = f a (l.foldr f b) 
Arguments: {α : Type u} {a : α}
Goal: ∀ {α_1 : Type u_1} {f : α → α_1 → α_1} {b : α_1} (l : List α), List.foldr f b (a :: l) = f a (List.foldr f b l)
-- List.reverseAux_nil
@[simp] theorem reverseAux_nil : reverseAux [] r = r 
Goal: ∀ {α : Type u_1} {r : List α}, List.nil.reverseAux r = r
-- List.reverseAux_cons
@[simp] theorem reverseAux_cons : reverseAux (a::l) r = reverseAux l (a::r) 
Goal: ∀ {α : Type u_1} {a : α} {l r : List α}, (a :: l).reverseAux r = l.reverseAux (a :: r)
-- List.reverse_nil
@[simp] theorem reverse_nil : reverse ([] : List α) = [] 
Arguments: {α : Type u}
Goal: List.nil.reverse = List.nil
-- List.reverseAux_reverseAux
theorem reverseAux_reverseAux (as bs cs : List α) : reverseAux (reverseAux as bs) cs = reverseAux bs (reverseAux (reverseAux as []) cs) 
Arguments: {α : Type u} (as bs cs : List α)
Goal: (as.reverseAux bs).reverseAux cs = bs.reverseAux ((as.reverseAux List.nil).reverseAux cs)
-- List.append_eq_appendTR
@[csimp] theorem append_eq_appendTR : @List.append = @appendTR 
Goal: @List.append = @List.appendTR
-- List.append_eq
@[simp] theorem append_eq (as bs : List α) : List.append as bs = as ++ bs 
Arguments: {α : Type u} (as bs : List α)
Goal: as.append bs = as ++ bs
-- List.nil_append
@[simp] theorem nil_append (as : List α) : [] ++ as = as 
Arguments: {α : Type u} (as : List α)
Goal: List.nil ++ as = as
-- List.cons_append
@[simp] theorem cons_append (a : α) (as bs : List α) : (a::as) ++ bs = a::(as ++ bs) 
Arguments: {α : Type u} (a : α) (as bs : List α)
Goal: a :: as ++ bs = a :: (as ++ bs)
-- List.append_nil
@[simp] theorem append_nil (as : List α) : as ++ [] = as 
Arguments: {α : Type u} (as : List α)
Goal: as ++ List.nil = as
-- List.length_append
@[simp] theorem length_append (as bs : List α) : (as ++ bs).length = as.length + bs.length 
Arguments: {α : Type u} (as bs : List α)
Goal: (as ++ bs).length = as.length + bs.length
-- List.append_assoc
@[simp] theorem append_assoc (as bs cs : List α) : (as ++ bs) ++ cs = as ++ (bs ++ cs) 
Arguments: {α : Type u} (as bs cs : List α)
Goal: as ++ bs ++ cs = as ++ (bs ++ cs)
-- List.append_cons
theorem append_cons (as : List α) (b : α) (bs : List α) : as ++ b :: bs = as ++ [b] ++ bs 
Arguments: {α : Type u} (as : List α) (b : α) (bs : List α)
Goal: as ++ b :: bs = as ++ b :: List.nil ++ bs
-- List.concat_eq_append
@[simp] theorem concat_eq_append (as : List α) (a : α) : as.concat a = as ++ [a] 
Arguments: {α : Type u} (as : List α) (a : α)
Goal: as.concat a = as ++ a :: List.nil
-- List.reverseAux_eq_append
theorem reverseAux_eq_append (as bs : List α) : reverseAux as bs = reverseAux as [] ++ bs 
Arguments: {α : Type u} (as bs : List α)
Goal: as.reverseAux bs = as.reverseAux List.nil ++ bs
-- List.reverse_cons
@[simp] theorem reverse_cons (a : α) (as : List α) : reverse (a :: as) = reverse as ++ [a] 
Arguments: {α : Type u} (a : α) (as : List α)
Goal: (a :: as).reverse = as.reverse ++ a :: List.nil
-- List.join_nil
@[simp] theorem join_nil : List.join ([] : List (List α)) = [] 
Arguments: {α : Type u}
Goal: List.nil.join = List.nil
-- List.join_cons
@[simp] theorem join_cons : (l :: ls).join = l ++ ls.join 
Goal: ∀ {α : Type u_1} {l : List α} {ls : List (List α)}, (l :: ls).join = l ++ ls.join
-- List.bind_nil
@[simp] theorem bind_nil (f : α → List β) : List.bind [] f = [] 
Arguments: {α : Type u} {β : Type v} (f : α → List β)
Goal: List.nil.bind f = List.nil
-- List.bind_cons
@[simp] theorem bind_cons x xs (f : α → List β) :
  List.bind (x :: xs) f = f x ++ List.bind xs f 
Arguments: {α : Type u} {β : Type v} (x : α) (xs : List α) (f : α → List β)
Goal: (x :: xs).bind f = f x ++ xs.bind f
-- List.replicate_zero
@[simp] theorem replicate_zero : replicate 0 a = [] 
Goal: ∀ {α : Type u_1} {a : α}, List.replicate 0 a = List.nil
-- List.replicate_succ
theorem replicate_succ (a : α) (n) : replicate (n+1) a = a :: replicate n a 
Arguments: {α : Type u} (a : α) (n : Nat)
Goal: List.replicate (n + 1) a = a :: List.replicate n a
-- List.length_replicate
@[simp] theorem length_replicate (n : Nat) (a : α) : (replicate n a).length = n 
Arguments: {α : Type u} (n : Nat) (a : α)
Goal: (List.replicate n a).length = n
-- List.empty_eq
@[simp] theorem empty_eq : (∅ : List α) = [] 
Arguments: {α : Type u}
Goal: ∅ = List.nil
-- List.isEmpty_nil
@[simp] theorem isEmpty_nil : ([] : List α).isEmpty = true 
Arguments: {α : Type u}
Goal: List.nil.isEmpty = true
-- List.isEmpty_cons
@[simp] theorem isEmpty_cons : (x :: xs : List α).isEmpty = false 
Arguments: {α : Type u} {x : α} {xs : List α}
Goal: (x :: xs).isEmpty = false
-- List.elem_nil
@[simp] theorem elem_nil [BEq α] : ([] : List α).elem a = false 
Arguments: {α : Type u} {a : α} [BEq α]
Goal: List.elem a List.nil = false
-- List.elem_cons
theorem elem_cons [BEq α] {a : α} :
    (b::bs).elem a = match a == b with | true => true | false => bs.elem a 
Arguments: {α : Type u} {b : α} {bs : List α} [BEq α] {a : α}
Goal: List.elem a (b :: bs) =
  match a == b with
  | true => true
  | false => List.elem a bs
-- List.contains_nil
@[simp] theorem contains_nil [BEq α] : ([] : List α).contains a = false 
Arguments: {α : Type u} {a : α} [BEq α]
Goal: List.nil.contains a = false
-- List.mem_of_elem_eq_true
theorem mem_of_elem_eq_true [BEq α] [LawfulBEq α] {a : α} {as : List α} : elem a as = true → a ∈ as 
Arguments: {α : Type u} [BEq α] [LawfulBEq α] {a : α} {as : List α}
Goal: List.elem a as = true → a ∈ as
-- List.elem_eq_true_of_mem
theorem elem_eq_true_of_mem [BEq α] [LawfulBEq α] {a : α} {as : List α} (h : a ∈ as) : elem a as = true 
Arguments: {α : Type u} [BEq α] [LawfulBEq α] {a : α} {as : List α} (h : a ∈ as)
Goal: List.elem a as = true
-- List.mem_append_of_mem_left
theorem mem_append_of_mem_left {a : α} {as : List α} (bs : List α) : a ∈ as → a ∈ as ++ bs 
Arguments: {α : Type u} {a : α} {as : List α} (bs : List α)
Goal: a ∈ as → a ∈ as ++ bs
-- List.mem_append_of_mem_right
theorem mem_append_of_mem_right {b : α} {bs : List α} (as : List α) : b ∈ bs → b ∈ as ++ bs 
Arguments: {α : Type u} {b : α} {bs : List α} (as : List α)
Goal: b ∈ bs → b ∈ as ++ bs
-- List.take_nil
@[simp] theorem take_nil : ([] : List α).take i = [] 
Arguments: {α : Type u} {i : Nat}
Goal: List.take i List.nil = List.nil
-- List.take_zero
@[simp] theorem take_zero (l : List α) : l.take 0 = [] 
Arguments: {α : Type u} (l : List α)
Goal: List.take 0 l = List.nil
-- List.take_cons_succ
@[simp] theorem take_cons_succ : (a::as).take (i+1) = a :: as.take i 
Goal: ∀ {α : Type u_1} {a : α} {as : List α} {i : Nat}, List.take (i + 1) (a :: as) = a :: List.take i as
-- List.drop_nil
@[simp] theorem drop_nil : ([] : List α).drop i = [] 
Arguments: {α : Type u} {i : Nat}
Goal: List.drop i List.nil = List.nil
-- List.drop_zero
@[simp] theorem drop_zero (l : List α) : l.drop 0 = l 
Arguments: {α : Type u} (l : List α)
Goal: List.drop 0 l = l
-- List.drop_succ_cons
@[simp] theorem drop_succ_cons : (a :: l).drop (n + 1) = l.drop n 
Goal: ∀ {α : Type u_1} {a : α} {l : List α} {n : Nat}, List.drop (n + 1) (a :: l) = List.drop n l
-- List.drop_eq_nil_of_le
theorem drop_eq_nil_of_le {as : List α} {i : Nat} (h : as.length ≤ i) : as.drop i = [] 
Arguments: {α : Type u} {as : List α} {i : Nat} (h : as.length ≤ i)
Goal: List.drop i as = List.nil
-- List.takeWhile_nil
@[simp] theorem takeWhile_nil : ([] : List α).takeWhile p = [] 
Arguments: {α : Type u} {p : α → Bool}
Goal: List.takeWhile p List.nil = List.nil
-- List.dropWhile_nil
@[simp] theorem dropWhile_nil : ([] : List α).dropWhile p = [] 
Arguments: {α : Type u} {p : α → Bool}
Goal: List.dropWhile p List.nil = List.nil
-- List.dropLast_nil
@[simp] theorem dropLast_nil : ([] : List α).dropLast = [] 
Arguments: {α : Type u}
Goal: List.nil.dropLast = List.nil
-- List.dropLast_single
@[simp] theorem dropLast_single : [x].dropLast = [] 
Goal: ∀ {α : Type u_1} {x : α}, (x :: List.nil).dropLast = List.nil
-- List.dropLast_cons₂
@[simp] theorem dropLast_cons₂ :
    (x::y::zs).dropLast = x :: (y::zs).dropLast 
Goal: ∀ {α : Type u_1} {x y : α} {zs : List α}, (x :: y :: zs).dropLast = x :: (y :: zs).dropLast
-- List.length_dropLast_cons
@[simp] theorem length_dropLast_cons (a : α) (as : List α) : (a :: as).dropLast.length = as.length 
Arguments: {α : Type u} (a : α) (as : List α)
Goal: (a :: as).dropLast.length = as.length
-- List.isPrefixOf_nil_left
@[simp] theorem isPrefixOf_nil_left [BEq α] : isPrefixOf ([] : List α) l = true 
Arguments: {α : Type u} {l : List α} [BEq α]
Goal: List.nil.isPrefixOf l = true
-- List.isPrefixOf_cons_nil
@[simp] theorem isPrefixOf_cons_nil [BEq α] : isPrefixOf (a::as) ([] : List α) = false 
Arguments: {α : Type u} {a : α} {as : List α} [BEq α]
Goal: (a :: as).isPrefixOf List.nil = false
-- List.isPrefixOf_cons₂
theorem isPrefixOf_cons₂ [BEq α] {a : α} :
    isPrefixOf (a::as) (b::bs) = (a == b && isPrefixOf as bs) 
Arguments: {α : Type u} {as : List α} {b : α} {bs : List α} [BEq α] {a : α}
Goal: (a :: as).isPrefixOf (b :: bs) = (a == b && as.isPrefixOf bs)
-- List.isSuffixOf_nil_left
@[simp] theorem isSuffixOf_nil_left [BEq α] : isSuffixOf ([] : List α) l = true 
Arguments: {α : Type u} {l : List α} [BEq α]
Goal: List.nil.isSuffixOf l = true
-- List.rotateLeft_nil
@[simp] theorem rotateLeft_nil : ([] : List α).rotateLeft n = [] 
Arguments: {α : Type u} {n : Nat}
Goal: List.nil.rotateLeft n = List.nil
-- List.rotateRight_nil
@[simp] theorem rotateRight_nil : ([] : List α).rotateRight n = [] 
Arguments: {α : Type u} {n : Nat}
Goal: List.nil.rotateRight n = List.nil
-- List.replace_nil
@[simp] theorem replace_nil [BEq α] : ([] : List α).replace a b = [] 
Arguments: {α : Type u} {a b : α} [BEq α]
Goal: List.nil.replace a b = List.nil
-- List.replace_cons
theorem replace_cons [BEq α] {a : α} :
    (a::as).replace b c = match b == a with | true => c::as | false => a :: replace as b c 
Arguments: {α : Type u} {as : List α} {b c : α} [BEq α] {a : α}
Goal: (a :: as).replace b c =
  match b == a with
  | true => c :: as
  | false => a :: as.replace b c
-- List.erase_nil
@[simp] theorem erase_nil [BEq α] (a : α) : [].erase a = [] 
Arguments: {α : Type u} [BEq α] (a : α)
Goal: List.nil.erase a = List.nil
-- List.erase_cons
theorem erase_cons [BEq α] (a b : α) (l : List α) :
    (b :: l).erase a = if b == a then l else b :: l.erase a 
Arguments: {α : Type u} [BEq α] (a b : α) (l : List α)
Goal: (b :: l).erase a = ite ((b == a) = true) l (b :: l.erase a)
-- List.eraseIdx_nil
@[simp] theorem eraseIdx_nil : ([] : List α).eraseIdx i = [] 
Arguments: {α : Type u} {i : Nat}
Goal: List.nil.eraseIdx i = List.nil
-- List.eraseIdx_cons_zero
@[simp] theorem eraseIdx_cons_zero : (a::as).eraseIdx 0 = as 
Goal: ∀ {α : Type u_1} {a : α} {as : List α}, (a :: as).eraseIdx 0 = as
-- List.eraseIdx_cons_succ
@[simp] theorem eraseIdx_cons_succ : (a::as).eraseIdx (i+1) = a :: as.eraseIdx i 
Goal: ∀ {α : Type u_1} {a : α} {as : List α} {i : Nat}, (a :: as).eraseIdx (i + 1) = a :: as.eraseIdx i
-- List.find?_nil
@[simp] theorem find?_nil : ([] : List α).find? p = none 
Arguments: {α : Type u} {p : α → Bool}
Goal: List.find? p List.nil = none
-- List.find?_cons
theorem find?_cons : (a::as).find? p = match p a with | true => some a | false => as.find? p 
Goal: ∀ {α : Type u_1} {a : α} {as : List α} {p : α → Bool},
  List.find? p (a :: as) =
    match p a with
    | true => some a
    | false => List.find? p as
-- List.findSome?_nil
@[simp] theorem findSome?_nil : ([] : List α).findSome? f = none 
Arguments: {α : Type u}
Goal: ∀ {α_1 : Type u_1} {f : α → Option α_1}, List.findSome? f List.nil = none
-- List.findSome?_cons
theorem findSome?_cons {f : α → Option β} :
    (a::as).findSome? f = match f a with | some b => some b | none => as.findSome? f 
Arguments: {α : Type u} {β : Type v} {a : α} {as : List α} {f : α → Option β}
Goal: List.findSome? f (a :: as) =
  match f a with
  | some b => some b
  | none => List.findSome? f as
-- List.lookup_nil
@[simp] theorem lookup_nil [BEq α] : ([] : List (α × β)).lookup a = none 
Arguments: {α : Type u} {β : Type v} {a : α} [BEq α]
Goal: List.lookup a List.nil = none
-- List.lookup_cons
theorem lookup_cons [BEq α] {k : α} :
    ((k,b)::es).lookup a = match a == k with | true => some b | false => es.lookup a 
Arguments: {α : Type u}
Goal: ∀ {β : Type u_1} {b : β} {es : List (α × β)} {a : α} [inst : BEq α] {k : α},
  List.lookup a ({ fst := k, snd := b } :: es) =
    match a == k with
    | true => some b
    | false => List.lookup a es
-- List.any_nil
@[simp] theorem any_nil : [].any f = false 
Goal: ∀ {α : Type u_1} {f : α → Bool}, List.nil.any f = false
-- List.any_cons
@[simp] theorem any_cons : (a::l).any f = (f a || l.any f) 
Goal: ∀ {α : Type u_1} {a : α} {l : List α} {f : α → Bool}, (a :: l).any f = (f a || l.any f)
-- List.all_nil
@[simp] theorem all_nil : [].all f = true 
Goal: ∀ {α : Type u_1} {f : α → Bool}, List.nil.all f = true
-- List.all_cons
@[simp] theorem all_cons : (a::l).all f = (f a && l.all f) 
Goal: ∀ {α : Type u_1} {a : α} {l : List α} {f : α → Bool}, (a :: l).all f = (f a && l.all f)
-- List.or_nil
@[simp] theorem or_nil : [].or = false 
Goal: List.nil.or = false
-- List.or_cons
@[simp] theorem or_cons : (a::l).or = (a || l.or) 
Arguments: {a : Bool} {l : List Bool}
Goal: (a :: l).or = (a || l.or)
-- List.and_nil
@[simp] theorem and_nil : [].and = true 
Goal: List.nil.and = true
-- List.and_cons
@[simp] theorem and_cons : (a::l).and = (a && l.and) 
Arguments: {a : Bool} {l : List Bool}
Goal: (a :: l).and = (a && l.and)
-- List.zipWith_nil_left
@[simp] theorem zipWith_nil_left {f : α → β → γ} : zipWith f [] l = [] 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {l : List β} {f : α → β → γ}
Goal: List.zipWith f List.nil l = List.nil
-- List.zipWith_nil_right
@[simp] theorem zipWith_nil_right {f : α → β → γ} : zipWith f l [] = [] 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {l : List α} {f : α → β → γ}
Goal: List.zipWith f l List.nil = List.nil
-- List.zipWith_cons_cons
@[simp] theorem zipWith_cons_cons {f : α → β → γ} :
    zipWith f (a :: as) (b :: bs) = f a b :: zipWith f as bs 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {a : α} {as : List α} {b : β} {bs : List β} {f : α → β → γ}
Goal: List.zipWith f (a :: as) (b :: bs) = f a b :: List.zipWith f as bs
-- List.zip_nil_left
@[simp] theorem zip_nil_left : zip ([] : List α) (l : List β)  = [] 
Arguments: {α : Type u} {β : Type v} {l : List β}
Goal: List.nil.zip l = List.nil
-- List.zip_nil_right
@[simp] theorem zip_nil_right : zip (l : List α) ([] : List β)  = [] 
Arguments: {α : Type u} {β : Type v} {l : List α}
Goal: l.zip List.nil = List.nil
-- List.zip_cons_cons
@[simp] theorem zip_cons_cons : zip (a :: as) (b :: bs) = (a, b) :: zip as bs 
Goal: ∀ {α : Type u_1} {a : α} {as : List α} {α_1 : Type u_2} {b : α_1} {bs : List α_1},
  (a :: as).zip (b :: bs) = { fst := a, snd := b } :: as.zip bs
-- List.zipWithAll_nil_right
@[simp] theorem zipWithAll_nil_right :
    zipWithAll f as [] = as.map fun a => f (some a) none 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : Option α → Option α_1 → α_2} {as : List α},
  List.zipWithAll f as List.nil = List.map (fun a => f (some a) none) as
-- List.zipWithAll_nil_left
@[simp] theorem zipWithAll_nil_left :
    zipWithAll f [] bs = bs.map fun b => f none (some b) 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : Option α → Option α_1 → α_2} {bs : List α_1},
  List.zipWithAll f List.nil bs = List.map (fun b => f none (some b)) bs
-- List.zipWithAll_cons_cons
@[simp] theorem zipWithAll_cons_cons :
    zipWithAll f (a :: as) (b :: bs) = f (some a) (some b) :: zipWithAll f as bs 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : Option α → Option α_1 → α_2} {a : α} {as : List α} {b : α_1}
  {bs : List α_1}, List.zipWithAll f (a :: as) (b :: bs) = f (some a) (some b) :: List.zipWithAll f as bs
-- List.unzip_nil
@[simp] theorem unzip_nil : ([] : List (α × β)).unzip = ([], []) 
Arguments: {α : Type u} {β : Type v}
Goal: List.nil.unzip = { fst := List.nil, snd := List.nil }
-- List.unzip_cons
@[simp] theorem unzip_cons {h : α × β} :
    (h :: t).unzip = match unzip t with | (al, bl) => (h.1::al, h.2::bl) 
Arguments: {α : Type u} {β : Type v} {t : List (α × β)} {h : α × β}
Goal: (h :: t).unzip =
  match t.unzip with
  | { fst := al, snd := bl } => { fst := h.fst :: al, snd := h.snd :: bl }
-- List.range_zero
@[simp] theorem range_zero : range 0 = [] 
Goal: List.range 0 = List.nil
-- List.iota_zero
@[simp] theorem iota_zero : iota 0 = [] 
Goal: List.iota 0 = List.nil
-- List.iota_succ
@[simp] theorem iota_succ : iota (i+1) = (i+1) :: iota i 
Arguments: {i : Nat}
Goal: List.iota (i + 1) = (i + 1) :: List.iota i
-- List.enumFrom_nil
@[simp] theorem enumFrom_nil : ([] : List α).enumFrom i = [] 
Arguments: {α : Type u} {i : Nat}
Goal: List.enumFrom i List.nil = List.nil
-- List.enumFrom_cons
@[simp] theorem enumFrom_cons : (a::as).enumFrom i = (i, a) :: as.enumFrom (i+1) 
Goal: ∀ {α : Type u_1} {a : α} {as : List α} {i : Nat},
  List.enumFrom i (a :: as) = { fst := i, snd := a } :: List.enumFrom (i + 1) as
-- List.enum_nil
@[simp] theorem enum_nil : ([] : List α).enum = [] 
Arguments: {α : Type u}
Goal: List.nil.enum = List.nil
-- List.intersperse_nil
@[simp] theorem intersperse_nil (sep : α) : ([] : List α).intersperse sep = [] 
Arguments: {α : Type u} (sep : α)
Goal: List.intersperse sep List.nil = List.nil
-- List.intersperse_single
@[simp] theorem intersperse_single (sep : α) : [x].intersperse sep = [x] 
Arguments: {α : Type u} {x : α} (sep : α)
Goal: List.intersperse sep (x :: List.nil) = x :: List.nil
-- List.intersperse_cons₂
@[simp] theorem intersperse_cons₂ (sep : α) :
    (x::y::zs).intersperse sep = x::sep::((y::zs).intersperse sep) 
Arguments: {α : Type u} {x y : α} {zs : List α} (sep : α)
Goal: List.intersperse sep (x :: y :: zs) = x :: sep :: List.intersperse sep (y :: zs)
-- Bool.default_bool
@[simp] theorem default_bool : default = false 
Goal: default = false
-- Bool.false_ne_true
theorem false_ne_true : false ≠ true 
Goal: false ≠ true
-- Bool.eq_false_or_eq_true
theorem eq_false_or_eq_true : (b : Bool) → b = true ∨ b = false 
Arguments: (b : Bool)
Goal: b = true ∨ b = false
-- Bool.eq_false_iff
theorem eq_false_iff : {b : Bool} → b = false ↔ b ≠ true 
Arguments: {b : Bool}
Goal: b = false ↔ b ≠ true
-- Bool.ne_false_iff
theorem ne_false_iff : {b : Bool} → b ≠ false ↔ b = true 
Arguments: {b : Bool}
Goal: b ≠ false ↔ b = true
-- Bool.eq_iff_iff
theorem eq_iff_iff {a b : Bool} : a = b ↔ (a ↔ b) 
Arguments: {a b : Bool}
Goal: a = b ↔ (a = true ↔ b = true)
-- Bool.decide_eq_true
@[simp] theorem decide_eq_true  {b : Bool} [Decidable (b = true)]  : decide (b = true)  =  b 
Arguments: {b : Bool} [Decidable (b = true)]
Goal: decide (b = true) = b
-- Bool.decide_eq_false
@[simp] theorem decide_eq_false {b : Bool} [Decidable (b = false)] : decide (b = false) = !b 
Arguments: {b : Bool} [Decidable (b = false)]
Goal: decide (b = false) = !b
-- Bool.decide_true_eq
@[simp] theorem decide_true_eq  {b : Bool} [Decidable (true = b)]  : decide (true  = b) =  b 
Arguments: {b : Bool} [Decidable (true = b)]
Goal: decide (true = b) = b
-- Bool.decide_false_eq
@[simp] theorem decide_false_eq {b : Bool} [Decidable (false = b)] : decide (false = b) = !b 
Arguments: {b : Bool} [Decidable (false = b)]
Goal: decide (false = b) = !b
-- Bool.and_self_left
@[simp] theorem and_self_left  : ∀(a b : Bool), (a && (a && b)) = (a && b) 
Arguments: (a b : Bool)
Goal: (a && (a && b)) = (a && b)
-- Bool.and_self_right
@[simp] theorem and_self_right : ∀(a b : Bool), ((a && b) && b) = (a && b) 
Arguments: (a b : Bool)
Goal: (a && b && b) = (a && b)
-- Bool.not_and_self
@[simp] theorem not_and_self : ∀ (x : Bool), (!x && x) = false 
Arguments: (x : Bool)
Goal: (!x && x) = false
-- Bool.and_not_self
@[simp] theorem and_not_self : ∀ (x : Bool), (x && !x) = false 
Arguments: (x : Bool)
Goal: (x && !x) = false
-- Bool.eq_true_and_eq_false_self
@[simp] theorem eq_true_and_eq_false_self : ∀(b : Bool), (b = true ∧ b = false) ↔ False 
Arguments: (b : Bool)
Goal: b = true ∧ b = false ↔ False
-- Bool.eq_false_and_eq_true_self
@[simp] theorem eq_false_and_eq_true_self : ∀(b : Bool), (b = false ∧ b = true) ↔ False 
Arguments: (b : Bool)
Goal: b = false ∧ b = true ↔ False
-- Bool.and_comm
theorem and_comm : ∀ (x y : Bool), (x && y) = (y && x) 
Arguments: (x y : Bool)
Goal: (x && y) = (y && x)
-- Bool.and_left_comm
theorem and_left_comm : ∀ (x y z : Bool), (x && (y && z)) = (y && (x && z)) 
Arguments: (x y z : Bool)
Goal: (x && (y && z)) = (y && (x && z))
-- Bool.and_right_comm
theorem and_right_comm : ∀ (x y z : Bool), ((x && y) && z) = ((x && z) && y) 
Arguments: (x y z : Bool)
Goal: (x && y && z) = (x && z && y)
-- Bool.and_iff_left_iff_imp
@[simp] theorem and_iff_left_iff_imp  : ∀(a b : Bool), ((a && b) = a) ↔ (a → b) 
Arguments: (a b : Bool)
Goal: (a && b) = a ↔ a = true → b = true
-- Bool.and_iff_right_iff_imp
@[simp] theorem and_iff_right_iff_imp : ∀(a b : Bool), ((a && b) = b) ↔ (b → a) 
Arguments: (a b : Bool)
Goal: (a && b) = b ↔ b = true → a = true
-- Bool.iff_self_and
@[simp] theorem iff_self_and : ∀(a b : Bool), (a = (a && b)) ↔ (a → b) 
Arguments: (a b : Bool)
Goal: a = (a && b) ↔ a = true → b = true
-- Bool.iff_and_self
@[simp] theorem iff_and_self : ∀(a b : Bool), (b = (a && b)) ↔ (b → a) 
Arguments: (a b : Bool)
Goal: b = (a && b) ↔ b = true → a = true
-- Bool.or_self_left
@[simp] theorem or_self_left  : ∀(a b : Bool), (a || (a || b)) = (a || b) 
Arguments: (a b : Bool)
Goal: (a || (a || b)) = (a || b)
-- Bool.or_self_right
@[simp] theorem or_self_right : ∀(a b : Bool), ((a || b) || b) = (a || b) 
Arguments: (a b : Bool)
Goal: (a || b || b) = (a || b)
-- Bool.not_or_self
@[simp] theorem not_or_self : ∀ (x : Bool), (!x || x) = true 
Arguments: (x : Bool)
Goal: (!x || x) = true
-- Bool.or_not_self
@[simp] theorem or_not_self : ∀ (x : Bool), (x || !x) = true 
Arguments: (x : Bool)
Goal: (x || !x) = true
-- Bool.eq_true_or_eq_false_self
@[simp] theorem eq_true_or_eq_false_self : ∀(b : Bool), (b = true ∨ b = false) ↔ True 
Arguments: (b : Bool)
Goal: b = true ∨ b = false ↔ True
-- Bool.eq_false_or_eq_true_self
@[simp] theorem eq_false_or_eq_true_self : ∀(b : Bool), (b = false ∨ b = true) ↔ True 
Arguments: (b : Bool)
Goal: b = false ∨ b = true ↔ True
-- Bool.or_iff_left_iff_imp
@[simp] theorem or_iff_left_iff_imp  : ∀(a b : Bool), ((a || b) = a) ↔ (b → a) 
Arguments: (a b : Bool)
Goal: (a || b) = a ↔ b = true → a = true
-- Bool.or_iff_right_iff_imp
@[simp] theorem or_iff_right_iff_imp : ∀(a b : Bool), ((a || b) = b) ↔ (a → b) 
Arguments: (a b : Bool)
Goal: (a || b) = b ↔ a = true → b = true
-- Bool.iff_self_or
@[simp] theorem iff_self_or : ∀(a b : Bool), (a = (a || b)) ↔ (b → a) 
Arguments: (a b : Bool)
Goal: a = (a || b) ↔ b = true → a = true
-- Bool.iff_or_self
@[simp] theorem iff_or_self : ∀(a b : Bool), (b = (a || b)) ↔ (a → b) 
Arguments: (a b : Bool)
Goal: b = (a || b) ↔ a = true → b = true
-- Bool.or_comm
theorem or_comm : ∀ (x y : Bool), (x || y) = (y || x) 
Arguments: (x y : Bool)
Goal: (x || y) = (y || x)