ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.not_nodup_pair
theorem not_nodup_pair (a : α) : ¬Nodup [a, a] 
Arguments: {α : Type u} (a : α)
Goal: ¬[a, a].Nodup
-- List.nodup_iff_sublist
theorem nodup_iff_sublist {l : List α} : Nodup l ↔ ∀ a, ¬[a, a] <+ l 
Arguments: {α : Type u} {l : List α}
Goal: l.Nodup ↔ ∀ (a : α), ¬[a, a].Sublist l
-- List.nodup_iff_injective_getElem
theorem nodup_iff_injective_getElem {l : List α} :
    Nodup l ↔ Function.Injective (fun i : Fin l.length => l[i.1]) 
Arguments: {α : Type u} {l : List α}
Goal: l.Nodup ↔ Function.Injective fun i => l[↑i]
-- List.nodup_iff_injective_get
theorem nodup_iff_injective_get {l : List α} :
    Nodup l ↔ Function.Injective l.get 
Arguments: {α : Type u} {l : List α}
Goal: l.Nodup ↔ Function.Injective l.get
-- List.nodup_iff_nthLe_inj
@[deprecated nodup_iff_injective_get (since := "2023-01-10")]
theorem nodup_iff_nthLe_inj {l : List α} :
    Nodup l ↔ ∀ i j h₁ h₂, nthLe l i h₁ = nthLe l j h₂ → i = j 
Arguments: {α : Type u} {l : List α}
Goal: l.Nodup ↔ ∀ (i j : ℕ) (h₁ : i < l.length) (h₂ : j < l.length), l.nthLe i h₁ = l.nthLe j h₂ → i = j
-- List.Nodup.get_inj_iff
theorem Nodup.get_inj_iff {l : List α} (h : Nodup l) {i j : Fin l.length} :
    l.get i = l.get j ↔ i = j 
Arguments: {α : Type u} {l : List α} (h : l.Nodup) {i j : Fin l.length}
Goal: l.get i = l.get j ↔ i = j
-- List.Nodup.getElem_inj_iff
theorem Nodup.getElem_inj_iff {l : List α} (h : Nodup l)
    {i : Nat} {hi : i < l.length} {j : Nat} {hj : j < l.length} :
    l[i] = l[j] ↔ i = j 
Arguments: {α : Type u} {l : List α} (h : l.Nodup) {i : ℕ} {hi : i < l.length} {j : ℕ} {hj : j < l.length}
Goal: l[i] = l[j] ↔ i = j
-- List.Nodup.nthLe_inj_iff
@[deprecated Nodup.get_inj_iff (since := "2023-01-10")]
theorem Nodup.nthLe_inj_iff {l : List α} (h : Nodup l) {i j : ℕ} (hi : i < l.length)
    (hj : j < l.length) : l.nthLe i hi = l.nthLe j hj ↔ i = j 
Arguments: {α : Type u} {l : List α} (h : l.Nodup) {i j : ℕ} (hi : i < l.length) (hj : j < l.length)
Goal: l.nthLe i hi = l.nthLe j hj ↔ i = j
-- List.nodup_iff_getElem?_ne_getElem?
theorem nodup_iff_getElem?_ne_getElem? {l : List α} :
    l.Nodup ↔ ∀ i j : ℕ, i < j → j < l.length → l[i]? ≠ l[j]? 
Arguments: {α : Type u} {l : List α}
Goal: l.Nodup ↔ ∀ (i j : ℕ), i < j → j < l.length → l[i]? ≠ l[j]?
-- List.nodup_iff_get?_ne_get?
theorem nodup_iff_get?_ne_get? {l : List α} :
    l.Nodup ↔ ∀ i j : ℕ, i < j → j < l.length → l.get? i ≠ l.get? j 
Arguments: {α : Type u} {l : List α}
Goal: l.Nodup ↔ ∀ (i j : ℕ), i < j → j < l.length → l.get? i ≠ l.get? j
-- List.Nodup.ne_singleton_iff
theorem Nodup.ne_singleton_iff {l : List α} (h : Nodup l) (x : α) :
    l ≠ [x] ↔ l = [] ∨ ∃ y ∈ l, y ≠ x 
Arguments: {α : Type u} {l : List α} (h : l.Nodup) (x : α)
Goal: l ≠ [x] ↔ l = [] ∨ ∃ y ∈ l, y ≠ x
-- List.not_nodup_of_get_eq_of_ne
theorem not_nodup_of_get_eq_of_ne (xs : List α) (n m : Fin xs.length)
    (h : xs.get n = xs.get m) (hne : n ≠ m) : ¬Nodup xs 
Arguments: {α : Type u} (xs : List α) (n m : Fin xs.length) (h : xs.get n = xs.get m) (hne : n ≠ m)
Goal: ¬xs.Nodup
-- List.indexOf_getElem
theorem indexOf_getElem [DecidableEq α] {l : List α} (H : Nodup l) (i : Nat) (h : i < l.length) :
    indexOf l[i] l = i 
Arguments: {α : Type u} [DecidableEq α] {l : List α} (H : l.Nodup) (i : ℕ) (h : i < l.length)
Goal: List.indexOf l[i] l = i
-- List.get_indexOf
theorem get_indexOf [DecidableEq α] {l : List α} (H : Nodup l) (i : Fin l.length) :
    indexOf (get l i) l = i 
Arguments: {α : Type u} [DecidableEq α] {l : List α} (H : l.Nodup) (i : Fin l.length)
Goal: List.indexOf (l.get i) l = ↑i
-- List.nodup_iff_count_le_one
theorem nodup_iff_count_le_one [DecidableEq α] {l : List α} : Nodup l ↔ ∀ a, count a l ≤ 1 
Arguments: {α : Type u} [DecidableEq α] {l : List α}
Goal: l.Nodup ↔ ∀ (a : α), List.count a l ≤ 1
-- List.nodup_iff_count_eq_one
theorem nodup_iff_count_eq_one [DecidableEq α] : Nodup l ↔ ∀ a ∈ l, count a l = 1 
Arguments: {α : Type u} {l : List α} [DecidableEq α]
Goal: l.Nodup ↔ ∀ a ∈ l, List.count a l = 1
-- List.nodup_replicate
theorem nodup_replicate (a : α) : ∀ {n : ℕ}, Nodup (replicate n a) ↔ n ≤ 1
  
Arguments: {α : Type u} (a : α) {n : ℕ}
Goal: (List.replicate n a).Nodup ↔ n ≤ 1
-- List.count_eq_one_of_mem
@[simp]
theorem count_eq_one_of_mem [DecidableEq α] {a : α} {l : List α} (d : Nodup l) (h : a ∈ l) :
    count a l = 1 
Arguments: {α : Type u} [DecidableEq α] {a : α} {l : List α} (d : l.Nodup) (h : a ∈ l)
Goal: List.count a l = 1
-- List.count_eq_of_nodup
theorem count_eq_of_nodup [DecidableEq α] {a : α} {l : List α} (d : Nodup l) :
    count a l = if a ∈ l then 1 else 0 
Arguments: {α : Type u} [DecidableEq α] {a : α} {l : List α} (d : l.Nodup)
Goal: List.count a l = if a ∈ l then 1 else 0
-- List.Nodup.of_append_left
theorem Nodup.of_append_left : Nodup (l₁ ++ l₂) → Nodup l₁ 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: (l₁ ++ l₂).Nodup → l₁.Nodup
-- List.Nodup.of_append_right
theorem Nodup.of_append_right : Nodup (l₁ ++ l₂) → Nodup l₂ 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: (l₁ ++ l₂).Nodup → l₂.Nodup
-- List.nodup_append
theorem nodup_append {l₁ l₂ : List α} :
    Nodup (l₁ ++ l₂) ↔ Nodup l₁ ∧ Nodup l₂ ∧ Disjoint l₁ l₂ 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: (l₁ ++ l₂).Nodup ↔ l₁.Nodup ∧ l₂.Nodup ∧ l₁.Disjoint l₂
-- List.disjoint_of_nodup_append
theorem disjoint_of_nodup_append {l₁ l₂ : List α} (d : Nodup (l₁ ++ l₂)) : Disjoint l₁ l₂ 
Arguments: {α : Type u} {l₁ l₂ : List α} (d : (l₁ ++ l₂).Nodup)
Goal: l₁.Disjoint l₂
-- List.Nodup.append
theorem Nodup.append (d₁ : Nodup l₁) (d₂ : Nodup l₂) (dj : Disjoint l₁ l₂) : Nodup (l₁ ++ l₂) 
Arguments: {α : Type u} {l₁ l₂ : List α} (d₁ : l₁.Nodup) (d₂ : l₂.Nodup) (dj : l₁.Disjoint l₂)
Goal: (l₁ ++ l₂).Nodup
-- List.nodup_append_comm
theorem nodup_append_comm {l₁ l₂ : List α} : Nodup (l₁ ++ l₂) ↔ Nodup (l₂ ++ l₁) 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: (l₁ ++ l₂).Nodup ↔ (l₂ ++ l₁).Nodup
-- List.nodup_middle
theorem nodup_middle {a : α} {l₁ l₂ : List α} :
    Nodup (l₁ ++ a :: l₂) ↔ Nodup (a :: (l₁ ++ l₂)) 
Arguments: {α : Type u} {a : α} {l₁ l₂ : List α}
Goal: (l₁ ++ a :: l₂).Nodup ↔ (a :: (l₁ ++ l₂)).Nodup
-- List.Nodup.of_map
theorem Nodup.of_map (f : α → β) {l : List α} : Nodup (map f l) → Nodup l 
Arguments: {α : Type u} {β : Type v} (f : α → β) {l : List α}
Goal: (List.map f l).Nodup → l.Nodup
-- List.Nodup.map_on
theorem Nodup.map_on {f : α → β} (H : ∀ x ∈ l, ∀ y ∈ l, f x = f y → x = y) (d : Nodup l) :
    (map f l).Nodup 
Arguments: {α : Type u} {β : Type v} {l : List α} {f : α → β} (H : ∀ x ∈ l, ∀ y ∈ l, f x = f y → x = y) (d : l.Nodup)
Goal: (List.map f l).Nodup
-- List.inj_on_of_nodup_map
theorem inj_on_of_nodup_map {f : α → β} {l : List α} (d : Nodup (map f l)) :
    ∀ ⦃x⦄, x ∈ l → ∀ ⦃y⦄, y ∈ l → f x = f y → x = y 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : List α} (d : (List.map f l).Nodup) ⦃x : α⦄
Goal: x ∈ l → ∀ ⦃y : α⦄, y ∈ l → f x = f y → x = y
-- List.nodup_map_iff_inj_on
theorem nodup_map_iff_inj_on {f : α → β} {l : List α} (d : Nodup l) :
    Nodup (map f l) ↔ ∀ x ∈ l, ∀ y ∈ l, f x = f y → x = y 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : List α} (d : l.Nodup)
Goal: (List.map f l).Nodup ↔ ∀ x ∈ l, ∀ y ∈ l, f x = f y → x = y
-- List.Nodup.map
protected theorem Nodup.map {f : α → β} (hf : Injective f) : Nodup l → Nodup (map f l) 
Arguments: {α : Type u} {β : Type v} {l : List α} {f : α → β} (hf : Function.Injective f)
Goal: l.Nodup → (List.map f l).Nodup
-- List.nodup_map_iff
theorem nodup_map_iff {f : α → β} {l : List α} (hf : Injective f) : Nodup (map f l) ↔ Nodup l 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : List α} (hf : Function.Injective f)
Goal: (List.map f l).Nodup ↔ l.Nodup
-- List.nodup_attach
@[simp]
theorem nodup_attach {l : List α} : Nodup (attach l) ↔ Nodup l 
Arguments: {α : Type u} {l : List α}
Goal: l.attach.Nodup ↔ l.Nodup
-- List.Nodup.pmap
theorem Nodup.pmap {p : α → Prop} {f : ∀ a, p a → β} {l : List α} {H}
    (hf : ∀ a ha b hb, f a ha = f b hb → a = b) (h : Nodup l) : Nodup (pmap f l H) 
Arguments: {α : Type u} {β : Type v} {p : α → Prop} {f : (a : α) → p a → β} {l : List α} {H : ∀ a ∈ l, p a} (hf : ∀ (a : α) (ha : p a) (b : α) (hb : p b), f a ha = f b hb → a = b) (h : l.Nodup)
Goal: (List.pmap f l H).Nodup
-- List.Nodup.filter
theorem Nodup.filter (p : α → Bool) {l} : Nodup l → Nodup (filter p l) 
Arguments: {α : Type u} (p : α → Bool) {l : List α}
Goal: l.Nodup → (List.filter p l).Nodup
-- List.nodup_reverse
@[simp]
theorem nodup_reverse {l : List α} : Nodup (reverse l) ↔ Nodup l 
Arguments: {α : Type u} {l : List α}
Goal: l.reverse.Nodup ↔ l.Nodup
-- List.Nodup.erase_eq_filter
theorem Nodup.erase_eq_filter [DecidableEq α] {l} (d : Nodup l) (a : α) :
    l.erase a = l.filter (· ≠ a) 
Arguments: {α : Type u} [DecidableEq α] {l : List α} (d : l.Nodup) (a : α)
Goal: l.erase a = List.filter (fun x => decide (x ≠ a)) l
-- List.Nodup.erase
theorem Nodup.erase [DecidableEq α] (a : α) : Nodup l → Nodup (l.erase a) 
Arguments: {α : Type u} {l : List α} [DecidableEq α] (a : α)
Goal: l.Nodup → (l.erase a).Nodup
-- List.Nodup.erase_getElem
theorem Nodup.erase_getElem [DecidableEq α] {l : List α} (hl : l.Nodup)
    (i : Nat) (h : i < l.length) : l.erase l[i] = l.eraseIdx ↑i 
Arguments: {α : Type u} [DecidableEq α] {l : List α} (hl : l.Nodup) (i : ℕ) (h : i < l.length)
Goal: l.erase l[i] = l.eraseIdx i
-- List.Nodup.erase_get
theorem Nodup.erase_get [DecidableEq α] {l : List α} (hl : l.Nodup) (i : Fin l.length) :
    l.erase (l.get i) = l.eraseIdx ↑i 
Arguments: {α : Type u} [DecidableEq α] {l : List α} (hl : l.Nodup) (i : Fin l.length)
Goal: l.erase (l.get i) = l.eraseIdx ↑i
-- List.Nodup.diff
theorem Nodup.diff [DecidableEq α] : l₁.Nodup → (l₁.diff l₂).Nodup 
Arguments: {α : Type u} {l₁ l₂ : List α} [DecidableEq α]
Goal: l₁.Nodup → (l₁.diff l₂).Nodup
-- List.Nodup.mem_erase_iff
theorem Nodup.mem_erase_iff [DecidableEq α] (d : Nodup l) : a ∈ l.erase b ↔ a ≠ b ∧ a ∈ l 
Arguments: {α : Type u} {l : List α} {a b : α} [DecidableEq α] (d : l.Nodup)
Goal: a ∈ l.erase b ↔ a ≠ b ∧ a ∈ l
-- List.Nodup.not_mem_erase
theorem Nodup.not_mem_erase [DecidableEq α] (h : Nodup l) : a ∉ l.erase a 
Arguments: {α : Type u} {l : List α} {a : α} [DecidableEq α] (h : l.Nodup)
Goal: a ∉ l.erase a
-- List.nodup_join
theorem nodup_join {L : List (List α)} :
    Nodup (join L) ↔ (∀ l ∈ L, Nodup l) ∧ Pairwise Disjoint L 
Arguments: {α : Type u} {L : List (List α)}
Goal: L.join.Nodup ↔ (∀ l ∈ L, l.Nodup) ∧ List.Pairwise List.Disjoint L
-- List.nodup_bind
theorem nodup_bind {l₁ : List α} {f : α → List β} :
    Nodup (l₁.bind f) ↔
      (∀ x ∈ l₁, Nodup (f x)) ∧ Pairwise (fun a b : α => Disjoint (f a) (f b)) l₁ 
Arguments: {α : Type u} {β : Type v} {l₁ : List α} {f : α → List β}
Goal: (l₁.bind f).Nodup ↔ (∀ x ∈ l₁, (f x).Nodup) ∧ List.Pairwise (fun a b => (f a).Disjoint (f b)) l₁
-- List.Nodup.product
protected theorem Nodup.product {l₂ : List β} (d₁ : l₁.Nodup) (d₂ : l₂.Nodup) :
    (l₁ ×ˢ l₂).Nodup 
Arguments: {α : Type u} {β : Type v} {l₁ : List α} {l₂ : List β} (d₁ : l₁.Nodup) (d₂ : l₂.Nodup)
Goal: (l₁ ×ˢ l₂).Nodup
-- List.Nodup.sigma
theorem Nodup.sigma {σ : α → Type*} {l₂ : ∀ a , List (σ a)} (d₁ : Nodup l₁)
    (d₂ : ∀ a , Nodup (l₂ a)) : (l₁.sigma l₂).Nodup 
Arguments: {α : Type u} {l₁ : List α} {σ : α → Type u_1} {l₂ : (a : α) → List (σ a)} (d₁ : l₁.Nodup) (d₂ : ∀ (a : α), (l₂ a).Nodup)
Goal: (l₁.sigma l₂).Nodup
-- List.Nodup.filterMap
protected theorem Nodup.filterMap {f : α → Option β} (h : ∀ a a' b, b ∈ f a → b ∈ f a' → a = a') :
    Nodup l → Nodup (filterMap f l) 
Arguments: {α : Type u} {β : Type v} {l : List α} {f : α → Option β} (h : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a')
Goal: l.Nodup → (List.filterMap f l).Nodup
-- List.Nodup.concat
protected theorem Nodup.concat (h : a ∉ l) (h' : l.Nodup) : (l.concat a).Nodup 
Arguments: {α : Type u} {l : List α} {a : α} (h : a ∉ l) (h' : l.Nodup)
Goal: (l.concat a).Nodup
-- List.Nodup.insert
protected theorem Nodup.insert [DecidableEq α] (h : l.Nodup) : (l.insert a).Nodup 
Arguments: {α : Type u} {l : List α} {a : α} [DecidableEq α] (h : l.Nodup)
Goal: (List.insert a l).Nodup
-- List.Nodup.union
theorem Nodup.union [DecidableEq α] (l₁ : List α) (h : Nodup l₂) : (l₁ ∪ l₂).Nodup 
Arguments: {α : Type u} {l₂ : List α} [DecidableEq α] (l₁ : List α) (h : l₂.Nodup)
Goal: (l₁ ∪ l₂).Nodup
-- List.Nodup.inter
theorem Nodup.inter [DecidableEq α] (l₂ : List α) : Nodup l₁ → Nodup (l₁ ∩ l₂) 
Arguments: {α : Type u} {l₁ : List α} [DecidableEq α] (l₂ : List α)
Goal: l₁.Nodup → (l₁ ∩ l₂).Nodup
-- List.Nodup.diff_eq_filter
theorem Nodup.diff_eq_filter [DecidableEq α] :
    ∀ {l₁ l₂ : List α} (_ : l₁.Nodup), l₁.diff l₂ = l₁.filter (· ∉ l₂)
  
Arguments: {α : Type u} [DecidableEq α] {l₁ l₂ : List α}
Goal: l₁.Nodup → l₁.diff l₂ = List.filter (fun x => decide (x ∉ l₂)) l₁
-- List.Nodup.mem_diff_iff
theorem Nodup.mem_diff_iff [DecidableEq α] (hl₁ : l₁.Nodup) : a ∈ l₁.diff l₂ ↔ a ∈ l₁ ∧ a ∉ l₂ 
Arguments: {α : Type u} {l₁ l₂ : List α} {a : α} [DecidableEq α] (hl₁ : l₁.Nodup)
Goal: a ∈ l₁.diff l₂ ↔ a ∈ l₁ ∧ a ∉ l₂
-- List.Nodup.set
protected theorem Nodup.set :
    ∀ {l : List α} {n : ℕ} {a : α} (_ : l.Nodup) (_ : a ∉ l), (l.set n a).Nodup
  
Arguments: {α : Type u} {l : List α} {n : ℕ} {a : α}
Goal: l.Nodup → a ∉ l → (l.set n a).Nodup
-- List.Nodup.map_update
theorem Nodup.map_update [DecidableEq α] {l : List α} (hl : l.Nodup) (f : α → β) (x : α) (y : β) :
    l.map (Function.update f x y) =
      if x ∈ l then (l.map f).set (l.indexOf x) y else l.map f 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] {l : List α} (hl : l.Nodup) (f : α → β) (x : α) (y : β)
Goal: List.map (Function.update f x y) l = if x ∈ l then (List.map f l).set (List.indexOf x l) y else List.map f l
-- List.Nodup.pairwise_of_forall_ne
theorem Nodup.pairwise_of_forall_ne {l : List α} {r : α → α → Prop} (hl : l.Nodup)
    (h : ∀ a ∈ l, ∀ b ∈ l, a ≠ b → r a b) : l.Pairwise r 
Arguments: {α : Type u} {l : List α} {r : α → α → Prop} (hl : l.Nodup) (h : ∀ a ∈ l, ∀ b ∈ l, a ≠ b → r a b)
Goal: List.Pairwise r l
-- List.Nodup.pairwise_of_set_pairwise
theorem Nodup.pairwise_of_set_pairwise {l : List α} {r : α → α → Prop} (hl : l.Nodup)
    (h : { x | x ∈ l }.Pairwise r) : l.Pairwise r 
Arguments: {α : Type u} {l : List α} {r : α → α → Prop} (hl : l.Nodup) (h : {x | x ∈ l}.Pairwise r)
Goal: List.Pairwise r l
-- List.Nodup.pairwise_coe
@[simp]
theorem Nodup.pairwise_coe [IsSymm α r] (hl : l.Nodup) :
    { a | a ∈ l }.Pairwise r ↔ l.Pairwise r 
Arguments: {α : Type u} {l : List α} {r : α → α → Prop} [IsSymm α r] (hl : l.Nodup)
Goal: {a | a ∈ l}.Pairwise r ↔ List.Pairwise r l
-- List.Nodup.take_eq_filter_mem
theorem Nodup.take_eq_filter_mem [DecidableEq α] :
    ∀ {l : List α} {n : ℕ} (_ : l.Nodup), l.take n = l.filter (l.take n).elem
  
Arguments: {α : Type u} [DecidableEq α] {l : List α} {n : ℕ}
Goal: l.Nodup → List.take n l = List.filter (fun a => List.elem a (List.take n l)) l
-- Option.toList_nodup
theorem Option.toList_nodup : ∀ o : Option α, o.toList.Nodup
  
Arguments: {α : Type u} (o : Option α)
Goal: o.toList.Nodup
-- List.rdrop_nil
@[simp]
theorem rdrop_nil : rdrop ([] : List α) n = [] 
Arguments: {α : Type u_1} (n : ℕ)
Goal: [].rdrop n = []
-- List.rdrop_zero
@[simp]
theorem rdrop_zero : rdrop l 0 = l 
Arguments: {α : Type u_1} (l : List α)
Goal: l.rdrop 0 = l
-- List.rdrop_eq_reverse_drop_reverse
theorem rdrop_eq_reverse_drop_reverse : l.rdrop n = reverse (l.reverse.drop n) 
Arguments: {α : Type u_1} (l : List α) (n : ℕ)
Goal: l.rdrop n = (List.drop n l.reverse).reverse
-- List.rdrop_concat_succ
@[simp]
theorem rdrop_concat_succ (x : α) : rdrop (l ++ [x]) (n + 1) = rdrop l n 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (x : α)
Goal: (l ++ [x]).rdrop (n + 1) = l.rdrop n
-- List.rtake_nil
@[simp]
theorem rtake_nil : rtake ([] : List α) n = [] 
Arguments: {α : Type u_1} (n : ℕ)
Goal: [].rtake n = []
-- List.rtake_zero
@[simp]
theorem rtake_zero : rtake l 0 = [] 
Arguments: {α : Type u_1} (l : List α)
Goal: l.rtake 0 = []
-- List.rtake_eq_reverse_take_reverse
theorem rtake_eq_reverse_take_reverse : l.rtake n = reverse (l.reverse.take n) 
Arguments: {α : Type u_1} (l : List α) (n : ℕ)
Goal: l.rtake n = (List.take n l.reverse).reverse
-- List.rtake_concat_succ
@[simp]
theorem rtake_concat_succ (x : α) : rtake (l ++ [x]) (n + 1) = rtake l n ++ [x] 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (x : α)
Goal: (l ++ [x]).rtake (n + 1) = l.rtake n ++ [x]
-- List.rdropWhile_nil
@[simp]
theorem rdropWhile_nil : rdropWhile p ([] : List α) = [] 
Arguments: {α : Type u_1} (p : α → Bool)
Goal: List.rdropWhile p [] = []
-- List.rdropWhile_concat
theorem rdropWhile_concat (x : α) :
    rdropWhile p (l ++ [x]) = if p x then rdropWhile p l else l ++ [x] 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) (x : α)
Goal: List.rdropWhile p (l ++ [x]) = if p x = true then List.rdropWhile p l else l ++ [x]
-- List.rdropWhile_concat_pos
@[simp]
theorem rdropWhile_concat_pos (x : α) (h : p x) : rdropWhile p (l ++ [x]) = rdropWhile p l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) (x : α) (h : p x = true)
Goal: List.rdropWhile p (l ++ [x]) = List.rdropWhile p l
-- List.rdropWhile_concat_neg
@[simp]
theorem rdropWhile_concat_neg (x : α) (h : ¬p x) : rdropWhile p (l ++ [x]) = l ++ [x] 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) (x : α) (h : ¬p x = true)
Goal: List.rdropWhile p (l ++ [x]) = l ++ [x]
-- List.rdropWhile_singleton
theorem rdropWhile_singleton (x : α) : rdropWhile p [x] = if p x then [] else [x] 
Arguments: {α : Type u_1} (p : α → Bool) (x : α)
Goal: List.rdropWhile p [x] = if p x = true then [] else [x]
-- List.rdropWhile_last_not
theorem rdropWhile_last_not (hl : l.rdropWhile p ≠ []) : ¬p ((rdropWhile p l).getLast hl) 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) (hl : List.rdropWhile p l ≠ [])
Goal: ¬p ((List.rdropWhile p l).getLast hl) = true
-- List.rdropWhile_prefix
theorem rdropWhile_prefix : l.rdropWhile p <+: l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.rdropWhile p l <+: l
-- List.rdropWhile_eq_nil_iff
@[simp]
theorem rdropWhile_eq_nil_iff : rdropWhile p l = [] ↔ ∀ x ∈ l, p x 
Arguments: {α : Type u_1} {p : α → Bool} {l : List α}
Goal: List.rdropWhile p l = [] ↔ ∀ (x : α), x ∈ l → p x = true
-- List.dropWhile_eq_self_iff
@[simp]
theorem dropWhile_eq_self_iff : dropWhile p l = l ↔ ∀ hl : 0 < l.length, ¬p (l.get ⟨0, hl⟩) 
Arguments: {α : Type u_1} {p : α → Bool} {l : List α}
Goal: List.dropWhile p l = l ↔ ∀ (hl : 0 < l.length), ¬p (l.get ⟨0, hl⟩) = true
-- List.rdropWhile_eq_self_iff
@[simp]
theorem rdropWhile_eq_self_iff : rdropWhile p l = l ↔ ∀ hl : l ≠ [], ¬p (l.getLast hl) 
Arguments: {α : Type u_1} {p : α → Bool} {l : List α}
Goal: List.rdropWhile p l = l ↔ ∀ (hl : l ≠ []), ¬p (l.getLast hl) = true
-- List.dropWhile_idempotent
theorem dropWhile_idempotent : dropWhile p (dropWhile p l) = dropWhile p l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.dropWhile p (List.dropWhile p l) = List.dropWhile p l
-- List.rdropWhile_idempotent
theorem rdropWhile_idempotent : rdropWhile p (rdropWhile p l) = rdropWhile p l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.rdropWhile p (List.rdropWhile p l) = List.rdropWhile p l
-- List.rtakeWhile_nil
@[simp]
theorem rtakeWhile_nil : rtakeWhile p ([] : List α) = [] 
Arguments: {α : Type u_1} (p : α → Bool)
Goal: List.rtakeWhile p [] = []
-- List.rtakeWhile_concat
theorem rtakeWhile_concat (x : α) :
    rtakeWhile p (l ++ [x]) = if p x then rtakeWhile p l ++ [x] else [] 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) (x : α)
Goal: List.rtakeWhile p (l ++ [x]) = if p x = true then List.rtakeWhile p l ++ [x] else []
-- List.rtakeWhile_concat_pos
@[simp]
theorem rtakeWhile_concat_pos (x : α) (h : p x) :
    rtakeWhile p (l ++ [x]) = rtakeWhile p l ++ [x] 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) (x : α) (h : p x = true)
Goal: List.rtakeWhile p (l ++ [x]) = List.rtakeWhile p l ++ [x]
-- List.rtakeWhile_concat_neg
@[simp]
theorem rtakeWhile_concat_neg (x : α) (h : ¬p x) : rtakeWhile p (l ++ [x]) = [] 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α) (x : α) (h : ¬p x = true)
Goal: List.rtakeWhile p (l ++ [x]) = []
-- List.rtakeWhile_suffix
theorem rtakeWhile_suffix : l.rtakeWhile p <:+ l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.rtakeWhile p l <:+ l
-- List.rtakeWhile_eq_self_iff
@[simp]
theorem rtakeWhile_eq_self_iff : rtakeWhile p l = l ↔ ∀ x ∈ l, p x 
Arguments: {α : Type u_1} {p : α → Bool} {l : List α}
Goal: List.rtakeWhile p l = l ↔ ∀ (x : α), x ∈ l → p x = true
-- List.rtakeWhile_eq_nil_iff
@[simp]
theorem rtakeWhile_eq_nil_iff : rtakeWhile p l = [] ↔ ∀ hl : l ≠ [], ¬p (l.getLast hl) 
Arguments: {α : Type u_1} {p : α → Bool} {l : List α}
Goal: List.rtakeWhile p l = [] ↔ ∀ (hl : l ≠ []), ¬p (l.getLast hl) = true
-- List.mem_rtakeWhile_imp
theorem mem_rtakeWhile_imp {x : α} (hx : x ∈ rtakeWhile p l) : p x 
Arguments: {α : Type u_1} {p : α → Bool} {l : List α} {x : α} (hx : x ∈ List.rtakeWhile p l)
Goal: p x = true
-- List.rtakeWhile_idempotent
theorem rtakeWhile_idempotent (p : α → Bool) (l : List α) :
    rtakeWhile p (rtakeWhile p l) = rtakeWhile p l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.rtakeWhile p (List.rtakeWhile p l) = List.rtakeWhile p l
-- List.rdrop_add
lemma rdrop_add (i j : ℕ) : (l.rdrop i).rdrop j = l.rdrop (i + j) 
Arguments: {α : Type u_1} {l : List α} (i j : ℕ)
Goal: (l.rdrop i).rdrop j = l.rdrop (i + j)
-- List.rdrop_append_length
@[simp]
lemma rdrop_append_length {l₁ l₂ : List α} :
    List.rdrop (l₁ ++ l₂) (List.length l₂) = l₁ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: (l₁ ++ l₂).rdrop l₂.length = l₁
-- List.rdrop_append_of_le_length
lemma rdrop_append_of_le_length {l₁ l₂ : List α} (k : ℕ) :
    k ≤ length l₂ → List.rdrop (l₁ ++ l₂) k = l₁ ++ List.rdrop l₂ k 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (k : ℕ)
Goal: k ≤ l₂.length → (l₁ ++ l₂).rdrop k = l₁ ++ l₂.rdrop k
-- List.rdrop_append_length_add
@[simp]
lemma rdrop_append_length_add {l₁ l₂ : List α} (k : ℕ) :
    List.rdrop (l₁ ++ l₂) (length l₂ + k) = List.rdrop l₁ k 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (k : ℕ)
Goal: (l₁ ++ l₂).rdrop (l₂.length + k) = l₁.rdrop k
-- List.length_iterate
@[simp]
theorem length_iterate (f : α → α) (a : α) (n : ℕ) : length (iterate f a n) = n 
Arguments: {α : Type u_1} (f : α → α) (a : α) (n : ℕ)
Goal: (List.iterate f a n).length = n
-- List.iterate_eq_nil
@[simp]
theorem iterate_eq_nil {f : α → α} {a : α} {n : ℕ} : iterate f a n = [] ↔ n = 0 
Arguments: {α : Type u_1} {f : α → α} {a : α} {n : ℕ}
Goal: List.iterate f a n = [] ↔ n = 0
-- List.getElem?_iterate
theorem getElem?_iterate (f : α → α) (a : α) :
    ∀ (n i : ℕ), i < n → (iterate f a n)[i]? = f^[i] a
  
Arguments: {α : Type u_1} (f : α → α) (a : α) (n i : ℕ)
Goal: i < n → (List.iterate f a n)[i]? = some (f^[i] a)
-- List.get?_iterate
theorem get?_iterate (f : α → α) (a : α) (n i : ℕ) (h : i < n) :
    get? (iterate f a n) i = f^[i] a 
Arguments: {α : Type u_1} (f : α → α) (a : α) (n i : ℕ) (h : i < n)
Goal: (List.iterate f a n).get? i = some (f^[i] a)
-- List.getElem_iterate
@[simp]
theorem getElem_iterate (f : α → α) (a : α) (n : ℕ) (i : Nat) (h : i < (iterate f a n).length) :
    (iterate f a n)[i] = f^[↑i] a 
Arguments: {α : Type u_1} (f : α → α) (a : α) (n i : ℕ) (h : i < (List.iterate f a n).length)
Goal: (List.iterate f a n)[i] = f^[i] a
-- List.get_iterate
theorem get_iterate (f : α → α) (a : α) (n : ℕ) (i : Fin (iterate f a n).length) :
    get (iterate f a n) i = f^[↑i] a 
Arguments: {α : Type u_1} (f : α → α) (a : α) (n : ℕ) (i : Fin (List.iterate f a n).length)
Goal: (List.iterate f a n).get i = f^[↑i] a
-- List.mem_iterate
@[simp]
theorem mem_iterate {f : α → α} {a : α} {n : ℕ} {b : α} :
    b ∈ iterate f a n ↔ ∃ m < n, b = f^[m] a 
Arguments: {α : Type u_1} {f : α → α} {a : α} {n : ℕ} {b : α}
Goal: b ∈ List.iterate f a n ↔ ∃ m < n, b = f^[m] a
-- List.range_map_iterate
@[simp]
theorem range_map_iterate (n : ℕ) (f : α → α) (a : α) :
    (List.range n).map (f^[·] a) = List.iterate f a n 
Arguments: {α : Type u_1} (n : ℕ) (f : α → α) (a : α)
Goal: List.map (fun x => f^[x] a) (List.range n) = List.iterate f a n
-- List.iterate_add
theorem iterate_add (f : α → α) (a : α) (m n : ℕ) :
    iterate f a (m + n) = iterate f a m ++ iterate f (f^[m] a) n 
Arguments: {α : Type u_1} (f : α → α) (a : α) (m n : ℕ)
Goal: List.iterate f a (m + n) = List.iterate f a m ++ List.iterate f (f^[m] a) n