ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.nthLe_map
@[deprecated get_map (since := "2023-01-05")]
theorem nthLe_map (f : α → β) {l n} (H1 H2) : nthLe (map f l) n H1 = f (nthLe l n H2) 
Arguments: {α : Type u} {β : Type v} (f : α → β) {l : List α} {n : ℕ} (H1 : n < (List.map f l).length) (H2 : n < l.length)
Goal: (List.map f l).nthLe n H1 = f (l.nthLe n H2)
-- List.getElem_map_rev
theorem getElem_map_rev (f : α → β) {l} {n : Nat} {h : n < l.length} :
    f l[n] = (map f l)[n]'((l.length_map f).symm ▸ h) 
Arguments: {α : Type u} {β : Type v} (f : α → β) {l : List α} {n : ℕ} {h : n < l.length}
Goal: f l[n] = (List.map f l)[n]
-- List.get_map_rev
@[deprecated getElem_map_rev (since := "2024-06-12")]
theorem get_map_rev (f : α → β) {l n} :
    f (get l n) = get (map f l) ⟨n.1, (l.length_map f).symm ▸ n.2⟩ 
Arguments: {α : Type u} {β : Type v} (f : α → β) {l : List α} {n : Fin l.length}
Goal: f (l.get n) = (List.map f l).get ⟨↑n, ⋯⟩
-- List.nthLe_map_rev
@[deprecated get_map_rev (since := "2023-01-05")]
theorem nthLe_map_rev (f : α → β) {l n} (H) :
    f (nthLe l n H) = nthLe (map f l) n ((l.length_map f).symm ▸ H) 
Arguments: {α : Type u} {β : Type v} (f : α → β) {l : List α} {n : ℕ} (H : n < l.length)
Goal: f (l.nthLe n H) = (List.map f l).nthLe n ⋯
-- List.nthLe_map'
@[simp, deprecated get_map (since := "2023-01-05")]
theorem nthLe_map' (f : α → β) {l n} (H) :
    nthLe (map f l) n H = f (nthLe l n (l.length_map f ▸ H)) 
Arguments: {α : Type u} {β : Type v} (f : α → β) {l : List α} {n : ℕ} (H : n < (List.map f l).length)
Goal: (List.map f l).nthLe n H = f (l.nthLe n ⋯)
-- List.nthLe_singleton
@[simp, deprecated get_singleton (since := "2023-01-05")]
theorem nthLe_singleton (a : α) {n : ℕ} (hn : n < 1) : nthLe [a] n hn = a 
Arguments: {α : Type u} (a : α) {n : ℕ} (hn : n < 1)
Goal: [a].nthLe n hn = a
-- List.nthLe_append_right
@[deprecated get_append_right' (since := "2023-01-05")]
theorem nthLe_append_right {l₁ l₂ : List α} {n : ℕ} (h₁ : l₁.length ≤ n) (h₂) :
    (l₁ ++ l₂).nthLe n h₂ = l₂.nthLe (n - l₁.length) (get_append_right_aux h₁ h₂) 
Arguments: {α : Type u} {l₁ l₂ : List α} {n : ℕ} (h₁ : l₁.length ≤ n) (h₂ : n < (l₁ ++ l₂).length)
Goal: (l₁ ++ l₂).nthLe n h₂ = l₂.nthLe (n - l₁.length) ⋯
-- List.get_length_sub_one
theorem get_length_sub_one {l : List α} (h : l.length - 1 < l.length) :
    l.get ⟨l.length - 1, h⟩ = l.getLast (by rintro rfl; exact Nat.lt_irrefl 0 h) 
Arguments: {α : Type u} {l : List α} (h : l.length - 1 < l.length)
Goal: l.get ⟨l.length - 1, h⟩ = l.getLast ⋯
-- List.nthLe_cons_length
@[deprecated get_cons_length (since := "2023-01-05")]
theorem nthLe_cons_length : ∀ (x : α) (xs : List α) (n : ℕ) (h : n = xs.length),
    (x :: xs).nthLe n (by simp [h]) = (x :: xs).getLast (cons_ne_nil x xs) 
Arguments: {α : Type u} (x : α) (xs : List α) (n : ℕ) (h : n = xs.length)
Goal: (x :: xs).nthLe n ⋯ = (x :: xs).getLast ⋯
-- List.take_one_drop_eq_of_lt_length
theorem take_one_drop_eq_of_lt_length {l : List α} {n : ℕ} (h : n < l.length) :
    (l.drop n).take 1 = [l.get ⟨n, h⟩] 
Arguments: {α : Type u} {l : List α} {n : ℕ} (h : n < l.length)
Goal: List.take 1 (List.drop n l) = [l.get ⟨n, h⟩]
-- List.ext_get?'
theorem ext_get?' {l₁ l₂ : List α} (h' : ∀ n < max l₁.length l₂.length, l₁.get? n = l₂.get? n) :
    l₁ = l₂ 
Arguments: {α : Type u} {l₁ l₂ : List α} (h' : ∀ (n : ℕ), n < max l₁.length l₂.length → l₁.get? n = l₂.get? n)
Goal: l₁ = l₂
-- List.ext_get?_iff
theorem ext_get?_iff {l₁ l₂ : List α} : l₁ = l₂ ↔ ∀ n, l₁.get? n = l₂.get? n 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: l₁ = l₂ ↔ ∀ (n : ℕ), l₁.get? n = l₂.get? n
-- List.ext_get_iff
theorem ext_get_iff {l₁ l₂ : List α} :
    l₁ = l₂ ↔ l₁.length = l₂.length ∧ ∀ n h₁ h₂, get l₁ ⟨n, h₁⟩ = get l₂ ⟨n, h₂⟩ 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: l₁ = l₂ ↔ l₁.length = l₂.length ∧ ∀ (n : ℕ) (h₁ : n < l₁.length) (h₂ : n < l₂.length), l₁.get ⟨n, h₁⟩ = l₂.get ⟨n, h₂⟩
-- List.ext_get?_iff'
theorem ext_get?_iff' {l₁ l₂ : List α} : l₁ = l₂ ↔
    ∀ n < max l₁.length l₂.length, l₁.get? n = l₂.get? n 
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: l₁ = l₂ ↔ ∀ (n : ℕ), n < max l₁.length l₂.length → l₁.get? n = l₂.get? n
-- List.ext_nthLe
@[deprecated ext_get (since := "2023-01-05")]
theorem ext_nthLe {l₁ l₂ : List α} (hl : length l₁ = length l₂)
    (h : ∀ n h₁ h₂, nthLe l₁ n h₁ = nthLe l₂ n h₂) : l₁ = l₂ 
Arguments: {α : Type u} {l₁ l₂ : List α} (hl : l₁.length = l₂.length) (h : ∀ (n : ℕ) (h₁ : n < l₁.length) (h₂ : n < l₂.length), l₁.nthLe n h₁ = l₂.nthLe n h₂)
Goal: l₁ = l₂
-- List.getElem_indexOf
@[simp]
theorem getElem_indexOf [DecidableEq α] {a : α} : ∀ {l : List α} (h : indexOf a l < l.length),
    l[indexOf a l] = a
  
Arguments: {α : Type u} [DecidableEq α] {a : α} {l : List α} (h : List.indexOf a l < l.length)
Goal: l[List.indexOf a l] = a
-- List.indexOf_get
theorem indexOf_get [DecidableEq α] {a : α} {l : List α} (h) : get l ⟨indexOf a l, h⟩ = a 
Arguments: {α : Type u} [DecidableEq α] {a : α} {l : List α} (h : List.indexOf a l < l.length)
Goal: l.get ⟨List.indexOf a l, h⟩ = a
-- List.getElem?_indexOf
@[simp]
theorem getElem?_indexOf [DecidableEq α] {a : α} {l : List α} (h : a ∈ l) :
    l[indexOf a l]? = some a 
Arguments: {α : Type u} [DecidableEq α] {a : α} {l : List α} (h : a ∈ l)
Goal: l[List.indexOf a l]? = some a
-- List.indexOf_get?
theorem indexOf_get? [DecidableEq α] {a : α} {l : List α} (h : a ∈ l) :
    get? l (indexOf a l) = some a 
Arguments: {α : Type u} [DecidableEq α] {a : α} {l : List α} (h : a ∈ l)
Goal: l.get? (List.indexOf a l) = some a
-- List.get_reverse_aux₁
@[deprecated (since := "2023-01-05")]
theorem get_reverse_aux₁ :
    ∀ (l r : List α) (i h1 h2), get (reverseAux l r) ⟨i + length l, h1⟩ = get r ⟨i, h2⟩
  
Arguments: {α : Type u} (l r : List α) (i : ℕ) (h1 : i + l.length < (l.reverseAux r).length) (h2 : i < r.length)
Goal: (l.reverseAux r).get ⟨i + l.length, h1⟩ = r.get ⟨i, h2⟩
-- List.indexOf_inj
theorem indexOf_inj [DecidableEq α] {l : List α} {x y : α} (hx : x ∈ l) (hy : y ∈ l) :
    indexOf x l = indexOf y l ↔ x = y 
Arguments: {α : Type u} [DecidableEq α] {l : List α} {x y : α} (hx : x ∈ l) (hy : y ∈ l)
Goal: List.indexOf x l = List.indexOf y l ↔ x = y
-- List.getElem_reverse_aux₂
theorem getElem_reverse_aux₂ :
    ∀ (l r : List α) (i : Nat) (h1) (h2),
      (reverseAux l r)[length l - 1 - i]'h1 = l[i]'h2
  
Arguments: {α : Type u} (l r : List α) (i : ℕ) (h1 : l.length - 1 - i < (l.reverseAux r).length) (h2 : i < l.length)
Goal: (l.reverseAux r)[l.length - 1 - i] = l[i]
-- List.getElem_reverse
@[simp] theorem getElem_reverse (l : List α) (i : Nat) (h1 h2) :
    (reverse l)[length l - 1 - i]'h1 = l[i]'h2 
Arguments: {α : Type u} (l : List α) (i : ℕ) (h1 : l.length - 1 - i < l.reverse.length) (h2 : i < l.length)
Goal: l.reverse[l.length - 1 - i] = l[i]
-- List.get_reverse_aux₂
@[deprecated getElem_reverse_aux₂ (since := "2024-06-12")]
theorem get_reverse_aux₂ (l r : List α) (i : Nat) (h1) (h2) :
    get (reverseAux l r) ⟨length l - 1 - i, h1⟩ = get l ⟨i, h2⟩ 
Arguments: {α : Type u} (l r : List α) (i : ℕ) (h1 : l.length - 1 - i < (l.reverseAux r).length) (h2 : i < l.length)
Goal: (l.reverseAux r).get ⟨l.length - 1 - i, h1⟩ = l.get ⟨i, h2⟩
-- List.get_reverse
@[deprecated getElem_reverse (since := "2024-06-12")]
theorem get_reverse (l : List α) (i : Nat) (h1 h2) :
    get (reverse l) ⟨length l - 1 - i, h1⟩ = get l ⟨i, h2⟩ 
Arguments: {α : Type u} (l : List α) (i : ℕ) (h1 : l.length - 1 - i < l.reverse.length) (h2 : i < l.length)
Goal: l.reverse.get ⟨l.length - 1 - i, h1⟩ = l.get ⟨i, h2⟩
-- List.nthLe_reverse
@[simp, deprecated get_reverse (since := "2023-01-05")]
theorem nthLe_reverse (l : List α) (i : Nat) (h1 h2) :
    nthLe (reverse l) (length l - 1 - i) h1 = nthLe l i h2 
Arguments: {α : Type u} (l : List α) (i : ℕ) (h1 : l.length - 1 - i < l.reverse.length) (h2 : i < l.length)
Goal: l.reverse.nthLe (l.length - 1 - i) h1 = l.nthLe i h2
-- List.nthLe_reverse'
theorem nthLe_reverse' (l : List α) (n : ℕ) (hn : n < l.reverse.length) (hn') :
    l.reverse.nthLe n hn = l.nthLe (l.length - 1 - n) hn' 
Arguments: {α : Type u} (l : List α) (n : ℕ) (hn : n < l.reverse.length) (hn' : l.length - 1 - n < l.length)
Goal: l.reverse.nthLe n hn = l.nthLe (l.length - 1 - n) hn'
-- List.get_reverse'
theorem get_reverse' (l : List α) (n) (hn') :
    l.reverse.get n = l.get ⟨l.length - 1 - n, hn'⟩ 
Arguments: {α : Type u} (l : List α) (n : Fin l.reverse.length) (hn' : l.length - 1 - ↑n < l.length)
Goal: l.reverse.get n = l.get ⟨l.length - 1 - ↑n, hn'⟩
-- List.eq_cons_of_length_one
theorem eq_cons_of_length_one {l : List α} (h : l.length = 1) :
    l = [l.nthLe 0 (by omega)] 
Arguments: {α : Type u} {l : List α} (h : l.length = 1)
Goal: l = [l.nthLe 0 ⋯]
-- List.modifyNthTail_modifyNthTail
theorem modifyNthTail_modifyNthTail {f g : List α → List α} (m : ℕ) :
    ∀ (n) (l : List α),
      (l.modifyNthTail f n).modifyNthTail g (m + n) =
        l.modifyNthTail (fun l => (f l).modifyNthTail g m) n
  
Arguments: {α : Type u} {f g : List α → List α} (m n : ℕ) (l : List α)
Goal: List.modifyNthTail g (m + n) (List.modifyNthTail f n l) = List.modifyNthTail (fun l => List.modifyNthTail g m (f l)) n l
-- List.modifyNthTail_modifyNthTail_le
theorem modifyNthTail_modifyNthTail_le {f g : List α → List α} (m n : ℕ) (l : List α)
    (h : n ≤ m) :
    (l.modifyNthTail f n).modifyNthTail g m =
      l.modifyNthTail (fun l => (f l).modifyNthTail g (m - n)) n 
Arguments: {α : Type u} {f g : List α → List α} (m n : ℕ) (l : List α) (h : n ≤ m)
Goal: List.modifyNthTail g m (List.modifyNthTail f n l) = List.modifyNthTail (fun l => List.modifyNthTail g (m - n) (f l)) n l
-- List.modifyNthTail_modifyNthTail_same
theorem modifyNthTail_modifyNthTail_same {f g : List α → List α} (n : ℕ) (l : List α) :
    (l.modifyNthTail f n).modifyNthTail g n = l.modifyNthTail (g ∘ f) n 
Arguments: {α : Type u} {f g : List α → List α} (n : ℕ) (l : List α)
Goal: List.modifyNthTail g n (List.modifyNthTail f n l) = List.modifyNthTail (g ∘ f) n l
-- List.modifyNth_eq_set
theorem modifyNth_eq_set (f : α → α) :
    ∀ (n) (l : List α), modifyNth f n l = ((fun a => set l n (f a)) <$> l[n]?).getD l
  
Arguments: {α : Type u} (f : α → α) (n : ℕ) (l : List α)
Goal: List.modifyNth f n l = ((fun a => l.set n (f a)) <$> l[n]?).getD l
-- List.length_modifyNthTail
theorem length_modifyNthTail (f : List α → List α) (H : ∀ l, length (f l) = length l) :
    ∀ n l, length (modifyNthTail f n l) = length l
  
Arguments: {α : Type u} (f : List α → List α) (H : ∀ (l : List α), (f l).length = l.length) (n : ℕ) (l : List α)
Goal: (List.modifyNthTail f n l).length = l.length
-- List.length_modifyNth
theorem length_modifyNth (f : α → α) : ∀ n l, length (modifyNth f n l) = length l 
Arguments: {α : Type u} (f : α → α) (n : ℕ) (l : List α)
Goal: (List.modifyNth f n l).length = l.length
-- List.getElem_set_of_ne
@[simp]
theorem getElem_set_of_ne {l : List α} {i j : ℕ} (h : i ≠ j) (a : α)
    (hj : j < (l.set i a).length) :
    (l.set i a)[j] = l[j]'(by simpa using hj) 
Arguments: {α : Type u} {l : List α} {i j : ℕ} (h : i ≠ j) (a : α) (hj : j < (l.set i a).length)
Goal: (l.set i a)[j] = l[j]
-- List.get_set_of_ne
@[deprecated getElem_set_of_ne (since := "2024-06-12")]
theorem get_set_of_ne {l : List α} {i j : ℕ} (h : i ≠ j) (a : α)
    (hj : j < (l.set i a).length) :
    (l.set i a).get ⟨j, hj⟩ = l.get ⟨j, by simpa using hj⟩ 
Arguments: {α : Type u} {l : List α} {i j : ℕ} (h : i ≠ j) (a : α) (hj : j < (l.set i a).length)
Goal: (l.set i a).get ⟨j, hj⟩ = l.get ⟨j, ⋯⟩
-- List.bind_pure_eq_map
theorem bind_pure_eq_map (f : α → β) (l : List α) : l.bind (pure ∘ f) = map f l 
Arguments: {α : Type u} {β : Type v} (f : α → β) (l : List α)
Goal: l.bind (pure ∘ f) = List.map f l
-- List.bind_ret_eq_map
@[deprecated bind_pure_eq_map (since := "2024-03-24")]
theorem bind_ret_eq_map (f : α → β) (l : List α) : l.bind (List.ret ∘ f) = map f l 
Arguments: {α : Type u} {β : Type v} (f : α → β) (l : List α)
Goal: l.bind (List.ret ∘ f) = List.map f l
-- List.bind_congr
theorem bind_congr {l : List α} {f g : α → List β} (h : ∀ x ∈ l, f x = g x) :
    List.bind l f = List.bind l g 
Arguments: {α : Type u} {β : Type v} {l : List α} {f g : α → List β} (h : ∀ (x : α), x ∈ l → f x = g x)
Goal: l.bind f = l.bind g
-- List.infix_bind_of_mem
theorem infix_bind_of_mem {a : α} {as : List α} (h : a ∈ as) (f : α → List α) :
    f a <:+: as.bind f 
Arguments: {α : Type u} {a : α} {as : List α} (h : a ∈ as) (f : α → List α)
Goal: f a <:+: as.bind f
-- List.map_eq_map
@[simp]
theorem map_eq_map {α β} (f : α → β) (l : List α) : f <$> l = map f l 
Arguments: {α β : Type u_2} (f : α → β) (l : List α)
Goal: f <$> l = List.map f l
-- List.map_tail
@[simp]
theorem map_tail (f : α → β) (l) : map f (tail l) = tail (map f l) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (l : List α)
Goal: List.map f l.tail = (List.map f l).tail
-- List.comp_map
theorem comp_map (h : β → γ) (g : α → β) (l : List α) : map (h ∘ g) l = map h (map g l) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (h : β → γ) (g : α → β) (l : List α)
Goal: List.map (h ∘ g) l = List.map h (List.map g l)
-- List.map_comp_map
@[simp]
theorem map_comp_map (g : β → γ) (f : α → β) : map g ∘ map f = map (g ∘ f) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (g : β → γ) (f : α → β)
Goal: List.map g ∘ List.map f = List.map (g ∘ f)
-- Function.LeftInverse.list_map
theorem _root_.Function.LeftInverse.list_map {f : α → β} {g : β → α} (h : LeftInverse f g) :
    LeftInverse (map f) (map g)
  
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α} (h : Function.LeftInverse f g)
Goal: Function.LeftInverse (List.map f) (List.map g)
-- Function.RightInverse.list_map
nonrec theorem _root_.Function.RightInverse.list_map {f : α → β} {g : β → α}
    (h : RightInverse f g) : RightInverse (map f) (map g) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α} (h : Function.RightInverse f g)
Goal: Function.RightInverse (List.map f) (List.map g)
-- Function.Involutive.list_map
nonrec theorem _root_.Function.Involutive.list_map {f : α → α}
    (h : Involutive f) : Involutive (map f) 
Arguments: {α : Type u} {f : α → α} (h : Function.Involutive f)
Goal: Function.Involutive (List.map f)
-- List.map_leftInverse_iff
@[simp]
theorem map_leftInverse_iff {f : α → β} {g : β → α} :
    LeftInverse (map f) (map g) ↔ LeftInverse f g 
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α}
Goal: Function.LeftInverse (List.map f) (List.map g) ↔ Function.LeftInverse f g
-- List.map_rightInverse_iff
@[simp]
theorem map_rightInverse_iff {f : α → β} {g : β → α} :
    RightInverse (map f) (map g) ↔ RightInverse f g 
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α}
Goal: Function.RightInverse (List.map f) (List.map g) ↔ Function.RightInverse f g
-- List.map_involutive_iff
@[simp]
theorem map_involutive_iff {f : α → α} :
    Involutive (map f) ↔ Involutive f 
Arguments: {α : Type u} {f : α → α}
Goal: Function.Involutive (List.map f) ↔ Function.Involutive f
-- Function.Injective.list_map
theorem _root_.Function.Injective.list_map {f : α → β} (h : Injective f) :
    Injective (map f)
  
Arguments: {α : Type u} {β : Type v} {f : α → β} (h : Function.Injective f)
Goal: Function.Injective (List.map f)
-- List.map_injective_iff
@[simp]
theorem map_injective_iff {f : α → β} : Injective (map f) ↔ Injective f 
Arguments: {α : Type u} {β : Type v} {f : α → β}
Goal: Function.Injective (List.map f) ↔ Function.Injective f
-- Function.Surjective.list_map
theorem _root_.Function.Surjective.list_map {f : α → β} (h : Surjective f) :
    Surjective (map f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} (h : Function.Surjective f)
Goal: Function.Surjective (List.map f)
-- List.map_surjective_iff
@[simp]
theorem map_surjective_iff {f : α → β} : Surjective (map f) ↔ Surjective f 
Arguments: {α : Type u} {β : Type v} {f : α → β}
Goal: Function.Surjective (List.map f) ↔ Function.Surjective f
-- Function.Bijective.list_map
theorem _root_.Function.Bijective.list_map {f : α → β} (h : Bijective f) : Bijective (map f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} (h : Function.Bijective f)
Goal: Function.Bijective (List.map f)
-- List.map_bijective_iff
@[simp]
theorem map_bijective_iff {f : α → β} : Bijective (map f) ↔ Bijective f 
Arguments: {α : Type u} {β : Type v} {f : α → β}
Goal: Function.Bijective (List.map f) ↔ Function.Bijective f
-- List.eq_of_mem_map_const
theorem eq_of_mem_map_const {b₁ b₂ : β} {l : List α} (h : b₁ ∈ map (const α b₂) l) :
    b₁ = b₂ 
Arguments: {α : Type u} {β : Type v} {b₁ b₂ : β} {l : List α} (h : b₁ ∈ List.map (Function.const α b₂) l)
Goal: b₁ = b₂
-- List.nil_zipWith
theorem nil_zipWith (f : α → β → γ) (l : List β) : zipWith f [] l = [] 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β → γ) (l : List β)
Goal: List.zipWith f [] l = []
-- List.zipWith_nil
theorem zipWith_nil (f : α → β → γ) (l : List α) : zipWith f l [] = [] 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β → γ) (l : List α)
Goal: List.zipWith f l [] = []
-- List.zipWith_flip
@[simp]
theorem zipWith_flip (f : α → β → γ) : ∀ as bs, zipWith (flip f) bs as = zipWith f as bs
  
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β → γ) (as : List α) (bs : List β)
Goal: List.zipWith (flip f) bs as = List.zipWith f as bs
-- List.take_cons
theorem take_cons (n) (a : α) (l : List α) : take (succ n) (a :: l) = a :: take n l 
Arguments: {α : Type u} (n : ℕ) (a : α) (l : List α)
Goal: List.take n.succ (a :: l) = a :: List.take n l
-- List.drop_tail
@[simp]
theorem drop_tail (l : List α) (n : ℕ) : l.tail.drop n = l.drop (n + 1) 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: List.drop n l.tail = List.drop (n + 1) l
-- List.cons_getElem_drop_succ
theorem cons_getElem_drop_succ {l : List α} {n : Nat} {h : n < l.length} :
    l[n] :: l.drop (n + 1) = l.drop n 
Arguments: {α : Type u} {l : List α} {n : ℕ} {h : n < l.length}
Goal: l[n] :: List.drop (n + 1) l = List.drop n l
-- List.cons_get_drop_succ
theorem cons_get_drop_succ {l : List α} {n} :
    l.get n :: l.drop (n.1 + 1) = l.drop n.1 
Arguments: {α : Type u} {l : List α} {n : Fin l.length}
Goal: l.get n :: List.drop (↑n + 1) l = List.drop (↑n) l
-- List.takeI_length
@[simp]
theorem takeI_length : ∀ n l, length (@takeI α _ n l) = n
  
Arguments: {α : Type u} [Inhabited α] (n : ℕ) (l : List α)
Goal: (List.takeI n l).length = n
-- List.takeI_nil
@[simp]
theorem takeI_nil : ∀ n, takeI n (@nil α) = replicate n default
  
Arguments: {α : Type u} [Inhabited α] (n : ℕ)
Goal: List.takeI n [] = List.replicate n default
-- List.takeI_eq_take
theorem takeI_eq_take : ∀ {n} {l : List α}, n ≤ length l → takeI n l = take n l
  
Arguments: {α : Type u} [Inhabited α] {n : ℕ} {l : List α}
Goal: n ≤ l.length → List.takeI n l = List.take n l
-- List.takeI_left
@[simp]
theorem takeI_left (l₁ l₂ : List α) : takeI (length l₁) (l₁ ++ l₂) = l₁ 
Arguments: {α : Type u} [Inhabited α] (l₁ l₂ : List α)
Goal: List.takeI l₁.length (l₁ ++ l₂) = l₁
-- List.takeI_left'
theorem takeI_left' {l₁ l₂ : List α} {n} (h : length l₁ = n) : takeI n (l₁ ++ l₂) = l₁ 
Arguments: {α : Type u} [Inhabited α] {l₁ l₂ : List α} {n : ℕ} (h : l₁.length = n)
Goal: List.takeI n (l₁ ++ l₂) = l₁
-- List.takeD_length
@[simp]
theorem takeD_length : ∀ n l a, length (@takeD α n l a) = n
  
Arguments: {α : Type u} (n : ℕ) (l : List α) (a : α)
Goal: (List.takeD n l a).length = n
-- List.takeD_eq_take
theorem takeD_eq_take : ∀ {n} {l : List α} a, n ≤ length l → takeD n l a = take n l
  
Arguments: {α : Type u} {n : ℕ} {l : List α} (a : α)
Goal: n ≤ l.length → List.takeD n l a = List.take n l
-- List.takeD_left
@[simp]
theorem takeD_left (l₁ l₂ : List α) (a : α) : takeD (length l₁) (l₁ ++ l₂) a = l₁ 
Arguments: {α : Type u} (l₁ l₂ : List α) (a : α)
Goal: List.takeD l₁.length (l₁ ++ l₂) a = l₁
-- List.takeD_left'
theorem takeD_left' {l₁ l₂ : List α} {n} {a} (h : length l₁ = n) : takeD n (l₁ ++ l₂) a = l₁ 
Arguments: {α : Type u} {l₁ l₂ : List α} {n : ℕ} {a : α} (h : l₁.length = n)
Goal: List.takeD n (l₁ ++ l₂) a = l₁
-- List.foldl_ext
theorem foldl_ext (f g : α → β → α) (a : α) {l : List β} (H : ∀ a : α, ∀ b ∈ l, f a b = g a b) :
    foldl f a l = foldl g a l 
Arguments: {α : Type u} {β : Type v} (f g : α → β → α) (a : α) {l : List β} (H : ∀ (a : α) (b : β), b ∈ l → f a b = g a b)
Goal: List.foldl f a l = List.foldl g a l
-- List.foldr_ext
theorem foldr_ext (f g : α → β → β) (b : β) {l : List α} (H : ∀ a ∈ l, ∀ b : β, f a b = g a b) :
    foldr f b l = foldr g b l 
Arguments: {α : Type u} {β : Type v} (f g : α → β → β) (b : β) {l : List α} (H : ∀ (a : α), a ∈ l → ∀ (b : β), f a b = g a b)
Goal: List.foldr f b l = List.foldr g b l
-- List.foldl_concat
theorem foldl_concat
    (f : β → α → β) (b : β) (x : α) (xs : List α) :
    List.foldl f b (xs ++ [x]) = f (List.foldl f b xs) x 
Arguments: {α : Type u} {β : Type v} (f : β → α → β) (b : β) (x : α) (xs : List α)
Goal: List.foldl f b (xs ++ [x]) = f (List.foldl f b xs) x
-- List.foldr_concat
theorem foldr_concat
    (f : α → β → β) (b : β) (x : α) (xs : List α) :
    List.foldr f b (xs ++ [x]) = (List.foldr f (f x b) xs) 
Arguments: {α : Type u} {β : Type v} (f : α → β → β) (b : β) (x : α) (xs : List α)
Goal: List.foldr f b (xs ++ [x]) = List.foldr f (f x b) xs
-- List.foldl_fixed'
theorem foldl_fixed' {f : α → β → α} {a : α} (hf : ∀ b, f a b = a) : ∀ l : List β, foldl f a l = a
  
Arguments: {α : Type u} {β : Type v} {f : α → β → α} {a : α} (hf : ∀ (b : β), f a b = a) (l : List β)
Goal: List.foldl f a l = a
-- List.foldr_fixed'
theorem foldr_fixed' {f : α → β → β} {b : β} (hf : ∀ a, f a b = b) : ∀ l : List α, foldr f b l = b
  
Arguments: {α : Type u} {β : Type v} {f : α → β → β} {b : β} (hf : ∀ (a : α), f a b = b) (l : List α)
Goal: List.foldr f b l = b
-- List.foldl_fixed
@[simp]
theorem foldl_fixed {a : α} : ∀ l : List β, foldl (fun a _ => a) a l = a 
Arguments: {α : Type u} {β : Type v} {a : α} (l : List β)
Goal: List.foldl (fun a x => a) a l = a
-- List.foldr_fixed
@[simp]
theorem foldr_fixed {b : β} : ∀ l : List α, foldr (fun _ b => b) b l = b 
Arguments: {α : Type u} {β : Type v} {b : β} (l : List α)
Goal: List.foldr (fun x b => b) b l = b
-- List.foldl_join
@[simp]
theorem foldl_join (f : α → β → α) :
    ∀ (a : α) (L : List (List β)), foldl f a (join L) = foldl (foldl f) a L
  
Arguments: {α : Type u} {β : Type v} (f : α → β → α) (a : α) (L : List (List β))
Goal: List.foldl f a L.join = List.foldl (List.foldl f) a L
-- List.foldr_join
@[simp]
theorem foldr_join (f : α → β → β) :
    ∀ (b : β) (L : List (List α)), foldr f b (join L) = foldr (fun l b => foldr f b l) b L
  
Arguments: {α : Type u} {β : Type v} (f : α → β → β) (b : β) (L : List (List α))
Goal: List.foldr f b L.join = List.foldr (fun l b => List.foldr f b l) b L
-- List.foldr_eta
theorem foldr_eta : ∀ l : List α, foldr cons [] l = l 
Arguments: {α : Type u} (l : List α)
Goal: List.foldr List.cons [] l = l
-- List.reverse_foldl
@[simp]
theorem reverse_foldl {l : List α} : reverse (foldl (fun t h => h :: t) [] l) = l 
Arguments: {α : Type u} {l : List α}
Goal: (List.foldl (fun t h => h :: t) [] l).reverse = l
-- List.foldl_hom₂
theorem foldl_hom₂ (l : List ι) (f : α → β → γ) (op₁ : α → ι → α) (op₂ : β → ι → β)
    (op₃ : γ → ι → γ) (a : α) (b : β) (h : ∀ a b i, f (op₁ a i) (op₂ b i) = op₃ (f a b) i) :
    foldl op₃ (f a b) l = f (foldl op₁ a l) (foldl op₂ b l) 
Arguments: {ι : Type u_1} {α : Type u} {β : Type v} {γ : Type w} (l : List ι) (f : α → β → γ) (op₁ : α → ι → α) (op₂ : β → ι → β) (op₃ : γ → ι → γ) (a : α) (b : β) (h : ∀ (a : α) (b : β) (i : ι), f (op₁ a i) (op₂ b i) = op₃ (f a b) i)
Goal: List.foldl op₃ (f a b) l = f (List.foldl op₁ a l) (List.foldl op₂ b l)
-- List.foldr_hom₂
theorem foldr_hom₂ (l : List ι) (f : α → β → γ) (op₁ : ι → α → α) (op₂ : ι → β → β)
    (op₃ : ι → γ → γ) (a : α) (b : β) (h : ∀ a b i, f (op₁ i a) (op₂ i b) = op₃ i (f a b)) :
    foldr op₃ (f a b) l = f (foldr op₁ a l) (foldr op₂ b l) 
Arguments: {ι : Type u_1} {α : Type u} {β : Type v} {γ : Type w} (l : List ι) (f : α → β → γ) (op₁ : ι → α → α) (op₂ : ι → β → β) (op₃ : ι → γ → γ) (a : α) (b : β) (h : ∀ (a : α) (b : β) (i : ι), f (op₁ i a) (op₂ i b) = op₃ i (f a b))
Goal: List.foldr op₃ (f a b) l = f (List.foldr op₁ a l) (List.foldr op₂ b l)