ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.Ioc_filter_dvd_eq
lemma Ioc_filter_dvd_eq : (Ioc a b).filter (r ∣ ·) =
    (Ioc ⌊a / (r : ℚ)⌋ ⌊b / (r : ℚ)⌋).map ⟨(· * r), mul_left_injective₀ hr.ne'⟩ 
Arguments: (a b : ℤ) {r : ℤ} (hr : 0 < r)
Goal: Finset.filter (fun x => r ∣ x) (Finset.Ioc a b) =
  Finset.map { toFun := fun x => x * r, inj' := ⋯ } (Finset.Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)
-- Int.Ico_filter_dvd_card
theorem Ico_filter_dvd_card : ((Ico a b).filter (r ∣ ·)).card =
    max (⌈b / (r : ℚ)⌉ - ⌈a / (r : ℚ)⌉) 0 
Arguments: (a b : ℤ) {r : ℤ} (hr : 0 < r)
Goal: ↑(Finset.filter (fun x => r ∣ x) (Finset.Ico a b)).card = max (⌈↑b / ↑r⌉ - ⌈↑a / ↑r⌉) 0
-- Int.Ioc_filter_dvd_card
theorem Ioc_filter_dvd_card : ((Ioc a b).filter (r ∣ ·)).card =
    max (⌊b / (r : ℚ)⌋ - ⌊a / (r : ℚ)⌋) 0 
Arguments: (a b : ℤ) {r : ℤ} (hr : 0 < r)
Goal: ↑(Finset.filter (fun x => r ∣ x) (Finset.Ioc a b)).card = max (⌊↑b / ↑r⌋ - ⌊↑a / ↑r⌋) 0
-- Int.Ico_filter_modEq_eq
lemma Ico_filter_modEq_eq (v : ℤ) : (Ico a b).filter (· ≡ v [ZMOD r]) =
    ((Ico (a - v) (b - v)).filter (r ∣ ·)).map ⟨(· + v), add_left_injective v⟩ 
Arguments: (a b : ℤ) {r : ℤ} (v : ℤ)
Goal: Finset.filter (fun x => x ≡ v [ZMOD r]) (Finset.Ico a b) =
  Finset.map { toFun := fun x => x + v, inj' := ⋯ } (Finset.filter (fun x => r ∣ x) (Finset.Ico (a - v) (b - v)))
-- Int.Ioc_filter_modEq_eq
lemma Ioc_filter_modEq_eq (v : ℤ) : (Ioc a b).filter (· ≡ v [ZMOD r]) =
    ((Ioc (a - v) (b - v)).filter (r ∣ ·)).map ⟨(· + v), add_left_injective v⟩ 
Arguments: (a b : ℤ) {r : ℤ} (v : ℤ)
Goal: Finset.filter (fun x => x ≡ v [ZMOD r]) (Finset.Ioc a b) =
  Finset.map { toFun := fun x => x + v, inj' := ⋯ } (Finset.filter (fun x => r ∣ x) (Finset.Ioc (a - v) (b - v)))
-- Int.Ico_filter_modEq_card
theorem Ico_filter_modEq_card (v : ℤ) : ((Ico a b).filter (· ≡ v [ZMOD r])).card =
    max (⌈(b - v) / (r : ℚ)⌉ - ⌈(a - v) / (r : ℚ)⌉) 0 
Arguments: (a b : ℤ) {r : ℤ} (hr : 0 < r) (v : ℤ)
Goal: ↑(Finset.filter (fun x => x ≡ v [ZMOD r]) (Finset.Ico a b)).card = max (⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑a - ↑v) / ↑r⌉) 0
-- Int.Ioc_filter_modEq_card
theorem Ioc_filter_modEq_card (v : ℤ) : ((Ioc a b).filter (· ≡ v [ZMOD r])).card =
    max (⌊(b - v) / (r : ℚ)⌋ - ⌊(a - v) / (r : ℚ)⌋) 0 
Arguments: (a b : ℤ) {r : ℤ} (hr : 0 < r) (v : ℤ)
Goal: ↑(Finset.filter (fun x => x ≡ v [ZMOD r]) (Finset.Ioc a b)).card = max (⌊(↑b - ↑v) / ↑r⌋ - ⌊(↑a - ↑v) / ↑r⌋) 0
-- Nat.Ico_filter_modEq_cast
lemma Ico_filter_modEq_cast {v : ℕ} : ((Ico a b).filter (· ≡ v [MOD r])).map castEmbedding =
    (Ico (a : ℤ) (b : ℤ)).filter (· ≡ v [ZMOD r]) 
Arguments: (a b : ℕ) {r v : ℕ}
Goal: Finset.map Nat.castEmbedding (Finset.filter (fun x => x ≡ v [MOD r]) (Finset.Ico a b)) =
  Finset.filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Finset.Ico ↑a ↑b)
-- Nat.Ioc_filter_modEq_cast
lemma Ioc_filter_modEq_cast {v : ℕ} : ((Ioc a b).filter (· ≡ v [MOD r])).map castEmbedding =
    (Ioc (a : ℤ) (b : ℤ)).filter (· ≡ v [ZMOD r]) 
Arguments: (a b : ℕ) {r v : ℕ}
Goal: Finset.map Nat.castEmbedding (Finset.filter (fun x => x ≡ v [MOD r]) (Finset.Ioc a b)) =
  Finset.filter (fun x => x ≡ ↑v [ZMOD ↑r]) (Finset.Ioc ↑a ↑b)
-- Nat.Ico_filter_modEq_card
theorem Ico_filter_modEq_card (v : ℕ) : ((Ico a b).filter (· ≡ v [MOD r])).card =
    max (⌈(b - v) / (r : ℚ)⌉ - ⌈(a - v) / (r : ℚ)⌉) 0 
Arguments: (a b : ℕ) {r : ℕ} (hr : 0 < r) (v : ℕ)
Goal: ↑(Finset.filter (fun x => x ≡ v [MOD r]) (Finset.Ico a b)).card = max (⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑a - ↑v) / ↑r⌉) 0
-- Nat.Ioc_filter_modEq_card
theorem Ioc_filter_modEq_card (v : ℕ) : ((Ioc a b).filter (· ≡ v [MOD r])).card =
    max (⌊(b - v) / (r : ℚ)⌋ - ⌊(a - v) / (r : ℚ)⌋) 0 
Arguments: (a b : ℕ) {r : ℕ} (hr : 0 < r) (v : ℕ)
Goal: ↑(Finset.filter (fun x => x ≡ v [MOD r]) (Finset.Ioc a b)).card = max (⌊(↑b - ↑v) / ↑r⌋ - ⌊(↑a - ↑v) / ↑r⌋) 0
-- Nat.count_modEq_card_eq_ceil
theorem count_modEq_card_eq_ceil (v : ℕ) :
    b.count (· ≡ v [MOD r]) = ⌈(b - (v % r : ℕ)) / (r : ℚ)⌉ 
Arguments: (b : ℕ) {r : ℕ} (hr : 0 < r) (v : ℕ)
Goal: ↑(Nat.count (fun x => x ≡ v [MOD r]) b) = ⌈(↑b - ↑(v % r)) / ↑r⌉
-- Nat.count_modEq_card
theorem count_modEq_card (v : ℕ) :
    b.count (· ≡ v [MOD r]) = b / r + if v % r < b % r then 1 else 0 
Arguments: (b : ℕ) {r : ℕ} (hr : 0 < r) (v : ℕ)
Goal: Nat.count (fun x => x ≡ v [MOD r]) b = b / r + if v % r < b % r then 1 else 0
-- List.Palindrome.reverse_eq
theorem reverse_eq {l : List α} (p : Palindrome l) : reverse l = l 
Arguments: {α : Type u_1} {l : List α} (p : l.Palindrome)
Goal: l.reverse = l
-- List.Palindrome.of_reverse_eq
theorem of_reverse_eq {l : List α} : reverse l = l → Palindrome l 
Arguments: {α : Type u_1} {l : List α}
Goal: l.reverse = l → l.Palindrome
-- List.Palindrome.iff_reverse_eq
theorem iff_reverse_eq {l : List α} : Palindrome l ↔ reverse l = l 
Arguments: {α : Type u_1} {l : List α}
Goal: l.Palindrome ↔ l.reverse = l
-- List.Palindrome.append_reverse
theorem append_reverse (l : List α) : Palindrome (l ++ reverse l) 
Arguments: {α : Type u_1} (l : List α)
Goal: (l ++ l.reverse).Palindrome
-- List.Palindrome.map
protected theorem map (f : α → β) (p : Palindrome l) : Palindrome (map f l) 
Arguments: {α : Type u_1} {β : Type u_2} {l : List α} (f : α → β) (p : l.Palindrome)
Goal: (List.map f l).Palindrome
-- List.reduceOption_cons_of_some
@[simp]
theorem reduceOption_cons_of_some (x : α) (l : List (Option α)) :
    reduceOption (some x :: l) = x :: l.reduceOption 
Arguments: {α : Type u_1} (x : α) (l : List (Option α))
Goal: (some x :: l).reduceOption = x :: l.reduceOption
-- List.reduceOption_cons_of_none
@[simp]
theorem reduceOption_cons_of_none (l : List (Option α)) :
    reduceOption (none :: l) = l.reduceOption 
Arguments: {α : Type u_1} (l : List (Option α))
Goal: (none :: l).reduceOption = l.reduceOption
-- List.reduceOption_nil
@[simp]
theorem reduceOption_nil : @reduceOption α [] = [] 
Arguments: {α : Type u_1}
Goal: [].reduceOption = []
-- List.reduceOption_map
@[simp]
theorem reduceOption_map {l : List (Option α)} {f : α → β} :
    reduceOption (map (Option.map f) l) = map f (reduceOption l) 
Arguments: {α : Type u_1} {β : Type u_2} {l : List (Option α)} {f : α → β}
Goal: (List.map (Option.map f) l).reduceOption = List.map f l.reduceOption
-- List.reduceOption_append
theorem reduceOption_append (l l' : List (Option α)) :
    (l ++ l').reduceOption = l.reduceOption ++ l'.reduceOption 
Arguments: {α : Type u_1} (l l' : List (Option α))
Goal: (l ++ l').reduceOption = l.reduceOption ++ l'.reduceOption
-- List.reduceOption_length_eq
theorem reduceOption_length_eq {l : List (Option α)} :
    l.reduceOption.length = (l.filter Option.isSome).length 
Arguments: {α : Type u_1} {l : List (Option α)}
Goal: l.reduceOption.length = (List.filter Option.isSome l).length
-- List.length_eq_reduceOption_length_add_filter_none
theorem length_eq_reduceOption_length_add_filter_none {l : List (Option α)} :
    l.length = l.reduceOption.length + (l.filter Option.isNone).length 
Arguments: {α : Type u_1} {l : List (Option α)}
Goal: l.length = l.reduceOption.length + (List.filter Option.isNone l).length
-- List.reduceOption_length_le
theorem reduceOption_length_le (l : List (Option α)) : l.reduceOption.length ≤ l.length 
Arguments: {α : Type u_1} (l : List (Option α))
Goal: l.reduceOption.length ≤ l.length
-- List.reduceOption_length_eq_iff
theorem reduceOption_length_eq_iff {l : List (Option α)} :
    l.reduceOption.length = l.length ↔ ∀ x ∈ l, Option.isSome x 
Arguments: {α : Type u_1} {l : List (Option α)}
Goal: l.reduceOption.length = l.length ↔ ∀ (x : Option α), x ∈ l → x.isSome = true
-- List.reduceOption_length_lt_iff
theorem reduceOption_length_lt_iff {l : List (Option α)} :
    l.reduceOption.length < l.length ↔ none ∈ l 
Arguments: {α : Type u_1} {l : List (Option α)}
Goal: l.reduceOption.length < l.length ↔ none ∈ l
-- List.reduceOption_singleton
theorem reduceOption_singleton (x : Option α) : [x].reduceOption = x.toList 
Arguments: {α : Type u_1} (x : Option α)
Goal: [x].reduceOption = x.toList
-- List.reduceOption_concat
theorem reduceOption_concat (l : List (Option α)) (x : Option α) :
    (l.concat x).reduceOption = l.reduceOption ++ x.toList 
Arguments: {α : Type u_1} (l : List (Option α)) (x : Option α)
Goal: (l.concat x).reduceOption = l.reduceOption ++ x.toList
-- List.reduceOption_concat_of_some
theorem reduceOption_concat_of_some (l : List (Option α)) (x : α) :
    (l.concat (some x)).reduceOption = l.reduceOption.concat x 
Arguments: {α : Type u_1} (l : List (Option α)) (x : α)
Goal: (l.concat (some x)).reduceOption = l.reduceOption.concat x
-- List.reduceOption_mem_iff
theorem reduceOption_mem_iff {l : List (Option α)} {x : α} : x ∈ l.reduceOption ↔ some x ∈ l 
Arguments: {α : Type u_1} {l : List (Option α)} {x : α}
Goal: x ∈ l.reduceOption ↔ some x ∈ l
-- List.reduceOption_get?_iff
theorem reduceOption_get?_iff {l : List (Option α)} {x : α} :
    (∃ i, l.get? i = some (some x)) ↔ ∃ i, l.reduceOption.get? i = some x 
Arguments: {α : Type u_1} {l : List (Option α)} {x : α}
Goal: (∃ i, l.get? i = some (some x)) ↔ ∃ i, l.reduceOption.get? i = some x
-- List.prefix_rfl
theorem prefix_rfl : l <+: l 
Arguments: {α : Type u_1} {l : List α}
Goal: l <+: l
-- List.suffix_rfl
theorem suffix_rfl : l <:+ l 
Arguments: {α : Type u_1} {l : List α}
Goal: l <:+ l
-- List.infix_rfl
theorem infix_rfl : l <:+: l 
Arguments: {α : Type u_1} {l : List α}
Goal: l <:+: l
-- List.prefix_concat
theorem prefix_concat (a : α) (l) : l <+: concat l a 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: l <+: l.concat a
-- List.prefix_concat_iff
theorem prefix_concat_iff {l₁ l₂ : List α} {a : α} :
    l₁ <+: l₂ ++ [a] ↔ l₁ = l₂ ++ [a] ∨ l₁ <+: l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {a : α}
Goal: l₁ <+: l₂ ++ [a] ↔ l₁ = l₂ ++ [a] ∨ l₁ <+: l₂
-- List.eq_of_infix_of_length_eq
theorem eq_of_infix_of_length_eq (h : l₁ <:+: l₂) : l₁.length = l₂.length → l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <:+: l₂)
Goal: l₁.length = l₂.length → l₁ = l₂
-- List.eq_of_prefix_of_length_eq
theorem eq_of_prefix_of_length_eq (h : l₁ <+: l₂) : l₁.length = l₂.length → l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <+: l₂)
Goal: l₁.length = l₂.length → l₁ = l₂
-- List.eq_of_suffix_of_length_eq
theorem eq_of_suffix_of_length_eq (h : l₁ <:+ l₂) : l₁.length = l₂.length → l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (h : l₁ <:+ l₂)
Goal: l₁.length = l₂.length → l₁ = l₂
-- List.dropSlice_sublist
lemma dropSlice_sublist (n m : ℕ) (l : List α) : l.dropSlice n m <+ l 
Arguments: {α : Type u_1} (n m : ℕ) (l : List α)
Goal: (List.dropSlice n m l).Sublist l
-- List.dropSlice_subset
lemma dropSlice_subset (n m : ℕ) (l : List α) : l.dropSlice n m ⊆ l 
Arguments: {α : Type u_1} (n m : ℕ) (l : List α)
Goal: List.dropSlice n m l ⊆ l
-- List.mem_of_mem_dropSlice
lemma mem_of_mem_dropSlice {n m : ℕ} {l : List α} {a : α} (h : a ∈ l.dropSlice n m) : a ∈ l 
Arguments: {α : Type u_1} {n m : ℕ} {l : List α} {a : α} (h : a ∈ List.dropSlice n m l)
Goal: a ∈ l
-- List.takeWhile_prefix
theorem takeWhile_prefix (p : α → Bool) : l.takeWhile p <+: l 
Arguments: {α : Type u_1} {l : List α} (p : α → Bool)
Goal: List.takeWhile p l <+: l
-- List.dropWhile_suffix
theorem dropWhile_suffix (p : α → Bool) : l.dropWhile p <:+ l 
Arguments: {α : Type u_1} {l : List α} (p : α → Bool)
Goal: List.dropWhile p l <:+ l
-- List.dropLast_prefix
theorem dropLast_prefix : ∀ l : List α, l.dropLast <+: l
  
Arguments: {α : Type u_1} (l : List α)
Goal: l.dropLast <+: l
-- List.tail_suffix
theorem tail_suffix (l : List α) : tail l <:+ l 
Arguments: {α : Type u_1} (l : List α)
Goal: l.tail <:+ l
-- List.dropLast_sublist
theorem dropLast_sublist (l : List α) : l.dropLast <+ l 
Arguments: {α : Type u_1} (l : List α)
Goal: l.dropLast.Sublist l
-- List.drop_sublist_drop_left
@[gcongr]
theorem drop_sublist_drop_left (l : List α) {m n : ℕ} (h : m ≤ n) : drop n l <+ drop m l 
Arguments: {α : Type u_1} (l : List α) {m n : ℕ} (h : m ≤ n)
Goal: (List.drop n l).Sublist (List.drop m l)
-- List.dropLast_subset
theorem dropLast_subset (l : List α) : l.dropLast ⊆ l 
Arguments: {α : Type u_1} (l : List α)
Goal: l.dropLast ⊆ l
-- List.tail_subset
theorem tail_subset (l : List α) : tail l ⊆ l 
Arguments: {α : Type u_1} (l : List α)
Goal: l.tail ⊆ l
-- List.mem_of_mem_dropLast
theorem mem_of_mem_dropLast (h : a ∈ l.dropLast) : a ∈ l 
Arguments: {α : Type u_1} {l : List α} {a : α} (h : a ∈ l.dropLast)
Goal: a ∈ l
-- List.mem_of_mem_tail
theorem mem_of_mem_tail (h : a ∈ l.tail) : a ∈ l 
Arguments: {α : Type u_1} {l : List α} {a : α} (h : a ∈ l.tail)
Goal: a ∈ l
-- List.Sublist.drop
@[gcongr]
protected theorem Sublist.drop : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → ∀ n, l₁.drop n <+ l₂.drop n
  
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁.Sublist l₂ → ∀ (n : ℕ), (List.drop n l₁).Sublist (List.drop n l₂)
-- List.prefix_iff_eq_append
theorem prefix_iff_eq_append : l₁ <+: l₂ ↔ l₁ ++ drop (length l₁) l₂ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <+: l₂ ↔ l₁ ++ List.drop l₁.length l₂ = l₂
-- List.suffix_iff_eq_append
theorem suffix_iff_eq_append : l₁ <:+ l₂ ↔ take (length l₂ - length l₁) l₂ ++ l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <:+ l₂ ↔ List.take (l₂.length - l₁.length) l₂ ++ l₁ = l₂
-- List.prefix_iff_eq_take
theorem prefix_iff_eq_take : l₁ <+: l₂ ↔ l₁ = take (length l₁) l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <+: l₂ ↔ l₁ = List.take l₁.length l₂
-- List.prefix_take_iff
theorem prefix_take_iff {x y : List α} {n : ℕ} : x <+: y.take n ↔ x <+: y ∧ x.length ≤ n 
Arguments: {α : Type u_1} {x y : List α} {n : ℕ}
Goal: x <+: List.take n y ↔ x <+: y ∧ x.length ≤ n
-- List.concat_get_prefix
theorem concat_get_prefix {x y : List α} (h : x <+: y) (hl : x.length < y.length) :
    x ++ [y.get ⟨x.length, hl⟩] <+: y 
Arguments: {α : Type u_1} {x y : List α} (h : x <+: y) (hl : x.length < y.length)
Goal: x ++ [y.get ⟨x.length, hl⟩] <+: y
-- List.suffix_iff_eq_drop
theorem suffix_iff_eq_drop : l₁ <:+ l₂ ↔ l₁ = drop (length l₂ - length l₁) l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <:+ l₂ ↔ l₁ = List.drop (l₂.length - l₁.length) l₂
-- List.prefix_take_le_iff
theorem prefix_take_le_iff {L : List (List (Option α))} (hm : m < L.length) :
    L.take m <+: L.take n ↔ m ≤ n 
Arguments: {α : Type u_1} {m n : ℕ} {L : List (List (Option α))} (hm : m < L.length)
Goal: List.take m L <+: List.take n L ↔ m ≤ n
-- List.cons_prefix_iff
theorem cons_prefix_iff : a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {a b : α}
Goal: a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂
-- List.IsPrefix.map
protected theorem IsPrefix.map (h : l₁ <+: l₂) (f : α → β) : l₁.map f <+: l₂.map f 
Arguments: {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α} (h : l₁ <+: l₂) (f : α → β)
Goal: List.map f l₁ <+: List.map f l₂
-- List.IsPrefix.filterMap
protected theorem IsPrefix.filterMap (h : l₁ <+: l₂) (f : α → Option β) :
    l₁.filterMap f <+: l₂.filterMap f 
Arguments: {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α} (h : l₁ <+: l₂) (f : α → Option β)
Goal: List.filterMap f l₁ <+: List.filterMap f l₂
-- List.IsPrefix.reduceOption
protected theorem IsPrefix.reduceOption {l₁ l₂ : List (Option α)} (h : l₁ <+: l₂) :
    l₁.reduceOption <+: l₂.reduceOption 
Arguments: {α : Type u_1} {l₁ l₂ : List (Option α)} (h : l₁ <+: l₂)
Goal: l₁.reduceOption <+: l₂.reduceOption
-- List.mem_inits
@[simp]
theorem mem_inits : ∀ s t : List α, s ∈ inits t ↔ s <+: t
  
Arguments: {α : Type u_1} (s t : List α)
Goal: s ∈ t.inits ↔ s <+: t
-- List.mem_tails
@[simp]
theorem mem_tails : ∀ s t : List α, s ∈ tails t ↔ s <:+ t
  
Arguments: {α : Type u_1} (s t : List α)
Goal: s ∈ t.tails ↔ s <:+ t
-- List.inits_cons
theorem inits_cons (a : α) (l : List α) : inits (a :: l) = [] :: l.inits.map fun t => a :: t 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: (a :: l).inits = [] :: List.map (fun t => a :: t) l.inits
-- List.tails_cons
theorem tails_cons (a : α) (l : List α) : tails (a :: l) = (a :: l) :: l.tails 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: (a :: l).tails = (a :: l) :: l.tails
-- List.inits_append
@[simp]
theorem inits_append : ∀ s t : List α, inits (s ++ t) = s.inits ++ t.inits.tail.map fun l => s ++ l
  
Arguments: {α : Type u_1} (s t : List α)
Goal: (s ++ t).inits = s.inits ++ List.map (fun l => s ++ l) t.inits.tail
-- List.tails_append
@[simp]
theorem tails_append :
    ∀ s t : List α, tails (s ++ t) = (s.tails.map fun l => l ++ t) ++ t.tails.tail
  
Arguments: {α : Type u_1} (s t : List α)
Goal: (s ++ t).tails = List.map (fun l => l ++ t) s.tails ++ t.tails.tail
-- List.inits_eq_tails
theorem inits_eq_tails : ∀ l : List α, l.inits = (reverse <| map reverse <| tails <| reverse l)
  
Arguments: {α : Type u_1} (l : List α)
Goal: l.inits = (List.map List.reverse l.reverse.tails).reverse
-- List.tails_eq_inits
theorem tails_eq_inits : ∀ l : List α, l.tails = (reverse <| map reverse <| inits <| reverse l)
  
Arguments: {α : Type u_1} (l : List α)
Goal: l.tails = (List.map List.reverse l.reverse.inits).reverse
-- List.inits_reverse
theorem inits_reverse (l : List α) : inits (reverse l) = reverse (map reverse l.tails) 
Arguments: {α : Type u_1} (l : List α)
Goal: l.reverse.inits = (List.map List.reverse l.tails).reverse
-- List.tails_reverse
theorem tails_reverse (l : List α) : tails (reverse l) = reverse (map reverse l.inits) 
Arguments: {α : Type u_1} (l : List α)
Goal: l.reverse.tails = (List.map List.reverse l.inits).reverse
-- List.map_reverse_inits
theorem map_reverse_inits (l : List α) : map reverse l.inits = (reverse <| tails <| reverse l) 
Arguments: {α : Type u_1} (l : List α)
Goal: List.map List.reverse l.inits = l.reverse.tails.reverse
-- List.map_reverse_tails
theorem map_reverse_tails (l : List α) : map reverse l.tails = (reverse <| inits <| reverse l) 
Arguments: {α : Type u_1} (l : List α)
Goal: List.map List.reverse l.tails = l.reverse.inits.reverse
-- List.length_tails
@[simp]
theorem length_tails (l : List α) : length (tails l) = length l + 1 
Arguments: {α : Type u_1} (l : List α)
Goal: l.tails.length = l.length + 1
-- List.length_inits
@[simp]
theorem length_inits (l : List α) : length (inits l) = length l + 1 
Arguments: {α : Type u_1} (l : List α)
Goal: l.inits.length = l.length + 1
-- List.getElem_tails
@[simp]
theorem getElem_tails (l : List α) (n : Nat) (h : n < (tails l).length) :
    (tails l)[n] = l.drop n 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (h : n < l.tails.length)
Goal: l.tails[n] = List.drop n l
-- List.get_tails
theorem get_tails (l : List α) (n : Fin (length (tails l))) : (tails l).get n = l.drop n 
Arguments: {α : Type u_1} (l : List α) (n : Fin l.tails.length)
Goal: l.tails.get n = List.drop (↑n) l
-- List.getElem_inits
@[simp]
theorem getElem_inits (l : List α) (n : Nat) (h : n < length (inits l)) :
    (inits l)[n] = l.take n 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (h : n < l.inits.length)
Goal: l.inits[n] = List.take n l
-- List.get_inits
theorem get_inits (l : List α) (n : Fin (length (inits l))) : (inits l).get n = l.take n 
Arguments: {α : Type u_1} (l : List α) (n : Fin l.inits.length)
Goal: l.inits.get n = List.take (↑n) l
-- List.nth_le_tails
@[simp, deprecated get_tails (since := "2024-04-16")]
theorem nth_le_tails (l : List α) (n : ℕ) (hn : n < length (tails l)) :
    nthLe (tails l) n hn = l.drop n 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (hn : n < l.tails.length)
Goal: l.tails.nthLe n hn = List.drop n l
-- List.nth_le_inits
@[simp, deprecated get_inits (since := "2024-04-16")]
theorem nth_le_inits (l : List α) (n : ℕ) (hn : n < length (inits l)) :
    nthLe (inits l) n hn = l.take n 
Arguments: {α : Type u_1} (l : List α) (n : ℕ) (hn : n < l.inits.length)
Goal: l.inits.nthLe n hn = List.take n l
-- List.insert_eq_ite
theorem insert_eq_ite (a : α) (l : List α) : insert a l = if a ∈ l then l else a :: l 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: insert a l = if a ∈ l then l else a :: l
-- List.suffix_insert
@[simp]
theorem suffix_insert (a : α) (l : List α) : l <:+ l.insert a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: l <:+ List.insert a l
-- List.infix_insert
theorem infix_insert (a : α) (l : List α) : l <:+: l.insert a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: l <:+: List.insert a l
-- List.sublist_insert
theorem sublist_insert (a : α) (l : List α) : l <+ l.insert a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: l.Sublist (List.insert a l)
-- List.subset_insert
theorem subset_insert (a : α) (l : List α) : l ⊆ l.insert a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: l ⊆ List.insert a l
-- List.mem_of_mem_suffix
theorem mem_of_mem_suffix (hx : a ∈ l₁) (hl : l₁ <:+ l₂) : a ∈ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {a : α} (hx : a ∈ l₁) (hl : l₁ <:+ l₂)
Goal: a ∈ l₂
-- List.IsPrefix.ne_nil
theorem IsPrefix.ne_nil {x y : List α} (h : x <+: y) (hx : x ≠ []) : y ≠ [] 
Arguments: {α : Type u_1} {x y : List α} (h : x <+: y) (hx : x ≠ [])
Goal: y ≠ []
-- List.IsPrefix.getElem
theorem IsPrefix.getElem {x y : List α} (h : x <+: y) {n} (hn : n < x.length) :
    x[n] = y[n]'(hn.trans_le h.length_le) 
Arguments: {α : Type u_1} {x y : List α} (h : x <+: y) {n : ℕ} (hn : n < x.length)
Goal: x[n] = y[n]
-- List.IsPrefix.get_eq
theorem IsPrefix.get_eq {x y : List α} (h : x <+: y) {n} (hn : n < x.length) :
    x.get ⟨n, hn⟩ = y.get ⟨n, hn.trans_le h.length_le⟩ 
Arguments: {α : Type u_1} {x y : List α} (h : x <+: y) {n : ℕ} (hn : n < x.length)
Goal: x.get ⟨n, hn⟩ = y.get ⟨n, ⋯⟩
-- List.IsPrefix.head_eq
theorem IsPrefix.head_eq {x y : List α} (h : x <+: y) (hx : x ≠ []) :
    x.head hx = y.head (h.ne_nil hx) 
Arguments: {α : Type u_1} {x y : List α} (h : x <+: y) (hx : x ≠ [])
Goal: x.head hx = y.head ⋯
-- List.mem_sections
theorem mem_sections {L : List (List α)} {f} : f ∈ sections L ↔ Forall₂ (· ∈ ·) f L 
Arguments: {α : Type u_1} {L : List (List α)} {f : List α}
Goal: f ∈ L.sections ↔ List.Forall₂ (fun x x_1 => x ∈ x_1) f L
-- List.mem_sections_length
theorem mem_sections_length {L : List (List α)} {f} (h : f ∈ sections L) : length f = length L 
Arguments: {α : Type u_1} {L : List (List α)} {f : List α} (h : f ∈ L.sections)
Goal: f.length = L.length
-- List.rel_sections
theorem rel_sections {r : α → β → Prop} :
    (Forall₂ (Forall₂ r) ⇒ Forall₂ (Forall₂ r)) sections sections
  
Arguments: {α : Type u_1} {β : Type u_2} {r : α → β → Prop}
Goal: (List.Forall₂ (List.Forall₂ r) ⇒ List.Forall₂ (List.Forall₂ r)) List.sections List.sections
-- List.forall_mem_ne
@[simp]
theorem forall_mem_ne {a : α} {l : List α} : (∀ a' : α, a' ∈ l → ¬a = a') ↔ a ∉ l 
Arguments: {α : Type u} {a : α} {l : List α}
Goal: (∀ a' ∈ l, ¬a = a') ↔ a ∉ l
-- List.nodup_nil
@[simp]
theorem nodup_nil : @Nodup α [] 
Arguments: {α : Type u}
Goal: [].Nodup
-- List.nodup_cons
@[simp]
theorem nodup_cons {a : α} {l : List α} : Nodup (a :: l) ↔ a ∉ l ∧ Nodup l 
Arguments: {α : Type u} {a : α} {l : List α}
Goal: (a :: l).Nodup ↔ a ∉ l ∧ l.Nodup
-- List.Pairwise.nodup
protected theorem Pairwise.nodup {l : List α} {r : α → α → Prop} [IsIrrefl α r] (h : Pairwise r l) :
    Nodup l 
Arguments: {α : Type u} {l : List α} {r : α → α → Prop} [IsIrrefl α r] (h : List.Pairwise r l)
Goal: l.Nodup
-- List.rel_nodup
theorem rel_nodup {r : α → β → Prop} (hr : Relator.BiUnique r) : (Forall₂ r ⇒ (· ↔ ·)) Nodup Nodup
  
Arguments: {α : Type u} {β : Type v} {r : α → β → Prop} (hr : Relator.BiUnique r)
Goal: (List.Forall₂ r ⇒ fun x x_1 => x ↔ x_1) List.Nodup List.Nodup
-- List.Nodup.cons
protected theorem Nodup.cons (ha : a ∉ l) (hl : Nodup l) : Nodup (a :: l) 
Arguments: {α : Type u} {l : List α} {a : α} (ha : a ∉ l) (hl : l.Nodup)
Goal: (a :: l).Nodup
-- List.nodup_singleton
theorem nodup_singleton (a : α) : Nodup [a] 
Arguments: {α : Type u} (a : α)
Goal: [a].Nodup
-- List.Nodup.of_cons
theorem Nodup.of_cons (h : Nodup (a :: l)) : Nodup l 
Arguments: {α : Type u} {l : List α} {a : α} (h : (a :: l).Nodup)
Goal: l.Nodup
-- List.Nodup.not_mem
theorem Nodup.not_mem (h : (a :: l).Nodup) : a ∉ l 
Arguments: {α : Type u} {l : List α} {a : α} (h : (a :: l).Nodup)
Goal: a ∉ l
-- List.not_nodup_cons_of_mem
theorem not_nodup_cons_of_mem : a ∈ l → ¬Nodup (a :: l) 
Arguments: {α : Type u} {l : List α} {a : α}
Goal: a ∈ l → ¬(a :: l).Nodup
-- List.Nodup.sublist
protected theorem Nodup.sublist : l₁ <+ l₂ → Nodup l₂ → Nodup l₁ 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: l₁.Sublist l₂ → l₂.Nodup → l₁.Nodup