ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.lookmap_id'
theorem lookmap_id' (h : ∀ (a), ∀ b ∈ f a, a = b) (l : List α) : l.lookmap f = l 
Arguments: {α : Type u} (f : α → Option α) (h : ∀ (a b : α), b ∈ f a → a = b) (l : List α)
Goal: List.lookmap f l = l
-- List.length_lookmap
theorem length_lookmap (l : List α) : length (l.lookmap f) = length l 
Arguments: {α : Type u} (f : α → Option α) (l : List α)
Goal: (List.lookmap f l).length = l.length
-- List.length_eq_length_filter_add
theorem length_eq_length_filter_add {l : List (α)} (f : α → Bool) :
    l.length = (l.filter f).length + (l.filter (! f ·)).length 
Arguments: {α : Type u} {l : List α} (f : α → Bool)
Goal: l.length = (List.filter f l).length + (List.filter (fun x => !f x) l).length
-- List.Sublist.map
theorem Sublist.map (f : α → β) {l₁ l₂ : List α} (s : l₁ <+ l₂) : map f l₁ <+ map f l₂ 
Arguments: {α : Type u} {β : Type v} (f : α → β) {l₁ l₂ : List α} (s : l₁.Sublist l₂)
Goal: (List.map f l₁).Sublist (List.map f l₂)
-- List.filterMap_eq_bind_toList
theorem filterMap_eq_bind_toList (f : α → Option β) (l : List α) :
    l.filterMap f = l.bind fun a ↦ (f a).toList 
Arguments: {α : Type u} {β : Type v} (f : α → Option β) (l : List α)
Goal: List.filterMap f l = l.bind fun a => (f a).toList
-- List.filterMap_congr
theorem filterMap_congr {f g : α → Option β} {l : List α}
    (h : ∀ x ∈ l, f x = g x) : l.filterMap f = l.filterMap g 
Arguments: {α : Type u} {β : Type v} {f g : α → Option β} {l : List α} (h : ∀ (x : α), x ∈ l → f x = g x)
Goal: List.filterMap f l = List.filterMap g l
-- List.filterMap_eq_map_iff_forall_eq_some
theorem filterMap_eq_map_iff_forall_eq_some {f : α → Option β} {g : α → β} {l : List α} :
    l.filterMap f = l.map g ↔ ∀ x ∈ l, f x = some (g x) 
Arguments: {α : Type u} {β : Type v} {f : α → Option β} {g : α → β} {l : List α}
Goal: List.filterMap f l = List.map g l ↔ ∀ (x : α), x ∈ l → f x = some (g x)
-- List.filter_singleton
theorem filter_singleton {a : α} : [a].filter p = bif p a then [a] else [] 
Arguments: {α : Type u} {p : α → Bool} {a : α}
Goal: List.filter p [a] = bif p a then [a] else []
-- List.filter_eq_foldr
theorem filter_eq_foldr (p : α → Bool) (l : List α) :
    filter p l = foldr (fun a out => bif p a then a :: out else out) [] l 
Arguments: {α : Type u} (p : α → Bool) (l : List α)
Goal: List.filter p l = List.foldr (fun a out => bif p a then a :: out else out) [] l
-- List.filter_subset
@[simp]
theorem filter_subset (l : List α) : filter p l ⊆ l 
Arguments: {α : Type u} {p : α → Bool} (l : List α)
Goal: List.filter p l ⊆ l
-- List.of_mem_filter
theorem of_mem_filter {a : α} {l} (h : a ∈ filter p l) : p a 
Arguments: {α : Type u} {p : α → Bool} {a : α} {l : List α} (h : a ∈ List.filter p l)
Goal: p a = true
-- List.mem_of_mem_filter
theorem mem_of_mem_filter {a : α} {l} (h : a ∈ filter p l) : a ∈ l 
Arguments: {α : Type u} {p : α → Bool} {a : α} {l : List α} (h : a ∈ List.filter p l)
Goal: a ∈ l
-- List.mem_filter_of_mem
theorem mem_filter_of_mem {a : α} {l} (h₁ : a ∈ l) (h₂ : p a) : a ∈ filter p l 
Arguments: {α : Type u} {p : α → Bool} {a : α} {l : List α} (h₁ : a ∈ l) (h₂ : p a = true)
Goal: a ∈ List.filter p l
-- List.monotone_filter_left
theorem monotone_filter_left (p : α → Bool) ⦃l l' : List α⦄ (h : l ⊆ l') :
    filter p l ⊆ filter p l' 
Arguments: {α : Type u} (p : α → Bool) ⦃l l' : List α⦄ (h : l ⊆ l')
Goal: List.filter p l ⊆ List.filter p l'
-- List.monotone_filter_right
theorem monotone_filter_right (l : List α) ⦃p q : α → Bool⦄
    (h : ∀ a, p a → q a) : l.filter p <+ l.filter q 
Arguments: {α : Type u} (l : List α) ⦃p q : α → Bool⦄ (h : ∀ (a : α), p a = true → q a = true)
Goal: (List.filter p l).Sublist (List.filter q l)
-- List.map_filter'
lemma map_filter' {f : α → β} (hf : Injective f) (l : List α)
    [DecidablePred fun b => ∃ a, p a ∧ f a = b] :
    (l.filter p).map f = (l.map f).filter fun b => ∃ a, p a ∧ f a = b 
Arguments: {α : Type u} {β : Type v} (p : α → Bool) {f : α → β} (hf : Function.Injective f) (l : List α) [DecidablePred fun b => ∃ a, p a = true ∧ f a = b]
Goal: List.map f (List.filter p l) = List.filter (fun b => decide (∃ a, p a = true ∧ f a = b)) (List.map f l)
-- List.filter_attach'
lemma filter_attach' (l : List α) (p : {a // a ∈ l} → Bool) [DecidableEq α] :
    l.attach.filter p =
      (l.filter fun x => ∃ h, p ⟨x, h⟩).attach.map (Subtype.map id fun x => mem_of_mem_filter) 
Arguments: {α : Type u} (l : List α) (p : { a // a ∈ l } → Bool) [DecidableEq α]
Goal: List.filter p l.attach = List.map (Subtype.map id ⋯) (List.filter (fun x => decide (∃ h, p ⟨x, h⟩ = true)) l).attach
-- List.filter_attach
lemma filter_attach (l : List α) (p : α → Bool) :
    (l.attach.filter fun x => p x : List {x // x ∈ l}) =
      (l.filter p).attach.map (Subtype.map id fun x => mem_of_mem_filter) 
Arguments: {α : Type u} (l : List α) (p : α → Bool)
Goal: List.filter (fun x => p ↑x) l.attach = List.map (Subtype.map id ⋯) (List.filter p l).attach
-- List.filter_comm
lemma filter_comm (q) (l : List α) : filter p (filter q l) = filter q (filter p l) 
Arguments: {α : Type u} (p q : α → Bool) (l : List α)
Goal: List.filter p (List.filter q l) = List.filter q (List.filter p l)
-- List.filter_true
@[simp]
theorem filter_true (l : List α) :
    filter (fun _ => true) l = l 
Arguments: {α : Type u} (l : List α)
Goal: List.filter (fun x => true) l = l
-- List.filter_false
@[simp]
theorem filter_false (l : List α) :
    filter (fun _ => false) l = [] 
Arguments: {α : Type u} (l : List α)
Goal: List.filter (fun x => false) l = []
-- List.span.loop_eq_take_drop
theorem span.loop_eq_take_drop :
    ∀ l₁ l₂ : List α, span.loop p l₁ l₂ = (l₂.reverse ++ takeWhile p l₁, dropWhile p l₁)
  
Arguments: {α : Type u} (p : α → Bool) (l₁ l₂ : List α)
Goal: List.span.loop p l₁ l₂ = (l₂.reverse ++ List.takeWhile p l₁, List.dropWhile p l₁)
-- List.span_eq_take_drop
@[simp]
theorem span_eq_take_drop (l : List α) : span p l = (takeWhile p l, dropWhile p l) 
Arguments: {α : Type u} (p : α → Bool) (l : List α)
Goal: List.span p l = (List.takeWhile p l, List.dropWhile p l)
-- List.dropWhile_nthLe_zero_not
theorem dropWhile_nthLe_zero_not (l : List α) (hl : 0 < (l.dropWhile p).length) :
    ¬p ((l.dropWhile p).nthLe 0 hl) 
Arguments: {α : Type u} (p : α → Bool) (l : List α) (hl : 0 < (List.dropWhile p l).length)
Goal: ¬p ((List.dropWhile p l).nthLe 0 hl) = true
-- List.dropWhile_eq_nil_iff
@[simp]
theorem dropWhile_eq_nil_iff : dropWhile p l = [] ↔ ∀ x ∈ l, p x 
Arguments: {α : Type u} {p : α → Bool} {l : List α}
Goal: List.dropWhile p l = [] ↔ ∀ (x : α), x ∈ l → p x = true
-- List.takeWhile_cons_of_pos
theorem takeWhile_cons_of_pos {x : α} (h : p x) :
    List.takeWhile p (x :: l) = x :: takeWhile p l 
Arguments: {α : Type u} {p : α → Bool} {l : List α} {x : α} (h : p x = true)
Goal: List.takeWhile p (x :: l) = x :: List.takeWhile p l
-- List.takeWhile_cons_of_neg
theorem takeWhile_cons_of_neg {x : α} (h : ¬ p x) :
    List.takeWhile p (x :: l) = [] 
Arguments: {α : Type u} {p : α → Bool} {l : List α} {x : α} (h : ¬p x = true)
Goal: List.takeWhile p (x :: l) = []
-- List.takeWhile_eq_self_iff
@[simp]
theorem takeWhile_eq_self_iff : takeWhile p l = l ↔ ∀ x ∈ l, p x 
Arguments: {α : Type u} {p : α → Bool} {l : List α}
Goal: List.takeWhile p l = l ↔ ∀ (x : α), x ∈ l → p x = true
-- List.takeWhile_eq_nil_iff
@[simp]
theorem takeWhile_eq_nil_iff : takeWhile p l = [] ↔ ∀ hl : 0 < l.length, ¬p (l.nthLe 0 hl) 
Arguments: {α : Type u} {p : α → Bool} {l : List α}
Goal: List.takeWhile p l = [] ↔ ∀ (hl : 0 < l.length), ¬p (l.nthLe 0 hl) = true
-- List.mem_takeWhile_imp
theorem mem_takeWhile_imp {x : α} (hx : x ∈ takeWhile p l) : p x 
Arguments: {α : Type u} {p : α → Bool} {l : List α} {x : α} (hx : x ∈ List.takeWhile p l)
Goal: p x = true
-- List.takeWhile_takeWhile
theorem takeWhile_takeWhile (p q : α → Bool) (l : List α) :
    takeWhile p (takeWhile q l) = takeWhile (fun a => p a ∧ q a) l 
Arguments: {α : Type u} (p q : α → Bool) (l : List α)
Goal: List.takeWhile p (List.takeWhile q l) = List.takeWhile (fun a => decide (p a = true ∧ q a = true)) l
-- List.takeWhile_idem
theorem takeWhile_idem : takeWhile p (takeWhile p l) = takeWhile p l 
Arguments: {α : Type u} {p : α → Bool} {l : List α}
Goal: List.takeWhile p (List.takeWhile p l) = List.takeWhile p l
-- List.length_eraseP_add_one
@[simp]
theorem length_eraseP_add_one {l : List α} {a} (al : a ∈ l) (pa : p a) :
    (l.eraseP p).length + 1 = l.length 
Arguments: {α : Type u} {p : α → Bool} {l : List α} {a : α} (al : a ∈ l) (pa : p a = true)
Goal: (List.eraseP p l).length + 1 = l.length
-- List.length_erase_add_one
@[simp] theorem length_erase_add_one {a : α} {l : List α} (h : a ∈ l) :
    (l.erase a).length + 1 = l.length 
Arguments: {α : Type u} [DecidableEq α] {a : α} {l : List α} (h : a ∈ l)
Goal: (l.erase a).length + 1 = l.length
-- List.map_erase
theorem map_erase [DecidableEq β] {f : α → β} (finj : Injective f) {a : α} (l : List α) :
    map f (l.erase a) = (map f l).erase (f a) 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] {f : α → β} (finj : Function.Injective f) {a : α} (l : List α)
Goal: List.map f (l.erase a) = (List.map f l).erase (f a)
-- List.map_foldl_erase
theorem map_foldl_erase [DecidableEq β] {f : α → β} (finj : Injective f) {l₁ l₂ : List α} :
    map f (foldl List.erase l₁ l₂) = foldl (fun l a => l.erase (f a)) (map f l₁) l₂ 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] {f : α → β} (finj : Function.Injective f) {l₁ l₂ : List α}
Goal: List.map f (List.foldl List.erase l₁ l₂) = List.foldl (fun l a => l.erase (f a)) (List.map f l₁) l₂
-- List.erase_get
theorem erase_get [DecidableEq ι] {l : List ι} (i : Fin l.length) :
    Perm (l.erase (l.get i)) (l.eraseIdx ↑i) 
Arguments: {ι : Type u_1} [DecidableEq ι] {l : List ι} (i : Fin l.length)
Goal: (l.erase (l.get i)).Perm (l.eraseIdx ↑i)
-- List.length_eraseIdx_add_one
theorem length_eraseIdx_add_one {l : List ι} {i : ℕ} (h : i < l.length) :
    (l.eraseIdx i).length + 1 = l.length 
Arguments: {ι : Type u_1} {l : List ι} {i : ℕ} (h : i < l.length)
Goal: (l.eraseIdx i).length + 1 = l.length
-- List.map_diff
@[simp]
theorem map_diff [DecidableEq β] {f : α → β} (finj : Injective f) {l₁ l₂ : List α} :
    map f (l₁.diff l₂) = (map f l₁).diff (map f l₂) 
Arguments: {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] {f : α → β} (finj : Function.Injective f) {l₁ l₂ : List α}
Goal: List.map f (l₁.diff l₂) = (List.map f l₁).diff (List.map f l₂)
-- List.erase_diff_erase_sublist_of_sublist
theorem erase_diff_erase_sublist_of_sublist {a : α} :
    ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → (l₂.erase a).diff (l₁.erase a) <+ l₂.diff l₁
  
Arguments: {α : Type u} [DecidableEq α] {a : α} {l₁ l₂ : List α}
Goal: l₁.Sublist l₂ → ((l₂.erase a).diff (l₁.erase a)).Sublist (l₂.diff l₁)
-- List.choose_spec
theorem choose_spec (hp : ∃ a, a ∈ l ∧ p a) : choose p l hp ∈ l ∧ p (choose p l hp) 
Arguments: {α : Type u} (p : α → Prop) [DecidablePred p] (l : List α) (hp : ∃ a, a ∈ l ∧ p a)
Goal: List.choose p l hp ∈ l ∧ p (List.choose p l hp)
-- List.choose_mem
theorem choose_mem (hp : ∃ a, a ∈ l ∧ p a) : choose p l hp ∈ l 
Arguments: {α : Type u} (p : α → Prop) [DecidablePred p] (l : List α) (hp : ∃ a, a ∈ l ∧ p a)
Goal: List.choose p l hp ∈ l
-- List.choose_property
theorem choose_property (hp : ∃ a, a ∈ l ∧ p a) : p (choose p l hp) 
Arguments: {α : Type u} (p : α → Prop) [DecidablePred p] (l : List α) (hp : ∃ a, a ∈ l ∧ p a)
Goal: p (List.choose p l hp)
-- List.map₂Left'_nil_right
@[simp]
theorem map₂Left'_nil_right (f : α → Option β → γ) (as) :
    map₂Left' f as [] = (as.map fun a => f a none, []) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → Option β → γ) (as : List α)
Goal: List.map₂Left' f as [] = (List.map (fun a => f a none) as, [])
-- List.map₂Right'_nil_left
@[simp]
theorem map₂Right'_nil_left : map₂Right' f [] bs = (bs.map (f none), []) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (bs : List β)
Goal: List.map₂Right' f [] bs = (List.map (f none) bs, [])
-- List.map₂Right'_nil_right
@[simp]
theorem map₂Right'_nil_right : map₂Right' f as [] = ([], as) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (as : List α)
Goal: List.map₂Right' f as [] = ([], as)
-- List.map₂Right'_nil_cons
theorem map₂Right'_nil_cons : map₂Right' f [] (b :: bs) = (f none b :: bs.map (f none), []) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (b : β) (bs : List β)
Goal: List.map₂Right' f [] (b :: bs) = (f none b :: List.map (f none) bs, [])
-- List.map₂Right'_cons_cons
@[simp]
theorem map₂Right'_cons_cons :
    map₂Right' f (a :: as) (b :: bs) =
      let r := map₂Right' f as bs
      (f (some a) b :: r.fst, r.snd) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (a : α) (as : List α) (b : β) (bs : List β)
Goal: List.map₂Right' f (a :: as) (b :: bs) =
  let r := List.map₂Right' f as bs;
  (f (some a) b :: r.1, r.2)
-- List.zipLeft'_nil_right
@[simp]
theorem zipLeft'_nil_right : zipLeft' as ([] : List β) = (as.map fun a => (a, none), []) 
Arguments: {α : Type u} {β : Type v} (as : List α)
Goal: as.zipLeft' [] = (List.map (fun a => (a, none)) as, [])
-- List.zipLeft'_nil_left
@[simp]
theorem zipLeft'_nil_left : zipLeft' ([] : List α) bs = ([], bs) 
Arguments: {α : Type u} {β : Type v} (bs : List β)
Goal: [].zipLeft' bs = ([], bs)
-- List.zipLeft'_cons_nil
theorem zipLeft'_cons_nil :
    zipLeft' (a :: as) ([] : List β) = ((a, none) :: as.map fun a => (a, none), []) 
Arguments: {α : Type u} {β : Type v} (a : α) (as : List α)
Goal: (a :: as).zipLeft' [] = ((a, none) :: List.map (fun a => (a, none)) as, [])
-- List.zipLeft'_cons_cons
@[simp]
theorem zipLeft'_cons_cons :
    zipLeft' (a :: as) (b :: bs) =
      let r := zipLeft' as bs
      ((a, some b) :: r.fst, r.snd) 
Arguments: {α : Type u} {β : Type v} (a : α) (as : List α) (b : β) (bs : List β)
Goal: (a :: as).zipLeft' (b :: bs) =
  let r := as.zipLeft' bs;
  ((a, some b) :: r.1, r.2)
-- List.zipRight'_nil_left
@[simp]
theorem zipRight'_nil_left : zipRight' ([] : List α) bs = (bs.map fun b => (none, b), []) 
Arguments: {α : Type u} {β : Type v} (bs : List β)
Goal: [].zipRight' bs = (List.map (fun b => (none, b)) bs, [])
-- List.zipRight'_nil_right
@[simp]
theorem zipRight'_nil_right : zipRight' as ([] : List β) = ([], as) 
Arguments: {α : Type u} {β : Type v} (as : List α)
Goal: as.zipRight' [] = ([], as)
-- List.zipRight'_nil_cons
theorem zipRight'_nil_cons :
    zipRight' ([] : List α) (b :: bs) = ((none, b) :: bs.map fun b => (none, b), []) 
Arguments: {α : Type u} {β : Type v} (b : β) (bs : List β)
Goal: [].zipRight' (b :: bs) = ((none, b) :: List.map (fun b => (none, b)) bs, [])
-- List.zipRight'_cons_cons
@[simp]
theorem zipRight'_cons_cons :
    zipRight' (a :: as) (b :: bs) =
      let r := zipRight' as bs
      ((some a, b) :: r.fst, r.snd) 
Arguments: {α : Type u} {β : Type v} (a : α) (as : List α) (b : β) (bs : List β)
Goal: (a :: as).zipRight' (b :: bs) =
  let r := as.zipRight' bs;
  ((some a, b) :: r.1, r.2)
-- List.map₂Left_nil_right
@[simp]
theorem map₂Left_nil_right : map₂Left f as [] = as.map fun a => f a none 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → Option β → γ) (as : List α)
Goal: List.map₂Left f as [] = List.map (fun a => f a none) as
-- List.map₂Left_eq_map₂Left'
theorem map₂Left_eq_map₂Left' : ∀ as bs, map₂Left f as bs = (map₂Left' f as bs).fst
  
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → Option β → γ) (as : List α) (bs : List β)
Goal: List.map₂Left f as bs = (List.map₂Left' f as bs).1
-- List.map₂Left_eq_zipWith
theorem map₂Left_eq_zipWith :
    ∀ as bs, length as ≤ length bs → map₂Left f as bs = zipWith (fun a b => f a (some b)) as bs
  
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → Option β → γ) (as : List α) (bs : List β)
Goal: as.length ≤ bs.length → List.map₂Left f as bs = List.zipWith (fun a b => f a (some b)) as bs
-- List.map₂Right_nil_left
@[simp]
theorem map₂Right_nil_left : map₂Right f [] bs = bs.map (f none) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (bs : List β)
Goal: List.map₂Right f [] bs = List.map (f none) bs
-- List.map₂Right_nil_right
@[simp]
theorem map₂Right_nil_right : map₂Right f as [] = [] 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (as : List α)
Goal: List.map₂Right f as [] = []
-- List.map₂Right_nil_cons
theorem map₂Right_nil_cons : map₂Right f [] (b :: bs) = f none b :: bs.map (f none) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (b : β) (bs : List β)
Goal: List.map₂Right f [] (b :: bs) = f none b :: List.map (f none) bs
-- List.map₂Right_cons_cons
@[simp]
theorem map₂Right_cons_cons :
    map₂Right f (a :: as) (b :: bs) = f (some a) b :: map₂Right f as bs 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (a : α) (as : List α) (b : β) (bs : List β)
Goal: List.map₂Right f (a :: as) (b :: bs) = f (some a) b :: List.map₂Right f as bs
-- List.map₂Right_eq_map₂Right'
theorem map₂Right_eq_map₂Right' : map₂Right f as bs = (map₂Right' f as bs).fst 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (as : List α) (bs : List β)
Goal: List.map₂Right f as bs = (List.map₂Right' f as bs).1
-- List.map₂Right_eq_zipWith
theorem map₂Right_eq_zipWith (h : length bs ≤ length as) :
    map₂Right f as bs = zipWith (fun a b => f (some a) b) as bs 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : Option α → β → γ) (as : List α) (bs : List β) (h : bs.length ≤ as.length)
Goal: List.map₂Right f as bs = List.zipWith (fun a b => f (some a) b) as bs
-- List.zipLeft_nil_right
@[simp]
theorem zipLeft_nil_right : zipLeft as ([] : List β) = as.map fun a => (a, none) 
Arguments: {α : Type u} {β : Type v} (as : List α)
Goal: as.zipLeft [] = List.map (fun a => (a, none)) as
-- List.zipLeft_nil_left
@[simp]
theorem zipLeft_nil_left : zipLeft ([] : List α) bs = [] 
Arguments: {α : Type u} {β : Type v} (bs : List β)
Goal: [].zipLeft bs = []
-- List.zipLeft_cons_nil
theorem zipLeft_cons_nil :
    zipLeft (a :: as) ([] : List β) = (a, none) :: as.map fun a => (a, none) 
Arguments: {α : Type u} {β : Type v} (a : α) (as : List α)
Goal: (a :: as).zipLeft [] = (a, none) :: List.map (fun a => (a, none)) as
-- List.zipLeft_cons_cons
@[simp]
theorem zipLeft_cons_cons : zipLeft (a :: as) (b :: bs) = (a, some b) :: zipLeft as bs 
Arguments: {α : Type u} {β : Type v} (a : α) (as : List α) (b : β) (bs : List β)
Goal: (a :: as).zipLeft (b :: bs) = (a, some b) :: as.zipLeft bs
-- List.zipLeft_eq_zipLeft'
theorem zipLeft_eq_zipLeft' (as : List α) (bs : List β) : zipLeft as bs = (zipLeft' as bs).fst 
Arguments: {α : Type u} {β : Type v} (as : List α) (bs : List β)
Goal: as.zipLeft bs = (as.zipLeft' bs).1
-- List.zipRight_nil_left
@[simp]
theorem zipRight_nil_left : zipRight ([] : List α) bs = bs.map fun b => (none, b) 
Arguments: {α : Type u} {β : Type v} (bs : List β)
Goal: [].zipRight bs = List.map (fun b => (none, b)) bs
-- List.zipRight_nil_right
@[simp]
theorem zipRight_nil_right : zipRight as ([] : List β) = [] 
Arguments: {α : Type u} {β : Type v} (as : List α)
Goal: as.zipRight [] = []
-- List.zipRight_nil_cons
theorem zipRight_nil_cons :
    zipRight ([] : List α) (b :: bs) = (none, b) :: bs.map fun b => (none, b) 
Arguments: {α : Type u} {β : Type v} (b : β) (bs : List β)
Goal: [].zipRight (b :: bs) = (none, b) :: List.map (fun b => (none, b)) bs
-- List.zipRight_cons_cons
@[simp]
theorem zipRight_cons_cons : zipRight (a :: as) (b :: bs) = (some a, b) :: zipRight as bs 
Arguments: {α : Type u} {β : Type v} (a : α) (as : List α) (b : β) (bs : List β)
Goal: (a :: as).zipRight (b :: bs) = (some a, b) :: as.zipRight bs
-- List.zipRight_eq_zipRight'
theorem zipRight_eq_zipRight' : zipRight as bs = (zipRight' as bs).fst 
Arguments: {α : Type u} {β : Type v} (as : List α) (bs : List β)
Goal: as.zipRight bs = (as.zipRight' bs).1
-- List.forall_cons
@[simp]
theorem forall_cons (p : α → Prop) (x : α) : ∀ l : List α, Forall p (x :: l) ↔ p x ∧ Forall p l
  
Arguments: {α : Type u} (p : α → Prop) (x : α) (l : List α)
Goal: List.Forall p (x :: l) ↔ p x ∧ List.Forall p l
-- List.forall_iff_forall_mem
theorem forall_iff_forall_mem : ∀ {l : List α}, Forall p l ↔ ∀ x ∈ l, p x
  
Arguments: {α : Type u} {p : α → Prop} {l : List α}
Goal: List.Forall p l ↔ ∀ (x : α), x ∈ l → p x
-- List.Forall.imp
theorem Forall.imp (h : ∀ x, p x → q x) : ∀ {l : List α}, Forall p l → Forall q l
  
Arguments: {α : Type u} {p q : α → Prop} (h : ∀ (x : α), p x → q x) {l : List α}
Goal: List.Forall p l → List.Forall q l
-- List.forall_map_iff
@[simp]
theorem forall_map_iff {p : β → Prop} (f : α → β) : Forall p (l.map f) ↔ Forall (p ∘ f) l 
Arguments: {α : Type u} {β : Type v} {l : List α} {p : β → Prop} (f : α → β)
Goal: List.Forall p (List.map f l) ↔ List.Forall (p ∘ f) l
-- List.getLast_reverse
theorem getLast_reverse {l : List α} (hl : l.reverse ≠ [])
    (hl' : 0 < l.length := (by
      contrapose! hl
      simpa [length_eq_zero] using hl)) :
    l.reverse.getLast hl = l.get ⟨0, hl'⟩ 
Arguments: {α : Type u} {l : List α} (hl : l.reverse ≠ []) (hl' : 0 < l.length := ⋯)
Goal: l.reverse.getLast hl = l.get ⟨0, hl'⟩
-- List.getElem_attach
@[simp]
theorem getElem_attach (L : List α) (i : Nat) (h : i < L.attach.length) :
    L.attach[i].1 = L[i]'(length_attach L ▸ h) 
Arguments: {α : Type u} (L : List α) (i : ℕ) (h : i < L.attach.length)
Goal: ↑L.attach[i] = L[i]
-- List.get_attach
theorem get_attach (L : List α) (i) :
    (L.attach.get i).1 = L.get ⟨i, length_attach L ▸ i.2⟩ 
Arguments: {α : Type u} (L : List α) (i : Fin L.attach.length)
Goal: ↑(L.attach.get i) = L.get ⟨↑i, ⋯⟩
-- List.mem_map_swap
@[simp 1100]
theorem mem_map_swap (x : α) (y : β) (xs : List (α × β)) :
    (y, x) ∈ map Prod.swap xs ↔ (x, y) ∈ xs 
Arguments: {α : Type u} {β : Type v} (x : α) (y : β) (xs : List (α × β))
Goal: (y, x) ∈ List.map Prod.swap xs ↔ (x, y) ∈ xs
-- List.dropSlice_eq
theorem dropSlice_eq (xs : List α) (n m : ℕ) : dropSlice n m xs = xs.take n ++ xs.drop (n + m) 
Arguments: {α : Type u} (xs : List α) (n m : ℕ)
Goal: List.dropSlice n m xs = List.take n xs ++ List.drop (n + m) xs
-- List.length_dropSlice
@[simp]
theorem length_dropSlice (i j : ℕ) (xs : List α) :
    (List.dropSlice i j xs).length = xs.length - min j (xs.length - i) 
Arguments: {α : Type u} (i j : ℕ) (xs : List α)
Goal: (List.dropSlice i j xs).length = xs.length - min j (xs.length - i)
-- List.length_dropSlice_lt
theorem length_dropSlice_lt (i j : ℕ) (hj : 0 < j) (xs : List α) (hi : i < xs.length) :
    (List.dropSlice i j xs).length < xs.length 
Arguments: {α : Type u} (i j : ℕ) (hj : 0 < j) (xs : List α) (hi : i < xs.length)
Goal: (List.dropSlice i j xs).length < xs.length
-- List.sizeOf_dropSlice_lt
@[deprecated (since := "2024-07-25")]
theorem sizeOf_dropSlice_lt [SizeOf α] (i j : ℕ) (hj : 0 < j) (xs : List α) (hi : i < xs.length) :
    SizeOf.sizeOf (List.dropSlice i j xs) < SizeOf.sizeOf xs 
Arguments: {α : Type u} [SizeOf α] (i j : ℕ) (hj : 0 < j) (xs : List α) (hi : i < xs.length)
Goal: sizeOf (List.dropSlice i j xs) < sizeOf xs
-- List.disjoint_pmap
theorem disjoint_pmap {p : α → Prop} {f : ∀ a : α, p a → β} {s t : List α}
    (hs : ∀ a ∈ s, p a) (ht : ∀ a ∈ t, p a)
    (hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a')
    (h : Disjoint s t) :
    Disjoint (s.pmap f hs) (t.pmap f ht) 
Arguments: {α : Type u} {β : Type v} {p : α → Prop} {f : (a : α) → p a → β} {s t : List α} (hs : ∀ (a : α), a ∈ s → p a) (ht : ∀ (a : α), a ∈ t → p a) (hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a') (h : s.Disjoint t)
Goal: (List.pmap f s hs).Disjoint (List.pmap f t ht)
-- List.disjoint_map
theorem disjoint_map {f : α → β} {s t : List α} (hf : Function.Injective f)
    (h : Disjoint s t) : Disjoint (s.map f) (t.map f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {s t : List α} (hf : Function.Injective f) (h : s.Disjoint t)
Goal: (List.map f s).Disjoint (List.map f t)
-- List.lookup_graph
lemma lookup_graph (f : α → β) {a : α} {as : List α} (h : a ∈ as) :
    lookup a (as.map fun x => (x, f x)) = some (f a) 
Arguments: {α : Type u_2} {β : Type u_3} [BEq α] [LawfulBEq α] (f : α → β) {a : α} {as : List α} (h : a ∈ as)
Goal: List.lookup a (List.map (fun x => (x, f x)) as) = some (f a)
-- Set.countable_coe_iff
@[simp]
theorem countable_coe_iff {s : Set α} : Countable s ↔ s.Countable 
Arguments: {α : Type u} {s : Set α}
Goal: Countable ↑s ↔ s.Countable