ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.disjoint_cons_left
@[simp] theorem disjoint_cons_left : Disjoint (a::l₁) l₂ ↔ (a ∉ l₂) ∧ Disjoint l₁ l₂ 
Goal: ∀ {α : Type u_1} {a : α} {l₁ l₂ : List α}, (a :: l₁).Disjoint l₂ ↔ ¬a ∈ l₂ ∧ l₁.Disjoint l₂
-- List.disjoint_cons_right
@[simp] theorem disjoint_cons_right : Disjoint l₁ (a :: l₂) ↔ (a ∉ l₁) ∧ Disjoint l₁ l₂ 
Goal: ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α}, l₁.Disjoint (a :: l₂) ↔ ¬a ∈ l₁ ∧ l₁.Disjoint l₂
-- List.disjoint_of_disjoint_append_left_left
theorem disjoint_of_disjoint_append_left_left (d : Disjoint (l₁ ++ l₂) l) : Disjoint l₁ l 
Goal: ∀ {α : Type u_1} {l₁ l₂ l : List α}, (l₁ ++ l₂).Disjoint l → l₁.Disjoint l
-- List.disjoint_of_disjoint_append_left_right
theorem disjoint_of_disjoint_append_left_right (d : Disjoint (l₁ ++ l₂) l) : Disjoint l₂ l 
Goal: ∀ {α : Type u_1} {l₁ l₂ l : List α}, (l₁ ++ l₂).Disjoint l → l₂.Disjoint l
-- List.disjoint_of_disjoint_append_right_left
theorem disjoint_of_disjoint_append_right_left (d : Disjoint l (l₁ ++ l₂)) : Disjoint l l₁ 
Goal: ∀ {α : Type u_1} {l l₁ l₂ : List α}, l.Disjoint (l₁ ++ l₂) → l.Disjoint l₁
-- List.disjoint_of_disjoint_append_right_right
theorem disjoint_of_disjoint_append_right_right (d : Disjoint l (l₁ ++ l₂)) : Disjoint l l₂ 
Goal: ∀ {α : Type u_1} {l l₁ l₂ : List α}, l.Disjoint (l₁ ++ l₂) → l.Disjoint l₂
-- List.foldl_hom
theorem foldl_hom (f : α₁ → α₂) (g₁ : α₁ → β → α₁) (g₂ : α₂ → β → α₂) (l : List β) (init : α₁)
    (H : ∀ x y, g₂ (f x) y = f (g₁ x y)) : l.foldl g₂ (f init) = f (l.foldl g₁ init) 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} (f : α₁ → α₂) (g₁ : α₁ → β → α₁) (g₂ : α₂ → β → α₂) (l : List β) (init : α₁) (H : ∀ (x : α₁) (y : β), g₂ (f x) y = f (g₁ x y))
Goal: List.foldl g₂ (f init) l = f (List.foldl g₁ init l)
-- List.foldr_hom
theorem foldr_hom (f : β₁ → β₂) (g₁ : α → β₁ → β₁) (g₂ : α → β₂ → β₂) (l : List α) (init : β₁)
    (H : ∀ x y, g₂ x (f y) = f (g₁ x y)) : l.foldr g₂ (f init) = f (l.foldr g₁ init) 
Arguments: {β₁ : Type u_1} {β₂ : Type u_2} {α : Type u_3} (f : β₁ → β₂) (g₁ : α → β₁ → β₁) (g₂ : α → β₂ → β₂) (l : List α) (init : β₁) (H : ∀ (x : α) (y : β₁), g₂ x (f y) = f (g₁ x y))
Goal: List.foldr g₂ (f init) l = f (List.foldr g₁ init l)
-- List.union_def
theorem union_def (l₁ l₂ : List α)  : l₁ ∪ l₂ = foldr .insert l₂ l₁ 
Arguments: {α : Type u_1} [BEq α] (l₁ l₂ : List α)
Goal: l₁ ∪ l₂ = List.foldr List.insert l₂ l₁
-- List.nil_union
@[simp] theorem nil_union (l : List α) : nil ∪ l = l 
Arguments: {α : Type u_1} [BEq α] (l : List α)
Goal: [] ∪ l = l
-- List.cons_union
@[simp] theorem cons_union (a : α) (l₁ l₂ : List α) :
    (a :: l₁) ∪ l₂ = (l₁ ∪ l₂).insert a 
Arguments: {α : Type u_1} [BEq α] (a : α) (l₁ l₂ : List α)
Goal: a :: l₁ ∪ l₂ = List.insert a (l₁ ∪ l₂)
-- List.mem_union_iff
@[simp] theorem mem_union_iff [LawfulBEq α] {x : α} {l₁ l₂ : List α} :
    x ∈ l₁ ∪ l₂ ↔ x ∈ l₁ ∨ x ∈ l₂ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {x : α} {l₁ l₂ : List α}
Goal: x ∈ l₁ ∪ l₂ ↔ x ∈ l₁ ∨ x ∈ l₂
-- List.inter_def
theorem inter_def [BEq α] (l₁ l₂ : List α)  : l₁ ∩ l₂ = filter (elem · l₂) l₁ 
Arguments: {α : Type u_1} [BEq α] (l₁ l₂ : List α)
Goal: l₁ ∩ l₂ = List.filter (fun x => List.elem x l₂) l₁
-- List.mem_inter_iff
@[simp] theorem mem_inter_iff [BEq α] [LawfulBEq α] {x : α} {l₁ l₂ : List α} :
    x ∈ l₁ ∩ l₂ ↔ x ∈ l₁ ∧ x ∈ l₂ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {x : α} {l₁ l₂ : List α}
Goal: x ∈ l₁ ∩ l₂ ↔ x ∈ l₁ ∧ x ∈ l₂
-- List.pair_mem_product
@[simp]
theorem pair_mem_product {xs : List α} {ys : List β} {x : α} {y : β} :
    (x, y) ∈ product xs ys ↔ x ∈ xs ∧ y ∈ ys 
Arguments: {α : Type u_1} {β : Type u_2} {xs : List α} {ys : List β} {x : α} {y : β}
Goal: (x, y) ∈ xs.product ys ↔ x ∈ xs ∧ y ∈ ys
-- List.leftpad_length
@[simp]
theorem leftpad_length (n : Nat) (a : α) (l : List α) :
    (leftpad n a l).length = max n l.length 
Arguments: {α : Type u_1} (n : Nat) (a : α) (l : List α)
Goal: (List.leftpad n a l).length = max n l.length
-- List.leftpad_prefix
theorem leftpad_prefix (n : Nat) (a : α) (l : List α) :
    replicate (n - length l) a <+: leftpad n a l 
Arguments: {α : Type u_1} (n : Nat) (a : α) (l : List α)
Goal: List.replicate (n - l.length) a <+: List.leftpad n a l
-- List.leftpad_suffix
theorem leftpad_suffix (n : Nat) (a : α) (l : List α) : l <:+ (leftpad n a l) 
Arguments: {α : Type u_1} (n : Nat) (a : α) (l : List α)
Goal: l <:+ List.leftpad n a l
-- List.forIn_eq_forIn
@[simp] theorem forIn_eq_forIn [Monad m] : @List.forIn α β m _ = forIn 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m]
Goal: List.forIn = forIn
-- List.forIn_eq_bindList
theorem forIn_eq_bindList [Monad m] [LawfulMonad m]
    (f : α → β → m (ForInStep β)) (l : List α) (init : β) :
    forIn l init f = ForInStep.run <$> (ForInStep.yield init).bindList f l 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → β → m (ForInStep β)) (l : List α) (init : β)
Goal: forIn l init f = ForInStep.run <$> ForInStep.bindList f l (ForInStep.yield init)
-- List.forM_append
@[simp] theorem forM_append [Monad m] [LawfulMonad m] (l₁ l₂ : List α) (f : α → m PUnit) :
    (l₁ ++ l₂).forM f = (do l₁.forM f; l₂.forM f) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} [Monad m] [LawfulMonad m] (l₁ l₂ : List α) (f : α → m PUnit)
Goal: (l₁ ++ l₂).forM f = do
  l₁.forM f
  l₂.forM f
-- List.diff_nil
@[simp] theorem diff_nil (l : List α) : l.diff [] = l 
Arguments: {α : Type u_1} [BEq α] (l : List α)
Goal: l.diff [] = l
-- List.diff_cons
@[simp] theorem diff_cons (l₁ l₂ : List α) (a : α) : l₁.diff (a :: l₂) = (l₁.erase a).diff l₂ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l₁ l₂ : List α) (a : α)
Goal: l₁.diff (a :: l₂) = (l₁.erase a).diff l₂
-- List.diff_cons_right
theorem diff_cons_right (l₁ l₂ : List α) (a : α) : l₁.diff (a :: l₂) = (l₁.diff l₂).erase a 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l₁ l₂ : List α) (a : α)
Goal: l₁.diff (a :: l₂) = (l₁.diff l₂).erase a
-- List.diff_erase
theorem diff_erase (l₁ l₂ : List α) (a : α) : (l₁.diff l₂).erase a = (l₁.erase a).diff l₂ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l₁ l₂ : List α) (a : α)
Goal: (l₁.diff l₂).erase a = (l₁.erase a).diff l₂
-- List.nil_diff
@[simp] theorem nil_diff (l : List α) : [].diff l = [] 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l : List α)
Goal: [].diff l = []
-- List.cons_diff
theorem cons_diff (a : α) (l₁ l₂ : List α) :
    (a :: l₁).diff l₂ = if a ∈ l₂ then l₁.diff (l₂.erase a) else a :: l₁.diff l₂ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a : α) (l₁ l₂ : List α)
Goal: (a :: l₁).diff l₂ = if a ∈ l₂ then l₁.diff (l₂.erase a) else a :: l₁.diff l₂
-- List.cons_diff_of_mem
theorem cons_diff_of_mem {a : α} {l₂ : List α} (h : a ∈ l₂) (l₁ : List α) :
    (a :: l₁).diff l₂ = l₁.diff (l₂.erase a) 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l₂ : List α} (h : a ∈ l₂) (l₁ : List α)
Goal: (a :: l₁).diff l₂ = l₁.diff (l₂.erase a)
-- List.cons_diff_of_not_mem
theorem cons_diff_of_not_mem {a : α} {l₂ : List α} (h : a ∉ l₂) (l₁ : List α) :
    (a :: l₁).diff l₂ = a :: l₁.diff l₂ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l₂ : List α} (h : ¬a ∈ l₂) (l₁ : List α)
Goal: (a :: l₁).diff l₂ = a :: l₁.diff l₂
-- List.diff_eq_foldl
theorem diff_eq_foldl : ∀ l₁ l₂ : List α, l₁.diff l₂ = foldl List.erase l₁ l₂
  
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l₁ l₂ : List α)
Goal: l₁.diff l₂ = List.foldl List.erase l₁ l₂
-- List.diff_append
@[simp] theorem diff_append (l₁ l₂ l₃ : List α) : l₁.diff (l₂ ++ l₃) = (l₁.diff l₂).diff l₃ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l₁ l₂ l₃ : List α)
Goal: l₁.diff (l₂ ++ l₃) = (l₁.diff l₂).diff l₃
-- List.diff_sublist
theorem diff_sublist : ∀ l₁ l₂ : List α, l₁.diff l₂ <+ l₁
  
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l₁ l₂ : List α)
Goal: l₁.diff l₂ <+ l₁
-- List.diff_subset
theorem diff_subset (l₁ l₂ : List α) : l₁.diff l₂ ⊆ l₁ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (l₁ l₂ : List α)
Goal: l₁.diff l₂ ⊆ l₁
-- List.mem_diff_of_mem
theorem mem_diff_of_mem {a : α} : ∀ {l₁ l₂ : List α}, a ∈ l₁ → a ∉ l₂ → a ∈ l₁.diff l₂
  
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l₁ l₂ : List α}
Goal: a ∈ l₁ → ¬a ∈ l₂ → a ∈ l₁.diff l₂
-- List.Sublist.diff_right
theorem Sublist.diff_right : ∀ {l₁ l₂ l₃ : List α}, l₁ <+ l₂ → l₁.diff l₃ <+ l₂.diff l₃
  
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {l₁ l₂ l₃ : List α}
Goal: l₁ <+ l₂ → l₁.diff l₃ <+ l₂.diff l₃
-- List.Sublist.erase_diff_erase_sublist
theorem Sublist.erase_diff_erase_sublist {a : α} :
    ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → (l₂.erase a).diff (l₁.erase a) <+ l₂.diff l₁
  
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a : α} {l₁ l₂ : List α}
Goal: l₁ <+ l₂ → (l₂.erase a).diff (l₁.erase a) <+ l₂.diff l₁
-- List.prefix_append
@[simp] theorem prefix_append (l₁ l₂ : List α) : l₁ <+: l₁ ++ l₂ 
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: l₁ <+: l₁ ++ l₂
-- List.suffix_append
@[simp] theorem suffix_append (l₁ l₂ : List α) : l₂ <:+ l₁ ++ l₂ 
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: l₂ <:+ l₁ ++ l₂
-- List.infix_append
theorem infix_append (l₁ l₂ l₃ : List α) : l₂ <:+: l₁ ++ l₂ ++ l₃ 
Arguments: {α : Type u_1} (l₁ l₂ l₃ : List α)
Goal: l₂ <:+: l₁ ++ l₂ ++ l₃
-- List.infix_append'
@[simp] theorem infix_append' (l₁ l₂ l₃ : List α) : l₂ <:+: l₁ ++ (l₂ ++ l₃) 
Arguments: {α : Type u_1} (l₁ l₂ l₃ : List α)
Goal: l₂ <:+: l₁ ++ (l₂ ++ l₃)
-- List.IsPrefix.isInfix
theorem IsPrefix.isInfix : l₁ <+: l₂ → l₁ <:+: l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → l₁ <:+: l₂
-- List.IsSuffix.isInfix
theorem IsSuffix.isInfix : l₁ <:+ l₂ → l₁ <:+: l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <:+: l₂
-- List.nil_prefix
theorem nil_prefix (l : List α) : [] <+: l 
Arguments: {α : Type u_1} (l : List α)
Goal: [] <+: l
-- List.nil_suffix
theorem nil_suffix (l : List α) : [] <:+ l 
Arguments: {α : Type u_1} (l : List α)
Goal: [] <:+ l
-- List.nil_infix
theorem nil_infix (l : List α) : [] <:+: l 
Arguments: {α : Type u_1} (l : List α)
Goal: [] <:+: l
-- List.prefix_refl
theorem prefix_refl (l : List α) : l <+: l 
Arguments: {α : Type u_1} (l : List α)
Goal: l <+: l
-- List.suffix_refl
theorem suffix_refl (l : List α) : l <:+ l 
Arguments: {α : Type u_1} (l : List α)
Goal: l <:+ l
-- List.infix_refl
theorem infix_refl (l : List α) : l <:+: l 
Arguments: {α : Type u_1} (l : List α)
Goal: l <:+: l
-- List.suffix_cons
@[simp] theorem suffix_cons (a : α) : ∀ l, l <:+ a :: l 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: l <:+ a :: l
-- List.infix_cons
theorem infix_cons : l₁ <:+: l₂ → l₁ <:+: a :: l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α} {a : α}, l₁ <:+: l₂ → l₁ <:+: a :: l₂
-- List.infix_concat
theorem infix_concat : l₁ <:+: l₂ → l₁ <:+: concat l₂ a 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α} {a : α}, l₁ <:+: l₂ → l₁ <:+: l₂.concat a
-- List.IsPrefix.trans
theorem IsPrefix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <+: l₂ → l₂ <+: l₃ → l₁ <+: l₃
  
Arguments: {α : Type u_1} {l₁ l₂ l₃ : List α}
Goal: l₁ <+: l₂ → l₂ <+: l₃ → l₁ <+: l₃
-- List.IsSuffix.trans
theorem IsSuffix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <:+ l₂ → l₂ <:+ l₃ → l₁ <:+ l₃
  
Arguments: {α : Type u_1} {l₁ l₂ l₃ : List α}
Goal: l₁ <:+ l₂ → l₂ <:+ l₃ → l₁ <:+ l₃
-- List.IsInfix.trans
theorem IsInfix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <:+: l₂ → l₂ <:+: l₃ → l₁ <:+: l₃
  
Arguments: {α : Type u_1} {l₁ l₂ l₃ : List α}
Goal: l₁ <:+: l₂ → l₂ <:+: l₃ → l₁ <:+: l₃
-- List.IsInfix.sublist
protected theorem IsInfix.sublist : l₁ <:+: l₂ → l₁ <+ l₂
  
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+: l₂ → l₁ <+ l₂
-- List.IsInfix.subset
protected theorem IsInfix.subset (hl : l₁ <:+: l₂) : l₁ ⊆ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+: l₂ → l₁ ⊆ l₂
-- List.IsPrefix.sublist
protected theorem IsPrefix.sublist (h : l₁ <+: l₂) : l₁ <+ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → l₁ <+ l₂
-- List.IsPrefix.subset
protected theorem IsPrefix.subset (hl : l₁ <+: l₂) : l₁ ⊆ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → l₁ ⊆ l₂
-- List.IsSuffix.sublist
protected theorem IsSuffix.sublist (h : l₁ <:+ l₂) : l₁ <+ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <+ l₂
-- List.IsSuffix.subset
protected theorem IsSuffix.subset (hl : l₁ <:+ l₂) : l₁ ⊆ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ ⊆ l₂
-- List.reverse_suffix
@[simp] theorem reverse_suffix : reverse l₁ <:+ reverse l₂ ↔ l₁ <+: l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.reverse <:+ l₂.reverse ↔ l₁ <+: l₂
-- List.reverse_prefix
@[simp] theorem reverse_prefix : reverse l₁ <+: reverse l₂ ↔ l₁ <:+ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.reverse <+: l₂.reverse ↔ l₁ <:+ l₂
-- List.reverse_infix
@[simp] theorem reverse_infix : reverse l₁ <:+: reverse l₂ ↔ l₁ <:+: l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.reverse <:+: l₂.reverse ↔ l₁ <:+: l₂
-- List.IsInfix.length_le
theorem IsInfix.length_le (h : l₁ <:+: l₂) : l₁.length ≤ l₂.length 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+: l₂ → l₁.length ≤ l₂.length
-- List.IsPrefix.length_le
theorem IsPrefix.length_le (h : l₁ <+: l₂) : l₁.length ≤ l₂.length 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → l₁.length ≤ l₂.length
-- List.IsSuffix.length_le
theorem IsSuffix.length_le (h : l₁ <:+ l₂) : l₁.length ≤ l₂.length 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁.length ≤ l₂.length
-- List.infix_nil
@[simp] theorem infix_nil : l <:+: [] ↔ l = [] 
Goal: ∀ {α : Type u_1} {l : List α}, l <:+: [] ↔ l = []
-- List.prefix_nil
@[simp] theorem prefix_nil : l <+: [] ↔ l = [] 
Goal: ∀ {α : Type u_1} {l : List α}, l <+: [] ↔ l = []
-- List.suffix_nil
@[simp] theorem suffix_nil : l <:+ [] ↔ l = [] 
Goal: ∀ {α : Type u_1} {l : List α}, l <:+ [] ↔ l = []
-- List.infix_iff_prefix_suffix
theorem infix_iff_prefix_suffix (l₁ l₂ : List α) : l₁ <:+: l₂ ↔ ∃ t, l₁ <+: t ∧ t <:+ l₂ 
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: l₁ <:+: l₂ ↔ ∃ t, l₁ <+: t ∧ t <:+ l₂
-- List.IsInfix.eq_of_length
theorem IsInfix.eq_of_length (h : l₁ <:+: l₂) : l₁.length = l₂.length → l₁ = l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+: l₂ → l₁.length = l₂.length → l₁ = l₂
-- List.IsPrefix.eq_of_length
theorem IsPrefix.eq_of_length (h : l₁ <+: l₂) : l₁.length = l₂.length → l₁ = l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → l₁.length = l₂.length → l₁ = l₂
-- List.IsSuffix.eq_of_length
theorem IsSuffix.eq_of_length (h : l₁ <:+ l₂) : l₁.length = l₂.length → l₁ = l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁.length = l₂.length → l₁ = l₂
-- List.prefix_of_prefix_length_le
theorem prefix_of_prefix_length_le :
    ∀ {l₁ l₂ l₃ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → length l₁ ≤ length l₂ → l₁ <+: l₂
  
Arguments: {α : Type u_1} {l₁ l₂ l₃ : List α}
Goal: l₁ <+: l₃ → l₂ <+: l₃ → l₁.length ≤ l₂.length → l₁ <+: l₂
-- List.prefix_or_prefix_of_prefix
theorem prefix_or_prefix_of_prefix (h₁ : l₁ <+: l₃) (h₂ : l₂ <+: l₃) : l₁ <+: l₂ ∨ l₂ <+: l₁ 
Goal: ∀ {α : Type u_1} {l₁ l₃ l₂ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → l₁ <+: l₂ ∨ l₂ <+: l₁
-- List.suffix_of_suffix_length_le
theorem suffix_of_suffix_length_le
    (h₁ : l₁ <:+ l₃) (h₂ : l₂ <:+ l₃) (ll : length l₁ ≤ length l₂) : l₁ <:+ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₃ l₂ : List α}, l₁ <:+ l₃ → l₂ <:+ l₃ → l₁.length ≤ l₂.length → l₁ <:+ l₂
-- List.suffix_or_suffix_of_suffix
theorem suffix_or_suffix_of_suffix (h₁ : l₁ <:+ l₃) (h₂ : l₂ <:+ l₃) : l₁ <:+ l₂ ∨ l₂ <:+ l₁ 
Goal: ∀ {α : Type u_1} {l₁ l₃ l₂ : List α}, l₁ <:+ l₃ → l₂ <:+ l₃ → l₁ <:+ l₂ ∨ l₂ <:+ l₁
-- List.suffix_cons_iff
theorem suffix_cons_iff : l₁ <:+ a :: l₂ ↔ l₁ = a :: l₂ ∨ l₁ <:+ l₂ 
Goal: ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α}, l₁ <:+ a :: l₂ ↔ l₁ = a :: l₂ ∨ l₁ <:+ l₂
-- List.infix_cons_iff
theorem infix_cons_iff : l₁ <:+: a :: l₂ ↔ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂ 
Goal: ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α}, l₁ <:+: a :: l₂ ↔ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂
-- List.infix_of_mem_join
theorem infix_of_mem_join : ∀ {L : List (List α)}, l ∈ L → l <:+: join L
  
Arguments: {α : Type u_1} {l : List α} {L : List (List α)}
Goal: l ∈ L → l <:+: L.join
-- List.prefix_append_right_inj
theorem prefix_append_right_inj (l) : l ++ l₁ <+: l ++ l₂ ↔ l₁ <+: l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α} (l : List α), l ++ l₁ <+: l ++ l₂ ↔ l₁ <+: l₂
-- List.prefix_cons_inj
@[simp]
theorem prefix_cons_inj (a) : a :: l₁ <+: a :: l₂ ↔ l₁ <+: l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α} (a : α), a :: l₁ <+: a :: l₂ ↔ l₁ <+: l₂
-- List.take_prefix
theorem take_prefix (n) (l : List α) : take n l <+: l 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.take n l <+: l
-- List.drop_suffix
theorem drop_suffix (n) (l : List α) : drop n l <:+ l 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.drop n l <:+ l
-- List.take_sublist
theorem take_sublist (n) (l : List α) : take n l <+ l 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.take n l <+ l
-- List.drop_sublist
theorem drop_sublist (n) (l : List α) : drop n l <+ l 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.drop n l <+ l
-- List.take_subset
theorem take_subset (n) (l : List α) : take n l ⊆ l 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.take n l ⊆ l
-- List.drop_subset
theorem drop_subset (n) (l : List α) : drop n l ⊆ l 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.drop n l ⊆ l
-- List.mem_of_mem_take
theorem mem_of_mem_take {l : List α} (h : a ∈ l.take n) : a ∈ l 
Arguments: {α : Type u_1} {a : α} {n : Nat} {l : List α} (h : a ∈ List.take n l)
Goal: a ∈ l
-- List.IsPrefix.filter
theorem IsPrefix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
    l₁.filter p <+: l₂.filter p 
Arguments: {α : Type u_1} (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂)
Goal: List.filter p l₁ <+: List.filter p l₂
-- List.IsSuffix.filter
theorem IsSuffix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
    l₁.filter p <:+ l₂.filter p 
Arguments: {α : Type u_1} (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂)
Goal: List.filter p l₁ <:+ List.filter p l₂
-- List.IsInfix.filter
theorem IsInfix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
    l₁.filter p <:+: l₂.filter p 
Arguments: {α : Type u_1} (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂)
Goal: List.filter p l₁ <:+: List.filter p l₂
-- List.mem_of_mem_drop
theorem mem_of_mem_drop {n} {l : List α} (h : a ∈ l.drop n) : a ∈ l 
Arguments: {α : Type u_1} {a : α} {n : Nat} {l : List α} (h : a ∈ List.drop n l)
Goal: a ∈ l
-- List.disjoint_take_drop
theorem disjoint_take_drop : ∀ {l : List α}, l.Nodup → m ≤ n → Disjoint (l.take m) (l.drop n)
  
Arguments: {α : Type u_1} {m n : Nat} {l : List α}
Goal: l.Nodup → m ≤ n → (List.take m l).Disjoint (List.drop n l)
-- List.chain_cons
@[simp]
theorem chain_cons {a b : α} {l : List α} : Chain R a (b :: l) ↔ R a b ∧ Chain R b l 
Arguments: {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α}
Goal: List.Chain R a (b :: l) ↔ R a b ∧ List.Chain R b l
-- List.rel_of_chain_cons
theorem rel_of_chain_cons {a b : α} {l : List α} (p : Chain R a (b :: l)) : R a b 
Arguments: {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α} (p : List.Chain R a (b :: l))
Goal: R a b
-- List.chain_of_chain_cons
theorem chain_of_chain_cons {a b : α} {l : List α} (p : Chain R a (b :: l)) : Chain R b l 
Arguments: {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α} (p : List.Chain R a (b :: l))
Goal: List.Chain R b l
-- List.Chain.imp'
theorem Chain.imp' {R S : α → α → Prop} (HRS : ∀ ⦃a b⦄, R a b → S a b) {a b : α}
    (Hab : ∀ ⦃c⦄, R a c → S b c) {l : List α} (p : Chain R a l) : Chain S b l 
Arguments: {α : Type u_1} {R S : α → α → Prop} (HRS : ∀ ⦃a b : α⦄, R a b → S a b) {a b : α} (Hab : ∀ ⦃c : α⦄, R a c → S b c) {l : List α} (p : List.Chain R a l)
Goal: List.Chain S b l
-- List.Chain.imp
theorem Chain.imp {R S : α → α → Prop} (H : ∀ a b, R a b → S a b) {a : α} {l : List α}
    (p : Chain R a l) : Chain S a l 
Arguments: {α : Type u_1} {R S : α → α → Prop} (H : ∀ (a b : α), R a b → S a b) {a : α} {l : List α} (p : List.Chain R a l)
Goal: List.Chain S a l
-- List.Pairwise.chain
protected theorem Pairwise.chain (p : Pairwise R (a :: l)) : Chain R a l 
Goal: ∀ {α : Type u_1} {R : α → α → Prop} {a : α} {l : List α}, List.Pairwise R (a :: l) → List.Chain R a l
-- List.range'_succ
theorem range'_succ (s n step) : range' s (n + 1) step = s :: range' (s + step) n step 
Arguments: (s n step : Nat)
Goal: List.range' s (n + 1) step = s :: List.range' (s + step) n step
-- List.length_range'
@[simp] theorem length_range' (s step) : ∀ n : Nat, length (range' s n step) = n
  
Arguments: (s step n : Nat)
Goal: (List.range' s n step).length = n
-- List.range'_eq_nil
@[simp] theorem range'_eq_nil : range' s n step = [] ↔ n = 0 
Arguments: {s n step : Nat}
Goal: List.range' s n step = [] ↔ n = 0
-- List.mem_range'
theorem mem_range' : ∀{n}, m ∈ range' s n step ↔ ∃ i < n, m = s + step * i
  
Arguments: {m s step n : Nat}
Goal: m ∈ List.range' s n step ↔ ∃ i, i < n ∧ m = s + step * i
-- List.mem_range'_1
@[simp] theorem mem_range'_1 : m ∈ range' s n ↔ s ≤ m ∧ m < s + n 
Arguments: {m s n : Nat}
Goal: m ∈ List.range' s n ↔ s ≤ m ∧ m < s + n
-- List.map_add_range'
@[simp]
theorem map_add_range' (a) : ∀ s n step, map (a + ·) (range' s n step) = range' (a + s) n step
  
Arguments: (a s n step : Nat)
Goal: List.map (fun x => a + x) (List.range' s n step) = List.range' (a + s) n step
-- List.map_sub_range'
theorem map_sub_range' (a s n : Nat) (h : a ≤ s) :
    map (· - a) (range' s n step) = range' (s - a) n step 
Arguments: {step : Nat} (a s n : Nat) (h : a ≤ s)
Goal: List.map (fun x => x - a) (List.range' s n step) = List.range' (s - a) n step
-- List.chain_succ_range'
theorem chain_succ_range' : ∀ s n step : Nat,
    Chain (fun a b => b = a + step) s (range' (s + step) n step)
  
Arguments: (s n step : Nat)
Goal: List.Chain (fun a b => b = a + step) s (List.range' (s + step) n step)
-- List.chain_lt_range'
theorem chain_lt_range' (s n : Nat) {step} (h : 0 < step) :
    Chain (· < ·) s (range' (s + step) n step) 
Arguments: (s n : Nat) {step : Nat} (h : 0 < step)
Goal: List.Chain (fun x x_1 => x < x_1) s (List.range' (s + step) n step)
-- List.range'_append
theorem range'_append : ∀ s m n step : Nat,
    range' s m step ++ range' (s + step * m) n step = range' s (n + m) step
  
Arguments: (s m n step : Nat)
Goal: List.range' s m step ++ List.range' (s + step * m) n step = List.range' s (n + m) step
-- List.range'_append_1
@[simp] theorem range'_append_1 (s m n : Nat) :
    range' s m ++ range' (s + m) n = range' s (n + m) 
Arguments: (s m n : Nat)
Goal: List.range' s m ++ List.range' (s + m) n = List.range' s (n + m)
-- List.range'_sublist_right
theorem range'_sublist_right {s m n : Nat} : range' s m step <+ range' s n step ↔ m ≤ n 
Arguments: {step s m n : Nat}
Goal: List.range' s m step <+ List.range' s n step ↔ m ≤ n
-- List.range'_subset_right
theorem range'_subset_right {s m n : Nat} (step0 : 0 < step) :
    range' s m step ⊆ range' s n step ↔ m ≤ n 
Arguments: {step s m n : Nat} (step0 : 0 < step)
Goal: List.range' s m step ⊆ List.range' s n step ↔ m ≤ n
-- List.range'_subset_right_1
theorem range'_subset_right_1 {s m n : Nat} : range' s m ⊆ range' s n ↔ m ≤ n 
Arguments: {s m n : Nat}
Goal: List.range' s m ⊆ List.range' s n ↔ m ≤ n
-- List.getElem?_range'
theorem getElem?_range' (s step) :
    ∀ {m n : Nat}, m < n → (range' s n step)[m]? = some (s + step * m)
  
Arguments: (s step : Nat) {m n : Nat}
Goal: m < n → (List.range' s n step)[m]? = some (s + step * m)
-- List.getElem_range'
@[simp] theorem getElem_range' {n m step} (i) (H : i < (range' n m step).length) :
    (range' n m step)[i] = n + step * i 
Arguments: {n m step : Nat} (i : Nat) (H : i < (List.range' n m step).length)
Goal: (List.range' n m step)[i] = n + step * i
-- List.get?_range'
@[deprecated getElem?_range' (since := "2024-06-12")]
theorem get?_range' (s step) {m n : Nat} (h : m < n) :
    get? (range' s n step) m = some (s + step * m) 
Arguments: (s step : Nat) {m n : Nat} (h : m < n)
Goal: (List.range' s n step).get? m = some (s + step * m)
-- List.get_range'
@[deprecated getElem_range' (since := "2024-06-12")]
theorem get_range' {n m step} (i) (H : i < (range' n m step).length) :
    get (range' n m step) ⟨i, H⟩ = n + step * i 
Arguments: {n m step : Nat} (i : Nat) (H : i < (List.range' n m step).length)
Goal: (List.range' n m step).get ⟨i, H⟩ = n + step * i