ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.ofFn_getElem_eq_map
@[simp]
theorem ofFn_getElem_eq_map {β : Type*} (l : List α) (f : α → β) :
    ofFn (fun i : Fin l.length => f <| l[(i : Nat)]) = l.map f 
Arguments: {α : Type u} {β : Type u_1} (l : List α) (f : α → β)
Goal: (List.ofFn fun i => f l[↑i]) = List.map f l
-- List.ofFn_get_eq_map
@[deprecated ofFn_getElem_eq_map (since := "2024-06-12")]
theorem ofFn_get_eq_map {β : Type*} (l : List α) (f : α → β) : ofFn (f <| l.get ·) = l.map f 
Arguments: {α : Type u} {β : Type u_1} (l : List α) (f : α → β)
Goal: (List.ofFn fun x => f (l.get x)) = List.map f l
-- List.ofFn_nthLe
@[deprecated ofFn_get (since := "2023-01-17")]
theorem ofFn_nthLe : ∀ l : List α, (ofFn fun i => nthLe l i i.2) = l 
Arguments: {α : Type u} (l : List α)
Goal: (List.ofFn fun i => l.nthLe ↑i ⋯) = l
-- List.mem_ofFn
theorem mem_ofFn {n} (f : Fin n → α) (a : α) : a ∈ ofFn f ↔ a ∈ Set.range f 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (a : α)
Goal: a ∈ List.ofFn f ↔ a ∈ Set.range f
-- List.forall_mem_ofFn_iff
@[simp]
theorem forall_mem_ofFn_iff {n : ℕ} {f : Fin n → α} {P : α → Prop} :
    (∀ i ∈ ofFn f, P i) ↔ ∀ j : Fin n, P (f j) 
Arguments: {α : Type u} {n : ℕ} {f : Fin n → α} {P : α → Prop}
Goal: (∀ i ∈ List.ofFn f, P i) ↔ ∀ (j : Fin n), P (f j)
-- List.ofFn_const
@[simp]
theorem ofFn_const : ∀ (n : ℕ) (c : α), (ofFn fun _ : Fin n => c) = replicate n c
  
Arguments: {α : Type u} (n : ℕ) (c : α)
Goal: (List.ofFn fun x => c) = List.replicate n c
-- List.ofFn_fin_repeat
@[simp]
theorem ofFn_fin_repeat {m} (a : Fin m → α) (n : ℕ) :
    List.ofFn (Fin.repeat n a) = (List.replicate n (List.ofFn a)).join 
Arguments: {α : Type u} {m : ℕ} (a : Fin m → α) (n : ℕ)
Goal: List.ofFn (Fin.repeat n a) = (List.replicate n (List.ofFn a)).join
-- List.pairwise_ofFn
@[simp]
theorem pairwise_ofFn {R : α → α → Prop} {n} {f : Fin n → α} :
    (ofFn f).Pairwise R ↔ ∀ ⦃i j⦄, i < j → R (f i) (f j) 
Arguments: {α : Type u} {R : α → α → Prop} {n : ℕ} {f : Fin n → α}
Goal: List.Pairwise R (List.ofFn f) ↔ ∀ ⦃i j : Fin n⦄, i < j → R (f i) (f j)
-- List.equivSigmaTuple_symm_apply
@[simps]
def equivSigmaTuple : List α ≃ Σn, Fin n → α 
Arguments: {α : Type u} (f : (n : ℕ) × (Fin n → α))
Goal: List.equivSigmaTuple.symm f = List.ofFn f.snd
-- List.equivSigmaTuple_apply_snd
@[simps]
def equivSigmaTuple : List α ≃ Σn, Fin n → α 
Arguments: {α : Type u} (l : List α)
Goal: ∀ (a : Fin l.length), (List.equivSigmaTuple l).snd a = l.get a
-- List.equivSigmaTuple_apply_fst
@[simps]
def equivSigmaTuple : List α ≃ Σn, Fin n → α 
Arguments: {α : Type u} (l : List α)
Goal: (List.equivSigmaTuple l).fst = l.length
-- List.ofFnRec_ofFn
@[simp]
theorem ofFnRec_ofFn {C : List α → Sort*} (h : ∀ (n) (f : Fin n → α), C (List.ofFn f)) {n : ℕ}
    (f : Fin n → α) : @ofFnRec _ C h (List.ofFn f) = h _ f 
Arguments: {α : Type u} {C : List α → Sort u_1} (h : (n : ℕ) → (f : Fin n → α) → C (List.ofFn f)) {n : ℕ} (f : Fin n → α)
Goal: List.ofFnRec h (List.ofFn f) = h n f
-- List.exists_iff_exists_tuple
theorem exists_iff_exists_tuple {P : List α → Prop} :
    (∃ l : List α, P l) ↔ ∃ (n : _) (f : Fin n → α), P (List.ofFn f) 
Arguments: {α : Type u} {P : List α → Prop}
Goal: (∃ l, P l) ↔ ∃ n f, P (List.ofFn f)
-- List.forall_iff_forall_tuple
theorem forall_iff_forall_tuple {P : List α → Prop} :
    (∀ l : List α, P l) ↔ ∀ (n) (f : Fin n → α), P (List.ofFn f) 
Arguments: {α : Type u} {P : List α → Prop}
Goal: (∀ (l : List α), P l) ↔ ∀ (n : ℕ) (f : Fin n → α), P (List.ofFn f)
-- List.ofFn_inj'
theorem ofFn_inj' {m n : ℕ} {f : Fin m → α} {g : Fin n → α} :
    ofFn f = ofFn g ↔ (⟨m, f⟩ : Σn, Fin n → α) = ⟨n, g⟩ 
Arguments: {α : Type u} {m n : ℕ} {f : Fin m → α} {g : Fin n → α}
Goal: List.ofFn f = List.ofFn g ↔ ⟨m, f⟩ = ⟨n, g⟩
-- List.ofFn_injective
theorem ofFn_injective {n : ℕ} : Function.Injective (ofFn : (Fin n → α) → List α) 
Arguments: {α : Type u} {n : ℕ}
Goal: Function.Injective List.ofFn
-- List.ofFn_inj
@[simp]
theorem ofFn_inj {n : ℕ} {f g : Fin n → α} : ofFn f = ofFn g ↔ f = g 
Arguments: {α : Type u} {n : ℕ} {f g : Fin n → α}
Goal: List.ofFn f = List.ofFn g ↔ f = g
-- List.insertNth_zero
@[simp]
theorem insertNth_zero (s : List α) (x : α) : insertNth 0 x s = x :: s 
Arguments: {α : Type u} (s : List α) (x : α)
Goal: List.insertNth 0 x s = x :: s
-- List.insertNth_succ_nil
@[simp]
theorem insertNth_succ_nil (n : ℕ) (a : α) : insertNth (n + 1) a [] = [] 
Arguments: {α : Type u} (n : ℕ) (a : α)
Goal: List.insertNth (n + 1) a [] = []
-- List.insertNth_succ_cons
@[simp]
theorem insertNth_succ_cons (s : List α) (hd x : α) (n : ℕ) :
    insertNth (n + 1) x (hd :: s) = hd :: insertNth n x s 
Arguments: {α : Type u} (s : List α) (hd x : α) (n : ℕ)
Goal: List.insertNth (n + 1) x (hd :: s) = hd :: List.insertNth n x s
-- List.length_insertNth
theorem length_insertNth : ∀ n as, n ≤ length as → length (insertNth n a as) = length as + 1
  
Arguments: {α : Type u} {a : α} (n : ℕ) (as : List α)
Goal: n ≤ as.length → (List.insertNth n a as).length = as.length + 1
-- List.eraseIdx_insertNth
theorem eraseIdx_insertNth (n : ℕ) (l : List α) : (l.insertNth n a).eraseIdx n = l 
Arguments: {α : Type u} {a : α} (n : ℕ) (l : List α)
Goal: (List.insertNth n a l).eraseIdx n = l
-- List.insertNth_eraseIdx_of_ge
theorem insertNth_eraseIdx_of_ge :
    ∀ n m as,
      n < length as → n ≤ m → insertNth m a (as.eraseIdx n) = (as.insertNth (m + 1) a).eraseIdx n
  
Arguments: {α : Type u} {a : α} (n m : ℕ) (as : List α)
Goal: n < as.length → n ≤ m → List.insertNth m a (as.eraseIdx n) = (List.insertNth (m + 1) a as).eraseIdx n
-- List.insertNth_eraseIdx_of_le
theorem insertNth_eraseIdx_of_le :
    ∀ n m as,
      n < length as → m ≤ n → insertNth m a (as.eraseIdx n) = (as.insertNth m a).eraseIdx (n + 1)
  
Arguments: {α : Type u} {a : α} (n m : ℕ) (as : List α)
Goal: n < as.length → m ≤ n → List.insertNth m a (as.eraseIdx n) = (List.insertNth m a as).eraseIdx (n + 1)
-- List.insertNth_comm
theorem insertNth_comm (a b : α) :
    ∀ (i j : ℕ) (l : List α) (_ : i ≤ j) (_ : j ≤ length l),
      (l.insertNth i a).insertNth (j + 1) b = (l.insertNth j b).insertNth i a
  
Arguments: {α : Type u} (a b : α) (i j : ℕ) (l : List α)
Goal: i ≤ j → j ≤ l.length → List.insertNth (j + 1) b (List.insertNth i a l) = List.insertNth i a (List.insertNth j b l)
-- List.mem_insertNth
theorem mem_insertNth {a b : α} :
    ∀ {n : ℕ} {l : List α} (_ : n ≤ l.length), a ∈ l.insertNth n b ↔ a = b ∨ a ∈ l
  
Arguments: {α : Type u} {a b : α} {n : ℕ} {l : List α}
Goal: n ≤ l.length → (a ∈ List.insertNth n b l ↔ a = b ∨ a ∈ l)
-- List.insertNth_of_length_lt
theorem insertNth_of_length_lt (l : List α) (x : α) (n : ℕ) (h : l.length < n) :
    insertNth n x l = l 
Arguments: {α : Type u} (l : List α) (x : α) (n : ℕ) (h : l.length < n)
Goal: List.insertNth n x l = l
-- List.insertNth_length_self
@[simp]
theorem insertNth_length_self (l : List α) (x : α) : insertNth l.length x l = l ++ [x] 
Arguments: {α : Type u} (l : List α) (x : α)
Goal: List.insertNth l.length x l = l ++ [x]
-- List.length_le_length_insertNth
theorem length_le_length_insertNth (l : List α) (x : α) (n : ℕ) :
    l.length ≤ (insertNth n x l).length 
Arguments: {α : Type u} (l : List α) (x : α) (n : ℕ)
Goal: l.length ≤ (List.insertNth n x l).length
-- List.length_insertNth_le_succ
theorem length_insertNth_le_succ (l : List α) (x : α) (n : ℕ) :
    (insertNth n x l).length ≤ l.length + 1 
Arguments: {α : Type u} (l : List α) (x : α) (n : ℕ)
Goal: (List.insertNth n x l).length ≤ l.length + 1
-- List.getElem_insertNth_of_lt
theorem getElem_insertNth_of_lt (l : List α) (x : α) (n k : ℕ) (hn : k < n) (hk : k < l.length)
    (hk' : k < (insertNth n x l).length := hk.trans_le (length_le_length_insertNth _ _ _)) :
    (insertNth n x l)[k] = l[k] 
Arguments: {α : Type u} (l : List α) (x : α) (n k : ℕ) (hn : k < n) (hk : k < l.length) (hk' : k < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l)[k] = l[k]
-- List.get_insertNth_of_lt
theorem get_insertNth_of_lt (l : List α) (x : α) (n k : ℕ) (hn : k < n) (hk : k < l.length)
    (hk' : k < (insertNth n x l).length := hk.trans_le (length_le_length_insertNth _ _ _)) :
    (insertNth n x l).get ⟨k, hk'⟩ = l.get ⟨k, hk⟩ 
Arguments: {α : Type u} (l : List α) (x : α) (n k : ℕ) (hn : k < n) (hk : k < l.length) (hk' : k < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l).get ⟨k, hk'⟩ = l.get ⟨k, hk⟩
-- List.nthLe_insertNth_of_lt
@[deprecated get_insertNth_of_lt (since := "2023-01-05")]
theorem nthLe_insertNth_of_lt : ∀ (l : List α) (x : α) (n k : ℕ), k < n → ∀ (hk : k < l.length)
    (hk' : k < (insertNth n x l).length := hk.trans_le (length_le_length_insertNth _ _ _)),
    (insertNth n x l).nthLe k hk' = l.nthLe k hk 
Arguments: {α : Type u} (l : List α) (x : α) (n k : ℕ)
Goal: k < n →
  ∀ (hk : k < l.length) (hk' : optParam (k < (List.insertNth n x l).length) ⋯),
    (List.insertNth n x l).nthLe k hk' = l.nthLe k hk
-- List.getElem_insertNth_self
@[simp]
theorem getElem_insertNth_self (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length)
    (hn' : n < (insertNth n x l).length := (by rwa [length_insertNth _ _ hn, Nat.lt_succ_iff])) :
    (insertNth n x l)[n] = x 
Arguments: {α : Type u} (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length) (hn' : n < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l)[n] = x
-- List.get_insertNth_self
theorem get_insertNth_self (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length)
    (hn' : n < (insertNth n x l).length := (by rwa [length_insertNth _ _ hn, Nat.lt_succ_iff])) :
    (insertNth n x l).get ⟨n, hn'⟩ = x 
Arguments: {α : Type u} (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length) (hn' : n < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l).get ⟨n, hn'⟩ = x
-- List.nthLe_insertNth_self
@[simp, deprecated get_insertNth_self (since := "2023-01-05")]
theorem nthLe_insertNth_self (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length)
    (hn' : n < (insertNth n x l).length := (by rwa [length_insertNth _ _ hn, Nat.lt_succ_iff])) :
    (insertNth n x l).nthLe n hn' = x 
Arguments: {α : Type u} (l : List α) (x : α) (n : ℕ) (hn : n ≤ l.length) (hn' : n < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l).nthLe n hn' = x
-- List.getElem_insertNth_add_succ
theorem getElem_insertNth_add_succ (l : List α) (x : α) (n k : ℕ) (hk' : n + k < l.length)
    (hk : n + k + 1 < (insertNth n x l).length := (by
      rwa [length_insertNth _ _ (by omega), Nat.succ_lt_succ_iff])) :
    (insertNth n x l)[n + k + 1] = l[n + k] 
Arguments: {α : Type u} (l : List α) (x : α) (n k : ℕ) (hk' : n + k < l.length) (hk : n + k + 1 < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l)[n + k + 1] = l[n + k]
-- List.get_insertNth_add_succ
theorem get_insertNth_add_succ (l : List α) (x : α) (n k : ℕ) (hk' : n + k < l.length)
    (hk : n + k + 1 < (insertNth n x l).length := (by
      rwa [length_insertNth _ _ (by omega), Nat.succ_lt_succ_iff])) :
    (insertNth n x l).get ⟨n + k + 1, hk⟩ = get l ⟨n + k, hk'⟩ 
Arguments: {α : Type u} (l : List α) (x : α) (n k : ℕ) (hk' : n + k < l.length) (hk : n + k + 1 < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l).get ⟨n + k + 1, hk⟩ = l.get ⟨n + k, hk'⟩
-- List.nthLe_insertNth_add_succ
@[deprecated get_insertNth_add_succ (since := "2023-01-05")]
theorem nthLe_insertNth_add_succ : ∀ (l : List α) (x : α) (n k : ℕ) (hk' : n + k < l.length)
    (hk : n + k + 1 < (insertNth n x l).length := (by
      rwa [length_insertNth _ _ (by omega), Nat.succ_lt_succ_iff])),
    (insertNth n x l).nthLe (n + k + 1) hk = nthLe l (n + k) hk' 
Arguments: {α : Type u} (l : List α) (x : α) (n k : ℕ) (hk' : n + k < l.length) (hk : n + k + 1 < (List.insertNth n x l).length := ⋯)
Goal: (List.insertNth n x l).nthLe (n + k + 1) hk = l.nthLe (n + k) hk'
-- List.insertNth_injective
theorem insertNth_injective (n : ℕ) (x : α) : Function.Injective (insertNth n x) 
Arguments: {α : Type u} (n : ℕ) (x : α)
Goal: Function.Injective (List.insertNth n x)
-- List.Ico.zero_bot
theorem zero_bot (n : ℕ) : Ico 0 n = range n 
Arguments: (n : ℕ)
Goal: List.Ico 0 n = List.range n
-- List.Ico.length
@[simp]
theorem length (n m : ℕ) : length (Ico n m) = m - n 
Arguments: (n m : ℕ)
Goal: (List.Ico n m).length = m - n
-- List.Ico.pairwise_lt
theorem pairwise_lt (n m : ℕ) : Pairwise (· < ·) (Ico n m) 
Arguments: (n m : ℕ)
Goal: List.Pairwise (fun x x_1 => x < x_1) (List.Ico n m)
-- List.Ico.nodup
theorem nodup (n m : ℕ) : Nodup (Ico n m) 
Arguments: (n m : ℕ)
Goal: (List.Ico n m).Nodup
-- List.Ico.mem
@[simp]
theorem mem {n m l : ℕ} : l ∈ Ico n m ↔ n ≤ l ∧ l < m 
Arguments: {n m l : ℕ}
Goal: l ∈ List.Ico n m ↔ n ≤ l ∧ l < m
-- List.Ico.eq_nil_of_le
theorem eq_nil_of_le {n m : ℕ} (h : m ≤ n) : Ico n m = [] 
Arguments: {n m : ℕ} (h : m ≤ n)
Goal: List.Ico n m = []
-- List.Ico.map_add
theorem map_add (n m k : ℕ) : (Ico n m).map (k + ·) = Ico (n + k) (m + k) 
Arguments: (n m k : ℕ)
Goal: List.map (fun x => k + x) (List.Ico n m) = List.Ico (n + k) (m + k)
-- List.Ico.map_sub
theorem map_sub (n m k : ℕ) (h₁ : k ≤ n) :
    ((Ico n m).map fun x => x - k) = Ico (n - k) (m - k) 
Arguments: (n m k : ℕ) (h₁ : k ≤ n)
Goal: List.map (fun x => x - k) (List.Ico n m) = List.Ico (n - k) (m - k)
-- List.Ico.self_empty
@[simp]
theorem self_empty {n : ℕ} : Ico n n = [] 
Arguments: {n : ℕ}
Goal: List.Ico n n = []
-- List.Ico.eq_empty_iff
@[simp]
theorem eq_empty_iff {n m : ℕ} : Ico n m = [] ↔ m ≤ n 
Arguments: {n m : ℕ}
Goal: List.Ico n m = [] ↔ m ≤ n
-- List.Ico.append_consecutive
theorem append_consecutive {n m l : ℕ} (hnm : n ≤ m) (hml : m ≤ l) :
    Ico n m ++ Ico m l = Ico n l 
Arguments: {n m l : ℕ} (hnm : n ≤ m) (hml : m ≤ l)
Goal: List.Ico n m ++ List.Ico m l = List.Ico n l
-- List.Ico.inter_consecutive
@[simp]
theorem inter_consecutive (n m l : ℕ) : Ico n m ∩ Ico m l = [] 
Arguments: (n m l : ℕ)
Goal: List.Ico n m ∩ List.Ico m l = []
-- List.Ico.bagInter_consecutive
@[simp]
theorem bagInter_consecutive (n m l : Nat) :
    @List.bagInter ℕ instBEqOfDecidableEq (Ico n m) (Ico m l) = [] 
Arguments: (n m l : ℕ)
Goal: (List.Ico n m).bagInter (List.Ico m l) = []
-- List.Ico.succ_singleton
@[simp]
theorem succ_singleton {n : ℕ} : Ico n (n + 1) = [n] 
Arguments: {n : ℕ}
Goal: List.Ico n (n + 1) = [n]
-- List.Ico.succ_top
theorem succ_top {n m : ℕ} (h : n ≤ m) : Ico n (m + 1) = Ico n m ++ [m] 
Arguments: {n m : ℕ} (h : n ≤ m)
Goal: List.Ico n (m + 1) = List.Ico n m ++ [m]
-- List.Ico.eq_cons
theorem eq_cons {n m : ℕ} (h : n < m) : Ico n m = n :: Ico (n + 1) m 
Arguments: {n m : ℕ} (h : n < m)
Goal: List.Ico n m = n :: List.Ico (n + 1) m
-- List.Ico.pred_singleton
@[simp]
theorem pred_singleton {m : ℕ} (h : 0 < m) : Ico (m - 1) m = [m - 1] 
Arguments: {m : ℕ} (h : 0 < m)
Goal: List.Ico (m - 1) m = [m - 1]
-- List.Ico.chain'_succ
theorem chain'_succ (n m : ℕ) : Chain' (fun a b => b = succ a) (Ico n m) 
Arguments: (n m : ℕ)
Goal: List.Chain' (fun a b => b = a.succ) (List.Ico n m)
-- List.Ico.not_mem_top
theorem not_mem_top {n m : ℕ} : m ∉ Ico n m 
Arguments: {n m : ℕ}
Goal: m ∉ List.Ico n m
-- List.Ico.filter_lt_of_top_le
theorem filter_lt_of_top_le {n m l : ℕ} (hml : m ≤ l) :
    ((Ico n m).filter fun x => x < l) = Ico n m 
Arguments: {n m l : ℕ} (hml : m ≤ l)
Goal: List.filter (fun x => decide (x < l)) (List.Ico n m) = List.Ico n m
-- List.Ico.filter_lt_of_le_bot
theorem filter_lt_of_le_bot {n m l : ℕ} (hln : l ≤ n) : ((Ico n m).filter fun x => x < l) = [] 
Arguments: {n m l : ℕ} (hln : l ≤ n)
Goal: List.filter (fun x => decide (x < l)) (List.Ico n m) = []
-- List.Ico.filter_lt_of_ge
theorem filter_lt_of_ge {n m l : ℕ} (hlm : l ≤ m) :
    ((Ico n m).filter fun x => x < l) = Ico n l 
Arguments: {n m l : ℕ} (hlm : l ≤ m)
Goal: List.filter (fun x => decide (x < l)) (List.Ico n m) = List.Ico n l
-- List.Ico.filter_lt
@[simp]
theorem filter_lt (n m l : ℕ) :
    ((Ico n m).filter fun x => x < l) = Ico n (min m l) 
Arguments: (n m l : ℕ)
Goal: List.filter (fun x => decide (x < l)) (List.Ico n m) = List.Ico n (min m l)
-- List.Ico.filter_le_of_le_bot
theorem filter_le_of_le_bot {n m l : ℕ} (hln : l ≤ n) :
    ((Ico n m).filter fun x => l ≤ x) = Ico n m 
Arguments: {n m l : ℕ} (hln : l ≤ n)
Goal: List.filter (fun x => decide (l ≤ x)) (List.Ico n m) = List.Ico n m
-- List.Ico.filter_le_of_top_le
theorem filter_le_of_top_le {n m l : ℕ} (hml : m ≤ l) : ((Ico n m).filter fun x => l ≤ x) = [] 
Arguments: {n m l : ℕ} (hml : m ≤ l)
Goal: List.filter (fun x => decide (l ≤ x)) (List.Ico n m) = []
-- List.Ico.filter_le_of_le
theorem filter_le_of_le {n m l : ℕ} (hnl : n ≤ l) :
    ((Ico n m).filter fun x => l ≤ x) = Ico l m 
Arguments: {n m l : ℕ} (hnl : n ≤ l)
Goal: List.filter (fun x => decide (l ≤ x)) (List.Ico n m) = List.Ico l m
-- List.Ico.filter_le
@[simp]
theorem filter_le (n m l : ℕ) : ((Ico n m).filter fun x => l ≤ x) = Ico (max n l) m 
Arguments: (n m l : ℕ)
Goal: List.filter (fun x => decide (l ≤ x)) (List.Ico n m) = List.Ico (max n l) m
-- List.Ico.filter_lt_of_succ_bot
theorem filter_lt_of_succ_bot {n m : ℕ} (hnm : n < m) :
    ((Ico n m).filter fun x => x < n + 1) = [n] 
Arguments: {n m : ℕ} (hnm : n < m)
Goal: List.filter (fun x => decide (x < n + 1)) (List.Ico n m) = [n]
-- List.Ico.filter_le_of_bot
@[simp]
theorem filter_le_of_bot {n m : ℕ} (hnm : n < m) : ((Ico n m).filter fun x => x ≤ n) = [n] 
Arguments: {n m : ℕ} (hnm : n < m)
Goal: List.filter (fun x => decide (x ≤ n)) (List.Ico n m) = [n]
-- List.Ico.trichotomy
theorem trichotomy (n a b : ℕ) : n < a ∨ b ≤ n ∨ n ∈ Ico a b 
Arguments: (n a b : ℕ)
Goal: n < a ∨ b ≤ n ∨ n ∈ List.Ico a b
-- Batteries.DList_singleton
@[simp]
theorem DList_singleton {α : Type*} {a : α} : DList.singleton a = DList.lazy_ofList [a] 
Arguments: {α : Type u_1} {a : α}
Goal: Batteries.DList.singleton a = Batteries.DList.lazy_ofList { fn := fun x => [a] }
-- Batteries.DList_lazy
@[simp]
theorem DList_lazy {α : Type*} {l : List α} : DList.lazy_ofList l = Batteries.DList.ofList l 
Arguments: {α : Type u_1} {l : List α}
Goal: Batteries.DList.lazy_ofList { fn := fun x => l } = Batteries.DList.ofList l
-- List.zip_swap
@[simp]
theorem zip_swap : ∀ (l₁ : List α) (l₂ : List β), (zip l₁ l₂).map Prod.swap = zip l₂ l₁
  
Arguments: {α : Type u} {β : Type u_1} (l₁ : List α) (l₂ : List β)
Goal: List.map Prod.swap (l₁.zip l₂) = l₂.zip l₁
-- List.forall_zipWith
theorem forall_zipWith {f : α → β → γ} {p : γ → Prop} :
    ∀ {l₁ : List α} {l₂ : List β}, length l₁ = length l₂ →
      (Forall p (zipWith f l₁ l₂) ↔ Forall₂ (fun x y => p (f x y)) l₁ l₂)
  
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {p : γ → Prop} {l₁ : List α} {l₂ : List β}
Goal: l₁.length = l₂.length → (List.Forall p (List.zipWith f l₁ l₂) ↔ List.Forall₂ (fun x y => p (f x y)) l₁ l₂)
-- List.lt_length_left_of_zipWith
theorem lt_length_left_of_zipWith {f : α → β → γ} {i : ℕ} {l : List α} {l' : List β}
    (h : i < (zipWith f l l').length) : i < l.length 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {i : ℕ} {l : List α} {l' : List β} (h : i < (List.zipWith f l l').length)
Goal: i < l.length
-- List.lt_length_right_of_zipWith
theorem lt_length_right_of_zipWith {f : α → β → γ} {i : ℕ} {l : List α} {l' : List β}
    (h : i < (zipWith f l l').length) : i < l'.length 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {i : ℕ} {l : List α} {l' : List β} (h : i < (List.zipWith f l l').length)
Goal: i < l'.length
-- List.lt_length_left_of_zip
theorem lt_length_left_of_zip {i : ℕ} {l : List α} {l' : List β} (h : i < (zip l l').length) :
    i < l.length 
Arguments: {α : Type u} {β : Type u_1} {i : ℕ} {l : List α} {l' : List β} (h : i < (l.zip l').length)
Goal: i < l.length
-- List.lt_length_right_of_zip
theorem lt_length_right_of_zip {i : ℕ} {l : List α} {l' : List β} (h : i < (zip l l').length) :
    i < l'.length 
Arguments: {α : Type u} {β : Type u_1} {i : ℕ} {l : List α} {l' : List β} (h : i < (l.zip l').length)
Goal: i < l'.length
-- List.mem_zip
theorem mem_zip {a b} : ∀ {l₁ : List α} {l₂ : List β}, (a, b) ∈ zip l₁ l₂ → a ∈ l₁ ∧ b ∈ l₂
  
Arguments: {α : Type u} {β : Type u_1} {a : α} {b : β} {l₁ : List α} {l₂ : List β}
Goal: (a, b) ∈ l₁.zip l₂ → a ∈ l₁ ∧ b ∈ l₂
-- List.unzip_eq_map
theorem unzip_eq_map : ∀ l : List (α × β), unzip l = (l.map Prod.fst, l.map Prod.snd)
  
Arguments: {α : Type u} {β : Type u_1} (l : List (α × β))
Goal: l.unzip = (List.map Prod.fst l, List.map Prod.snd l)
-- List.unzip_left
theorem unzip_left (l : List (α × β)) : (unzip l).1 = l.map Prod.fst 
Arguments: {α : Type u} {β : Type u_1} (l : List (α × β))
Goal: l.unzip.1 = List.map Prod.fst l
-- List.unzip_right
theorem unzip_right (l : List (α × β)) : (unzip l).2 = l.map Prod.snd 
Arguments: {α : Type u} {β : Type u_1} (l : List (α × β))
Goal: l.unzip.2 = List.map Prod.snd l
-- List.unzip_swap
theorem unzip_swap (l : List (α × β)) : unzip (l.map Prod.swap) = (unzip l).swap 
Arguments: {α : Type u} {β : Type u_1} (l : List (α × β))
Goal: (List.map Prod.swap l).unzip = l.unzip.swap
-- List.zip_unzip
theorem zip_unzip : ∀ l : List (α × β), zip (unzip l).1 (unzip l).2 = l
  
Arguments: {α : Type u} {β : Type u_1} (l : List (α × β))
Goal: l.unzip.1.zip l.unzip.2 = l
-- List.unzip_zip_left
theorem unzip_zip_left :
    ∀ {l₁ : List α} {l₂ : List β}, length l₁ ≤ length l₂ → (unzip (zip l₁ l₂)).1 = l₁
  
Arguments: {α : Type u} {β : Type u_1} {l₁ : List α} {l₂ : List β}
Goal: l₁.length ≤ l₂.length → (l₁.zip l₂).unzip.1 = l₁
-- List.unzip_zip_right
theorem unzip_zip_right {l₁ : List α} {l₂ : List β} (h : length l₂ ≤ length l₁) :
    (unzip (zip l₁ l₂)).2 = l₂ 
Arguments: {α : Type u} {β : Type u_1} {l₁ : List α} {l₂ : List β} (h : l₂.length ≤ l₁.length)
Goal: (l₁.zip l₂).unzip.2 = l₂
-- List.unzip_zip
theorem unzip_zip {l₁ : List α} {l₂ : List β} (h : length l₁ = length l₂) :
    unzip (zip l₁ l₂) = (l₁, l₂) 
Arguments: {α : Type u} {β : Type u_1} {l₁ : List α} {l₂ : List β} (h : l₁.length = l₂.length)
Goal: (l₁.zip l₂).unzip = (l₁, l₂)
-- List.zip_of_prod
theorem zip_of_prod {l : List α} {l' : List β} {lp : List (α × β)} (hl : lp.map Prod.fst = l)
    (hr : lp.map Prod.snd = l') : lp = l.zip l' 
Arguments: {α : Type u} {β : Type u_1} {l : List α} {l' : List β} {lp : List (α × β)} (hl : List.map Prod.fst lp = l) (hr : List.map Prod.snd lp = l')
Goal: lp = l.zip l'
-- List.map_prod_left_eq_zip
theorem map_prod_left_eq_zip {l : List α} (f : α → β) :
    (l.map fun x => (x, f x)) = l.zip (l.map f) 
Arguments: {α : Type u} {β : Type u_1} {l : List α} (f : α → β)
Goal: List.map (fun x => (x, f x)) l = l.zip (List.map f l)
-- List.map_prod_right_eq_zip
theorem map_prod_right_eq_zip {l : List α} (f : α → β) :
    (l.map fun x => (f x, x)) = (l.map f).zip l 
Arguments: {α : Type u} {β : Type u_1} {l : List α} (f : α → β)
Goal: List.map (fun x => (f x, x)) l = (List.map f l).zip l
-- List.zipWith_comm
theorem zipWith_comm (f : α → β → γ) :
    ∀ (la : List α) (lb : List β), zipWith f la lb = zipWith (fun b a => f a b) lb la
  
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (la : List α) (lb : List β)
Goal: List.zipWith f la lb = List.zipWith (fun b a => f a b) lb la
-- List.zipWith_congr
@[congr]
theorem zipWith_congr (f g : α → β → γ) (la : List α) (lb : List β)
    (h : List.Forall₂ (fun a b => f a b = g a b) la lb) : zipWith f la lb = zipWith g la lb 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f g : α → β → γ) (la : List α) (lb : List β) (h : List.Forall₂ (fun a b => f a b = g a b) la lb)
Goal: List.zipWith f la lb = List.zipWith g la lb
-- List.zipWith_comm_of_comm
theorem zipWith_comm_of_comm (f : α → α → β) (comm : ∀ x y : α, f x y = f y x) (l l' : List α) :
    zipWith f l l' = zipWith f l' l 
Arguments: {α : Type u} {β : Type u_1} (f : α → α → β) (comm : ∀ (x y : α), f x y = f y x) (l l' : List α)
Goal: List.zipWith f l l' = List.zipWith f l' l
-- List.zipWith_same
@[simp]
theorem zipWith_same (f : α → α → δ) : ∀ l : List α, zipWith f l l = l.map fun a => f a a
  
Arguments: {α : Type u} {δ : Type u_3} (f : α → α → δ) (l : List α)
Goal: List.zipWith f l l = List.map (fun a => f a a) l