ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.exists_of_mem_map
theorem exists_of_mem_map (h : b ∈ map f l) : ∃ a, a ∈ l ∧ f a = b 
Goal: ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {f : α_1 → α} {l : List α_1}, b ∈ List.map f l → ∃ a, a ∈ l ∧ f a = b
-- List.mem_map_of_mem
theorem mem_map_of_mem (f : α → β) (h : a ∈ l) : f a ∈ map f l 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {l : List α} (f : α → β) (h : a ∈ l)
Goal: f a ∈ List.map f l
-- List.map_inj_left
@[simp] theorem map_inj_left {f g : α → β} : map f l = map g l ↔ ∀ a ∈ l, f a = g a 
Arguments: {α : Type u_1} {β : Type u_2} {l : List α} {f g : α → β}
Goal: List.map f l = List.map g l ↔ ∀ (a : α), a ∈ l → f a = g a
-- List.map_congr_left
theorem map_congr_left (h : ∀ a ∈ l, f a = g a) : map f l = map g l 
Goal: ∀ {α : Type u_1} {l : List α} {α_1 : Type u_2} {f g : α → α_1},
  (∀ (a : α), a ∈ l → f a = g a) → List.map f l = List.map g l
-- List.map_inj
theorem map_inj : map f = map g ↔ f = g 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f g : α → α_1}, List.map f = List.map g ↔ f = g
-- List.map_eq_nil
@[simp] theorem map_eq_nil {f : α → β} {l : List α} : map f l = [] ↔ l = [] 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}
Goal: List.map f l = [] ↔ l = []
-- List.eq_nil_of_map_eq_nil
theorem eq_nil_of_map_eq_nil {f : α → β} {l : List α} (h : map f l = []) : l = [] 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} (h : List.map f l = [])
Goal: l = []
-- List.map_eq_cons
theorem map_eq_cons {f : α → β} {l : List α} :
    map f l = b :: l₂ ↔ l.head?.map f = some b ∧ l.tail?.map (map f) = some l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {b : β} {l₂ : List β} {f : α → β} {l : List α}
Goal: List.map f l = b :: l₂ ↔ Option.map f l.head? = some b ∧ Option.map (List.map f) l.tail? = some l₂
-- List.map_eq_cons'
theorem map_eq_cons' {f : α → β} {l : List α} :
    map f l = b :: l₂ ↔ ∃ a l₁, l = a :: l₁ ∧ f a = b ∧ map f l₁ = l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {b : β} {l₂ : List β} {f : α → β} {l : List α}
Goal: List.map f l = b :: l₂ ↔ ∃ a l₁, l = a :: l₁ ∧ f a = b ∧ List.map f l₁ = l₂
-- List.map_eq_foldr
theorem map_eq_foldr (f : α → β) (l : List α) : map f l = foldr (fun a bs => f a :: bs) [] l 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: List.map f l = List.foldr (fun a bs => f a :: bs) [] l
-- List.set_map
@[simp] theorem set_map {f : α → β} {l : List α} {n : Nat} {a : α} :
    (map f l).set n (f a) = map f (l.set n a) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {n : Nat} {a : α}
Goal: (List.map f l).set n (f a) = List.map f (l.set n a)
-- List.head_map
@[simp] theorem head_map (f : α → β) (l : List α) (w) :
    head (map f l) w = f (head l (by simpa using w)) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) (w : List.map f l ≠ [])
Goal: (List.map f l).head w = f (l.head ⋯)
-- List.head?_map
@[simp] theorem head?_map (f : α → β) (l : List α) : head? (map f l) = (head? l).map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: (List.map f l).head? = Option.map f l.head?
-- List.headD_map
@[simp] theorem headD_map (f : α → β) (l : List α) (a : α) : headD (map f l) (f a) = f (headD l a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) (a : α)
Goal: (List.map f l).headD (f a) = f (l.headD a)
-- List.tail?_map
@[simp] theorem tail?_map (f : α → β) (l : List α) : tail? (map f l) = (tail? l).map (map f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: (List.map f l).tail? = Option.map (List.map f) l.tail?
-- List.tailD_map
@[simp] theorem tailD_map (f : α → β) (l : List α) (l' : List α) :
    tailD (map f l) (map f l') = map f (tailD l l') 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l l' : List α)
Goal: (List.map f l).tailD (List.map f l') = List.map f (l.tailD l')
-- List.getLast_map
@[simp] theorem getLast_map (f : α → β) (l : List α) (h) :
    getLast (map f l) h = f (getLast l (by simpa using h)) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) (h : List.map f l ≠ [])
Goal: (List.map f l).getLast h = f (l.getLast ⋯)
-- List.getLast?_map
@[simp] theorem getLast?_map (f : α → β) (l : List α) : getLast? (map f l) = (getLast? l).map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: (List.map f l).getLast? = Option.map f l.getLast?
-- List.getLastD_map
@[simp] theorem getLastD_map (f : α → β) (l : List α) (a : α) : getLastD (map f l) (f a) = f (getLastD l a) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) (a : α)
Goal: (List.map f l).getLastD (f a) = f (l.getLastD a)
-- List.map_append
@[simp] theorem map_append (f : α → β) : ∀ l₁ l₂, map f (l₁ ++ l₂) = map f l₁ ++ map f l₂ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l₁ l₂ : List α)
Goal: List.map f (l₁ ++ l₂) = List.map f l₁ ++ List.map f l₂
-- List.map_map
@[simp] theorem map_map (g : β → γ) (f : α → β) (l : List α) :
  map g (map f l) = map (g ∘ f) l 
Arguments: {β : Type u_1} {γ : Type u_2} {α : Type u_3} (g : β → γ) (f : α → β) (l : List α)
Goal: List.map g (List.map f l) = List.map (g ∘ f) l
-- List.forall_mem_map_iff
theorem forall_mem_map_iff {f : α → β} {l : List α} {P : β → Prop} :
    (∀ (i) (_ : i ∈ l.map f), P i) ↔ ∀ (j) (_ : j ∈ l), P (f j) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {P : β → Prop}
Goal: (∀ (i : β), i ∈ List.map f l → P i) ↔ ∀ (j : α), j ∈ l → P (f j)
-- List.filter_cons_of_pos
@[simp] theorem filter_cons_of_pos {p : α → Bool} {a : α} (l) (pa : p a) :
    filter p (a :: l) = a :: filter p l 
Arguments: {α : Type u_1} {p : α → Bool} {a : α} (l : List α) (pa : p a = true)
Goal: List.filter p (a :: l) = a :: List.filter p l
-- List.filter_cons_of_neg
@[simp] theorem filter_cons_of_neg {p : α → Bool} {a : α} (l) (pa : ¬ p a) :
    filter p (a :: l) = filter p l 
Arguments: {α : Type u_1} {p : α → Bool} {a : α} (l : List α) (pa : ¬p a = true)
Goal: List.filter p (a :: l) = List.filter p l
-- List.filter_cons
theorem filter_cons :
    (x :: xs : List α).filter p = if p x then x :: (xs.filter p) else xs.filter p 
Arguments: {α : Type u_1} {x : α} {xs : List α} {p : α → Bool}
Goal: List.filter p (x :: xs) = if p x = true then x :: List.filter p xs else List.filter p xs
-- List.length_filter_le
theorem length_filter_le (p : α → Bool) (l : List α) :
    (l.filter p).length ≤ l.length 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: (List.filter p l).length ≤ l.length
-- List.filter_eq_self
@[simp]
theorem filter_eq_self {l} : filter p l = l ↔ ∀ a ∈ l, p a 
Goal: ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.filter p l = l ↔ ∀ (a : α), a ∈ l → p a = true
-- List.filter_length_eq_length
@[simp]
theorem filter_length_eq_length {l} : (filter p l).length = l.length ↔ ∀ a ∈ l, p a 
Goal: ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (List.filter p l).length = l.length ↔ ∀ (a : α), a ∈ l → p a = true
-- List.mem_filter
theorem mem_filter : x ∈ filter p as ↔ x ∈ as ∧ p x 
Goal: ∀ {α : Type u_1} {x : α} {p : α → Bool} {as : List α}, x ∈ List.filter p as ↔ x ∈ as ∧ p x = true
-- List.filter_eq_nil
theorem filter_eq_nil {l} : filter p l = [] ↔ ∀ a, a ∈ l → ¬p a 
Goal: ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.filter p l = [] ↔ ∀ (a : α), a ∈ l → ¬p a = true
-- List.filter_filter
@[simp] theorem filter_filter (q) : ∀ l, filter p (filter q l) = filter (fun a => p a ∧ q a) l
  
Goal: ∀ {α : Type u_1} {p : α → Bool} (q : α → Bool) (l : List α),
  List.filter p (List.filter q l) = List.filter (fun a => decide (p a = true ∧ q a = true)) l
-- List.filter_map
theorem filter_map (f : β → α) (l : List β) : filter p (map f l) = map f (filter (p ∘ f) l) 
Arguments: {β : Type u_1} {α : Type u_2} {p : α → Bool} (f : β → α) (l : List β)
Goal: List.filter p (List.map f l) = List.map f (List.filter (p ∘ f) l)
-- List.map_filter_eq_foldr
theorem map_filter_eq_foldr (f : α → β) (p : α → Bool) (as : List α) :
    map f (filter p as) = foldr (fun a bs => bif p a then f a :: bs else bs) [] as 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (p : α → Bool) (as : List α)
Goal: List.map f (List.filter p as) = List.foldr (fun a bs => bif p a then f a :: bs else bs) [] as
-- List.filter_append
@[simp] theorem filter_append {p : α → Bool} :
    ∀ (l₁ l₂ : List α), filter p (l₁ ++ l₂) = filter p l₁ ++ filter p l₂
  
Arguments: {α : Type u_1} {p : α → Bool} (l₁ l₂ : List α)
Goal: List.filter p (l₁ ++ l₂) = List.filter p l₁ ++ List.filter p l₂
-- List.filter_congr
theorem filter_congr {p q : α → Bool} :
    ∀ {l : List α}, (∀ x ∈ l, p x = q x) → filter p l = filter q l
  
Arguments: {α : Type u_1} {p q : α → Bool} {l : List α}
Goal: (∀ (x : α), x ∈ l → p x = q x) → List.filter p l = List.filter q l
-- List.filterMap_cons_none
@[simp] theorem filterMap_cons_none {f : α → Option β} (a : α) (l : List α) (h : f a = none) :
    filterMap f (a :: l) = filterMap f l 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → Option β} (a : α) (l : List α) (h : f a = none)
Goal: List.filterMap f (a :: l) = List.filterMap f l
-- List.filterMap_cons_some
@[simp] theorem filterMap_cons_some (f : α → Option β) (a : α) (l : List α) {b : β} (h : f a = some b) :
    filterMap f (a :: l) = b :: filterMap f l 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (a : α) (l : List α) {b : β} (h : f a = some b)
Goal: List.filterMap f (a :: l) = b :: List.filterMap f l
-- List.filterMap_eq_map
@[simp]
theorem filterMap_eq_map (f : α → β) : filterMap (some ∘ f) = map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: List.filterMap (some ∘ f) = List.map f
-- List.filterMap_some
@[simp] theorem filterMap_some (l : List α) : filterMap some l = l 
Arguments: {α : Type u_1} (l : List α)
Goal: List.filterMap some l = l
-- List.map_filterMap_some_eq_filter_map_is_some
theorem map_filterMap_some_eq_filter_map_is_some (f : α → Option β) (l : List α) :
    (l.filterMap f).map some = (l.map f).filter fun b => b.isSome 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (l : List α)
Goal: List.map some (List.filterMap f l) = List.filter (fun b => b.isSome) (List.map f l)
-- List.length_filterMap_le
theorem length_filterMap_le (f : α → Option β) (l : List α) :
    (filterMap f l).length ≤ l.length 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (l : List α)
Goal: (List.filterMap f l).length ≤ l.length
-- List.filterMap_length_eq_length
@[simp]
theorem filterMap_length_eq_length {l} :
    (filterMap f l).length = l.length ↔ ∀ a ∈ l, (f a).isSome 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → Option α_1} {l : List α},
  (List.filterMap f l).length = l.length ↔ ∀ (a : α), a ∈ l → (f a).isSome = true
-- List.filterMap_eq_filter
@[simp]
theorem filterMap_eq_filter (p : α → Bool) :
    filterMap (Option.guard (p ·)) = filter p 
Arguments: {α : Type u_1} (p : α → Bool)
Goal: List.filterMap (Option.guard fun x => p x = true) = List.filter p
-- List.filterMap_filterMap
theorem filterMap_filterMap (f : α → Option β) (g : β → Option γ) (l : List α) :
    filterMap g (filterMap f l) = filterMap (fun x => (f x).bind g) l 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → Option β) (g : β → Option γ) (l : List α)
Goal: List.filterMap g (List.filterMap f l) = List.filterMap (fun x => (f x).bind g) l
-- List.map_filterMap
theorem map_filterMap (f : α → Option β) (g : β → γ) (l : List α) :
    map g (filterMap f l) = filterMap (fun x => (f x).map g) l 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → Option β) (g : β → γ) (l : List α)
Goal: List.map g (List.filterMap f l) = List.filterMap (fun x => Option.map g (f x)) l
-- List.filterMap_map
@[simp]
theorem filterMap_map (f : α → β) (g : β → Option γ) (l : List α) :
    filterMap g (map f l) = filterMap (g ∘ f) l 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : β → Option γ) (l : List α)
Goal: List.filterMap g (List.map f l) = List.filterMap (g ∘ f) l
-- List.filter_filterMap
theorem filter_filterMap (f : α → Option β) (p : β → Bool) (l : List α) :
    filter p (filterMap f l) = filterMap (fun x => (f x).filter p) l 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (p : β → Bool) (l : List α)
Goal: List.filter p (List.filterMap f l) = List.filterMap (fun x => Option.filter p (f x)) l
-- List.filterMap_filter
theorem filterMap_filter (p : α → Bool) (f : α → Option β) (l : List α) :
    filterMap f (filter p l) = filterMap (fun x => if p x then f x else none) l 
Arguments: {α : Type u_1} {β : Type u_2} (p : α → Bool) (f : α → Option β) (l : List α)
Goal: List.filterMap f (List.filter p l) = List.filterMap (fun x => if p x = true then f x else none) l
-- List.mem_filterMap
@[simp] theorem mem_filterMap (f : α → Option β) (l : List α) {b : β} :
    b ∈ filterMap f l ↔ ∃ a, a ∈ l ∧ f a = some b 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (l : List α) {b : β}
Goal: b ∈ List.filterMap f l ↔ ∃ a, a ∈ l ∧ f a = some b
-- List.filterMap_append
theorem filterMap_append {α β : Type _} (l l' : List α) (f : α → Option β) :
    filterMap f (l ++ l') = filterMap f l ++ filterMap f l' 
Arguments: {α : Type u_1} {β : Type u_2} (l l' : List α) (f : α → Option β)
Goal: List.filterMap f (l ++ l') = List.filterMap f l ++ List.filterMap f l'
-- List.filterMap_join
@[simp] theorem filterMap_join (f : α → Option β) (L : List (List α)) :
    filterMap f (join L) = join (map (filterMap f) L) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (L : List (List α))
Goal: List.filterMap f L.join = (List.map (List.filterMap f) L).join
-- List.map_filterMap_of_inv
theorem map_filterMap_of_inv (f : α → Option β) (g : β → α) (H : ∀ x : α, (f x).map g = some x)
    (l : List α) : map g (filterMap f l) = l 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) (g : β → α) (H : ∀ (x : α), Option.map g (f x) = some x) (l : List α)
Goal: List.map g (List.filterMap f l) = l
-- List.getElem?_append_right
theorem getElem?_append_right : ∀ {l₁ l₂ : List α} {n : Nat}, l₁.length ≤ n →
  (l₁ ++ l₂)[n]? = l₂[n - l₁.length]?

Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat}
Goal: l₁.length ≤ n → (l₁ ++ l₂)[n]? = l₂[n - l₁.length]?
-- List.get?_append_right
@[deprecated getElem?_append_right (since := "2024-06-12")]
theorem get?_append_right {l₁ l₂ : List α} {n : Nat} (h : l₁.length ≤ n) :
    (l₁ ++ l₂).get? n = l₂.get? (n - l₁.length) 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h : l₁.length ≤ n)
Goal: (l₁ ++ l₂).get? n = l₂.get? (n - l₁.length)
-- List.getElem_append_right'
theorem getElem_append_right' {l₁ l₂ : List α} {n : Nat} (h₁ : l₁.length ≤ n) (h₂) :
    (l₁ ++ l₂)[n]'h₂ =
      l₂[n - l₁.length]'(by rw [length_append] at h₂; exact Nat.sub_lt_left_of_lt_add h₁ h₂) 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h₁ : l₁.length ≤ n) (h₂ : n < (l₁ ++ l₂).length)
Goal: (l₁ ++ l₂)[n] = l₂[n - l₁.length]
-- List.get_append_right_aux
@[deprecated (since := "2024-06-12")]
theorem get_append_right_aux {l₁ l₂ : List α} {n : Nat}
  (h₁ : l₁.length ≤ n) (h₂ : n < (l₁ ++ l₂).length) : n - l₁.length < l₂.length 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h₁ : l₁.length ≤ n) (h₂ : n < (l₁ ++ l₂).length)
Goal: n - l₁.length < l₂.length
-- List.get_append_right'
@[deprecated getElem_append_right' (since := "2024-06-12")]
theorem get_append_right' {l₁ l₂ : List α} {n : Nat} (h₁ : l₁.length ≤ n) (h₂) :
    (l₁ ++ l₂).get ⟨n, h₂⟩ = l₂.get ⟨n - l₁.length, get_append_right_aux h₁ h₂⟩ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h₁ : l₁.length ≤ n) (h₂ : n < (l₁ ++ l₂).length)
Goal: (l₁ ++ l₂).get ⟨n, h₂⟩ = l₂.get ⟨n - l₁.length, ⋯⟩
-- List.getElem_of_append
theorem getElem_of_append {l : List α} (eq : l = l₁ ++ a :: l₂) (h : l₁.length = n) :
    l[n]'(eq ▸ h ▸ by simp_arith) = a 
Arguments: {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α} {n : Nat} {l : List α} (eq : l = l₁ ++ a :: l₂) (h : l₁.length = n)
Goal: l[n] = a
-- List.get_of_append_proof
@[deprecated (since := "2024-06-12")]
theorem get_of_append_proof {l : List α}
    (eq : l = l₁ ++ a :: l₂) (h : l₁.length = n) : n < length l 
Arguments: {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α} {n : Nat} {l : List α} (eq : l = l₁ ++ a :: l₂) (h : l₁.length = n)
Goal: n < l.length
-- List.get_of_append
@[deprecated getElem_of_append (since := "2024-06-12")]
theorem get_of_append {l : List α} (eq : l = l₁ ++ a :: l₂) (h : l₁.length = n) :
    l.get ⟨n, get_of_append_proof eq h⟩ = a 
Arguments: {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α} {n : Nat} {l : List α} (eq : l = l₁ ++ a :: l₂) (h : l₁.length = n)
Goal: l.get ⟨n, ⋯⟩ = a
-- List.append_of_mem
theorem append_of_mem {a : α} {l : List α} : a ∈ l → ∃ s t : List α, l = s ++ a :: t
  
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: a ∈ l → ∃ s t, l = s ++ a :: t
-- List.singleton_append
@[simp 1100] theorem singleton_append : [x] ++ l = x :: l 
Goal: ∀ {α : Type u_1} {x : α} {l : List α}, [x] ++ l = x :: l
-- List.append_inj
theorem append_inj :
    ∀ {s₁ s₂ t₁ t₂ : List α}, s₁ ++ t₁ = s₂ ++ t₂ → length s₁ = length s₂ → s₁ = s₂ ∧ t₁ = t₂
  
Arguments: {α : Type u_1} {s₁ s₂ t₁ t₂ : List α}
Goal: s₁ ++ t₁ = s₂ ++ t₂ → s₁.length = s₂.length → s₁ = s₂ ∧ t₁ = t₂
-- List.append_inj_right
theorem append_inj_right (h : s₁ ++ t₁ = s₂ ++ t₂) (hl : length s₁ = length s₂) : t₁ = t₂ 
Goal: ∀ {α : Type u_1} {s₁ t₁ s₂ t₂ : List α}, s₁ ++ t₁ = s₂ ++ t₂ → s₁.length = s₂.length → t₁ = t₂
-- List.append_inj_left
theorem append_inj_left (h : s₁ ++ t₁ = s₂ ++ t₂) (hl : length s₁ = length s₂) : s₁ = s₂ 
Goal: ∀ {α : Type u_1} {s₁ t₁ s₂ t₂ : List α}, s₁ ++ t₁ = s₂ ++ t₂ → s₁.length = s₂.length → s₁ = s₂
-- List.append_inj'
theorem append_inj' (h : s₁ ++ t₁ = s₂ ++ t₂) (hl : length t₁ = length t₂) : s₁ = s₂ ∧ t₁ = t₂ 
Goal: ∀ {α : Type u_1} {s₁ t₁ s₂ t₂ : List α}, s₁ ++ t₁ = s₂ ++ t₂ → t₁.length = t₂.length → s₁ = s₂ ∧ t₁ = t₂
-- List.append_inj_right'
theorem append_inj_right' (h : s₁ ++ t₁ = s₂ ++ t₂) (hl : length t₁ = length t₂) : t₁ = t₂ 
Goal: ∀ {α : Type u_1} {s₁ t₁ s₂ t₂ : List α}, s₁ ++ t₁ = s₂ ++ t₂ → t₁.length = t₂.length → t₁ = t₂
-- List.append_inj_left'
theorem append_inj_left' (h : s₁ ++ t₁ = s₂ ++ t₂) (hl : length t₁ = length t₂) : s₁ = s₂ 
Goal: ∀ {α : Type u_1} {s₁ t₁ s₂ t₂ : List α}, s₁ ++ t₁ = s₂ ++ t₂ → t₁.length = t₂.length → s₁ = s₂
-- List.append_right_inj
theorem append_right_inj {t₁ t₂ : List α} (s) : s ++ t₁ = s ++ t₂ ↔ t₁ = t₂ 
Arguments: {α : Type u_1} {t₁ t₂ : List α} (s : List α)
Goal: s ++ t₁ = s ++ t₂ ↔ t₁ = t₂
-- List.append_left_inj
theorem append_left_inj {s₁ s₂ : List α} (t) : s₁ ++ t = s₂ ++ t ↔ s₁ = s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : List α} (t : List α)
Goal: s₁ ++ t = s₂ ++ t ↔ s₁ = s₂
-- List.append_eq_nil
@[simp] theorem append_eq_nil : p ++ q = [] ↔ p = [] ∧ q = [] 
Goal: ∀ {α : Type u_1} {p q : List α}, p ++ q = [] ↔ p = [] ∧ q = []
-- List.getLast_append
@[simp] theorem getLast_append {a : α} : ∀ (l : List α) h, getLast (l ++ [a]) h = a
  
Arguments: {α : Type u_1} {a : α} (l : List α) (h : l ++ [a] ≠ [])
Goal: (l ++ [a]).getLast h = a
-- List.getLast_concat
theorem getLast_concat : getLast (concat l a) h = a 
Goal: ∀ {α : Type u_1} {l : List α} {a : α} {h : l.concat a ≠ []}, (l.concat a).getLast h = a
-- List.getElem_append
theorem getElem_append : ∀ {l₁ l₂ : List α} (n : Nat) (h : n < l₁.length),
    (l₁ ++ l₂)[n]'(length_append .. ▸ Nat.lt_add_right _ h) = l₁[n]

Arguments: {α : Type u_1} {l₁ l₂ : List α} (n : Nat) (h : n < l₁.length)
Goal: (l₁ ++ l₂)[n] = l₁[n]
-- List.get_append
@[deprecated getElem_append (since := "2024-06-12")]
theorem get_append {l₁ l₂ : List α} (n : Nat) (h : n < l₁.length) :
    (l₁ ++ l₂).get ⟨n, length_append .. ▸ Nat.lt_add_right _ h⟩ = l₁.get ⟨n, h⟩ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (n : Nat) (h : n < l₁.length)
Goal: (l₁ ++ l₂).get ⟨n, ⋯⟩ = l₁.get ⟨n, h⟩
-- List.get_append_left
@[deprecated getElem_append_left (since := "2024-06-12")]
theorem get_append_left (as bs : List α) (h : i < as.length) {h'} : (as ++ bs).get ⟨i, h'⟩ = as.get ⟨i, h⟩ 
Arguments: {α : Type u_1} {i : Nat} (as bs : List α) (h : i < as.length) {h' : i < (as ++ bs).length}
Goal: (as ++ bs).get ⟨i, h'⟩ = as.get ⟨i, h⟩
-- List.get_append_right
@[deprecated getElem_append_right (since := "2024-06-12")]
theorem get_append_right (as bs : List α) (h : ¬ i < as.length) {h' h''} : (as ++ bs).get ⟨i, h'⟩ = bs.get ⟨i - as.length, h''⟩ 
Arguments: {α : Type u_1} {i : Nat} (as bs : List α) (h : ¬i < as.length) {h' : i < (as ++ bs).length} {h'' : i - as.length < bs.length}
Goal: (as ++ bs).get ⟨i, h'⟩ = bs.get ⟨i - as.length, h''⟩
-- List.getElem?_append
theorem getElem?_append {l₁ l₂ : List α} {n : Nat} (hn : n < l₁.length) :
    (l₁ ++ l₂)[n]? = l₁[n]? 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (hn : n < l₁.length)
Goal: (l₁ ++ l₂)[n]? = l₁[n]?
-- List.get?_append
@[deprecated (since := "2024-06-12")]
theorem get?_append {l₁ l₂ : List α} {n : Nat} (hn : n < l₁.length) :
    (l₁ ++ l₂).get? n = l₁.get? n 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (hn : n < l₁.length)
Goal: (l₁ ++ l₂).get? n = l₁.get? n
-- List.append_eq_append
theorem append_eq_append : List.append l₁ l₂ = l₁ ++ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.append l₂ = l₁ ++ l₂
-- List.append_ne_nil_of_ne_nil_left
theorem append_ne_nil_of_ne_nil_left (s t : List α) : s ≠ [] → s ++ t ≠ [] 
Arguments: {α : Type u_1} (s t : List α)
Goal: s ≠ [] → s ++ t ≠ []
-- List.append_ne_nil_of_ne_nil_right
theorem append_ne_nil_of_ne_nil_right (s t : List α) : t ≠ [] → s ++ t ≠ [] 
Arguments: {α : Type u_1} (s t : List α)
Goal: t ≠ [] → s ++ t ≠ []
-- List.nil_eq_append
@[simp] theorem nil_eq_append : [] = a ++ b ↔ a = [] ∧ b = [] 
Goal: ∀ {α : Type u_1} {a b : List α}, [] = a ++ b ↔ a = [] ∧ b = []
-- List.append_ne_nil_of_left_ne_nil
theorem append_ne_nil_of_left_ne_nil (a b : List α) (h0 : a ≠ []) : a ++ b ≠ [] 
Arguments: {α : Type u_1} (a b : List α) (h0 : a ≠ [])
Goal: a ++ b ≠ []
-- List.append_eq_cons
theorem append_eq_cons :
    a ++ b = x :: c ↔ (a = [] ∧ b = x :: c) ∨ (∃ a', a = x :: a' ∧ c = a' ++ b) 
Goal: ∀ {α : Type u_1} {a b : List α} {x : α} {c : List α},
  a ++ b = x :: c ↔ a = [] ∧ b = x :: c ∨ ∃ a', a = x :: a' ∧ c = a' ++ b
-- List.cons_eq_append
theorem cons_eq_append :
    x :: c = a ++ b ↔ (a = [] ∧ b = x :: c) ∨ (∃ a', a = x :: a' ∧ c = a' ++ b) 
Goal: ∀ {α : Type u_1} {x : α} {c a b : List α}, x :: c = a ++ b ↔ a = [] ∧ b = x :: c ∨ ∃ a', a = x :: a' ∧ c = a' ++ b
-- List.append_eq_append_iff
theorem append_eq_append_iff {a b c d : List α} :
    a ++ b = c ++ d ↔ (∃ a', c = a ++ a' ∧ b = a' ++ d) ∨ ∃ c', a = c ++ c' ∧ d = c' ++ b 
Arguments: {α : Type u_1} {a b c d : List α}
Goal: a ++ b = c ++ d ↔ (∃ a', c = a ++ a' ∧ b = a' ++ d) ∨ ∃ c', a = c ++ c' ∧ d = c' ++ b
-- List.mem_append
@[simp] theorem mem_append {a : α} {s t : List α} : a ∈ s ++ t ↔ a ∈ s ∨ a ∈ t 
Arguments: {α : Type u_1} {a : α} {s t : List α}
Goal: a ∈ s ++ t ↔ a ∈ s ∨ a ∈ t
-- List.not_mem_append
theorem not_mem_append {a : α} {s t : List α} (h₁ : a ∉ s) (h₂ : a ∉ t) : a ∉ s ++ t 
Arguments: {α : Type u_1} {a : α} {s t : List α} (h₁ : ¬a ∈ s) (h₂ : ¬a ∈ t)
Goal: ¬a ∈ s ++ t
-- List.mem_append_eq
theorem mem_append_eq (a : α) (s t : List α) : (a ∈ s ++ t) = (a ∈ s ∨ a ∈ t) 
Arguments: {α : Type u_1} (a : α) (s t : List α)
Goal: (a ∈ s ++ t) = (a ∈ s ∨ a ∈ t)
-- List.mem_append_left
theorem mem_append_left {a : α} {l₁ : List α} (l₂ : List α) (h : a ∈ l₁) : a ∈ l₁ ++ l₂ 
Arguments: {α : Type u_1} {a : α} {l₁ : List α} (l₂ : List α) (h : a ∈ l₁)
Goal: a ∈ l₁ ++ l₂
-- List.mem_append_right
theorem mem_append_right {a : α} (l₁ : List α) {l₂ : List α} (h : a ∈ l₂) : a ∈ l₁ ++ l₂ 
Arguments: {α : Type u_1} {a : α} (l₁ : List α) {l₂ : List α} (h : a ∈ l₂)
Goal: a ∈ l₁ ++ l₂
-- List.mem_iff_append
theorem mem_iff_append {a : α} {l : List α} : a ∈ l ↔ ∃ s t : List α, l = s ++ a :: t 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: a ∈ l ↔ ∃ s t, l = s ++ a :: t
-- List.forall_mem_append
theorem forall_mem_append {p : α → Prop} {l₁ l₂ : List α} :
    (∀ (x) (_ : x ∈ l₁ ++ l₂), p x) ↔ (∀ (x) (_ : x ∈ l₁), p x) ∧ (∀ (x) (_ : x ∈ l₂), p x) 
Arguments: {α : Type u_1} {p : α → Prop} {l₁ l₂ : List α}
Goal: (∀ (x : α), x ∈ l₁ ++ l₂ → p x) ↔ (∀ (x : α), x ∈ l₁ → p x) ∧ ∀ (x : α), x ∈ l₂ → p x
-- List.concat_nil
theorem concat_nil (a : α) : concat [] a = [a] 
Arguments: {α : Type u_1} (a : α)
Goal: [].concat a = [a]