ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- not_true_eq_false
@[simp] theorem not_true_eq_false : (¬ True) = False 
Goal: (¬True) = False
-- not_iff_self
@[simp] theorem not_iff_self : ¬(¬a ↔ a) 
Arguments: {a : Prop}
Goal: ¬(¬a ↔ a)
-- and_congr_right
theorem and_congr_right (h : a → (b ↔ c)) : a ∧ b ↔ a ∧ c 
Arguments: {a b c : Prop} (h : a → (b ↔ c))
Goal: a ∧ b ↔ a ∧ c
-- and_congr_left
theorem and_congr_left (h : c → (a ↔ b)) : a ∧ c ↔ b ∧ c 
Arguments: {c a b : Prop} (h : c → (a ↔ b))
Goal: a ∧ c ↔ b ∧ c
-- and_assoc
theorem and_assoc : (a ∧ b) ∧ c ↔ a ∧ (b ∧ c) 
Arguments: {a b c : Prop}
Goal: (a ∧ b) ∧ c ↔ a ∧ b ∧ c
-- and_self_left
@[simp] theorem and_self_left  : a ∧ (a ∧ b) ↔ a ∧ b 
Arguments: {a b : Prop}
Goal: a ∧ a ∧ b ↔ a ∧ b
-- and_self_right
@[simp] theorem and_self_right : (a ∧ b) ∧ b ↔ a ∧ b 
Arguments: {a b : Prop}
Goal: (a ∧ b) ∧ b ↔ a ∧ b
-- and_congr_right_iff
@[simp] theorem and_congr_right_iff : (a ∧ b ↔ a ∧ c) ↔ (a → (b ↔ c)) 
Arguments: {a b c : Prop}
Goal: (a ∧ b ↔ a ∧ c) ↔ a → (b ↔ c)
-- and_congr_left_iff
@[simp] theorem and_congr_left_iff : (a ∧ c ↔ b ∧ c) ↔ c → (a ↔ b) 
Arguments: {a c b : Prop}
Goal: (a ∧ c ↔ b ∧ c) ↔ c → (a ↔ b)
-- and_iff_left_of_imp
theorem and_iff_left_of_imp  (h : a → b) : (a ∧ b) ↔ a 
Arguments: {a b : Prop} (h : a → b)
Goal: a ∧ b ↔ a
-- and_iff_right_of_imp
theorem and_iff_right_of_imp (h : b → a) : (a ∧ b) ↔ b 
Arguments: {b a : Prop} (h : b → a)
Goal: a ∧ b ↔ b
-- and_iff_left_iff_imp
@[simp] theorem and_iff_left_iff_imp  : ((a ∧ b) ↔ a) ↔ (a → b) 
Arguments: {a b : Prop}
Goal: (a ∧ b ↔ a) ↔ a → b
-- and_iff_right_iff_imp
@[simp] theorem and_iff_right_iff_imp : ((a ∧ b) ↔ b) ↔ (b → a) 
Arguments: {a b : Prop}
Goal: (a ∧ b ↔ b) ↔ b → a
-- iff_self_and
@[simp] theorem iff_self_and : (p ↔ p ∧ q) ↔ (p → q) 
Arguments: {p q : Prop}
Goal: (p ↔ p ∧ q) ↔ p → q
-- iff_and_self
@[simp] theorem iff_and_self : (p ↔ q ∧ p) ↔ (p → q) 
Arguments: {p q : Prop}
Goal: (p ↔ q ∧ p) ↔ p → q
-- Or.imp
theorem Or.imp (f : a → c) (g : b → d) (h : a ∨ b) : c ∨ d 
Arguments: {a c b d : Prop} (f : a → c) (g : b → d) (h : a ∨ b)
Goal: c ∨ d
-- Or.imp_left
theorem Or.imp_left (f : a → b) : a ∨ c → b ∨ c 
Arguments: {a b c : Prop} (f : a → b)
Goal: a ∨ c → b ∨ c
-- Or.imp_right
theorem Or.imp_right (f : b → c) : a ∨ b → a ∨ c 
Arguments: {b c a : Prop} (f : b → c)
Goal: a ∨ b → a ∨ c
-- or_assoc
theorem or_assoc : (a ∨ b) ∨ c ↔ a ∨ (b ∨ c) 
Arguments: {a b c : Prop}
Goal: (a ∨ b) ∨ c ↔ a ∨ b ∨ c
-- or_self_left
@[simp] theorem or_self_left  : a ∨ (a ∨ b) ↔ a ∨ b 
Arguments: {a b : Prop}
Goal: a ∨ a ∨ b ↔ a ∨ b
-- or_self_right
@[simp] theorem or_self_right : (a ∨ b) ∨ b ↔ a ∨ b 
Arguments: {a b : Prop}
Goal: (a ∨ b) ∨ b ↔ a ∨ b
-- or_iff_right_of_imp
theorem or_iff_right_of_imp (ha : a → b) : (a ∨ b) ↔ b 
Arguments: {a b : Prop} (ha : a → b)
Goal: a ∨ b ↔ b
-- or_iff_left_of_imp
theorem or_iff_left_of_imp  (hb : b → a) : (a ∨ b) ↔ a  
Arguments: {b a : Prop} (hb : b → a)
Goal: a ∨ b ↔ a
-- or_iff_left_iff_imp
@[simp] theorem or_iff_left_iff_imp  : (a ∨ b ↔ a) ↔ (b → a) 
Arguments: {a b : Prop}
Goal: (a ∨ b ↔ a) ↔ b → a
-- or_iff_right_iff_imp
@[simp] theorem or_iff_right_iff_imp : (a ∨ b ↔ b) ↔ (a → b) 
Arguments: {a b : Prop}
Goal: (a ∨ b ↔ b) ↔ a → b
-- iff_self_or
@[simp] theorem iff_self_or (a b : Prop) : (a ↔ a ∨ b) ↔ (b → a) 
Arguments: (a b : Prop)
Goal: (a ↔ a ∨ b) ↔ b → a
-- iff_or_self
@[simp] theorem iff_or_self (a b : Prop) : (b ↔ a ∨ b) ↔ (a → b) 
Arguments: (a b : Prop)
Goal: (b ↔ a ∨ b) ↔ a → b
-- Bool.or_false
@[simp] theorem Bool.or_false (b : Bool) : (b || false) = b  
Arguments: (b : Bool)
Goal: (b || false) = b
-- Bool.or_true
@[simp] theorem Bool.or_true (b : Bool) : (b || true) = true 
Arguments: (b : Bool)
Goal: (b || true) = true
-- Bool.false_or
@[simp] theorem Bool.false_or (b : Bool) : (false || b) = b  
Arguments: (b : Bool)
Goal: (false || b) = b
-- Bool.true_or
@[simp] theorem Bool.true_or (b : Bool) : (true || b) = true 
Arguments: (b : Bool)
Goal: (true || b) = true
-- Bool.or_self
@[simp] theorem Bool.or_self (b : Bool) : (b || b) = b       
Arguments: (b : Bool)
Goal: (b || b) = b
-- Bool.or_eq_true
@[simp] theorem Bool.or_eq_true (a b : Bool) : ((a || b) = true) = (a = true ∨ b = true) 
Arguments: (a b : Bool)
Goal: ((a || b) = true) = (a = true ∨ b = true)
-- Bool.and_false
@[simp] theorem Bool.and_false (b : Bool) : (b && false) = false 
Arguments: (b : Bool)
Goal: (b && false) = false
-- Bool.and_true
@[simp] theorem Bool.and_true (b : Bool) : (b && true) = b       
Arguments: (b : Bool)
Goal: (b && true) = b
-- Bool.false_and
@[simp] theorem Bool.false_and (b : Bool) : (false && b) = false 
Arguments: (b : Bool)
Goal: (false && b) = false
-- Bool.true_and
@[simp] theorem Bool.true_and (b : Bool) : (true && b) = b       
Arguments: (b : Bool)
Goal: (true && b) = b
-- Bool.and_self
@[simp] theorem Bool.and_self (b : Bool) : (b && b) = b          
Arguments: (b : Bool)
Goal: (b && b) = b
-- Bool.and_eq_true
@[simp] theorem Bool.and_eq_true (a b : Bool) : ((a && b) = true) = (a = true ∧ b = true) 
Arguments: (a b : Bool)
Goal: ((a && b) = true) = (a = true ∧ b = true)
-- Bool.and_assoc
theorem Bool.and_assoc (a b c : Bool) : (a && b && c) = (a && (b && c)) 
Arguments: (a b c : Bool)
Goal: (a && b && c) = (a && (b && c))
-- Bool.or_assoc
theorem Bool.or_assoc (a b c : Bool) : (a || b || c) = (a || (b || c)) 
Arguments: (a b c : Bool)
Goal: (a || b || c) = (a || (b || c))
-- Bool.not_not
@[simp] theorem Bool.not_not (b : Bool) : (!!b) = b 
Arguments: (b : Bool)
Goal: (!!b) = b
-- Bool.not_true
@[simp] theorem Bool.not_true  : (!true) = false 
Goal: (!true) = false
-- Bool.not_false
@[simp] theorem Bool.not_false : (!false) = true 
Goal: (!false) = true
-- Bool.not_beq_true
@[simp] theorem Bool.not_beq_true  (b : Bool) : (!(b == true)) = (b == false) 
Arguments: (b : Bool)
Goal: (!b == true) = (b == false)
-- Bool.not_beq_false
@[simp] theorem Bool.not_beq_false (b : Bool) : (!(b == false)) = (b == true) 
Arguments: (b : Bool)
Goal: (!b == false) = (b == true)
-- Bool.not_eq_true'
@[simp] theorem Bool.not_eq_true'  (b : Bool) : ((!b) = true) = (b = false) 
Arguments: (b : Bool)
Goal: ((!b) = true) = (b = false)
-- Bool.not_eq_false'
@[simp] theorem Bool.not_eq_false' (b : Bool) : ((!b) = false) = (b = true) 
Arguments: (b : Bool)
Goal: ((!b) = false) = (b = true)
-- Bool.beq_to_eq
@[simp] theorem Bool.beq_to_eq (a b : Bool) :
  (a == b) = (a = b) 
Arguments: (a b : Bool)
Goal: ((a == b) = true) = (a = b)
-- Bool.not_beq_to_not_eq
@[simp] theorem Bool.not_beq_to_not_eq (a b : Bool) :
  (!(a == b)) = ¬(a = b) 
Arguments: (a b : Bool)
Goal: ((!a == b) = true) = ¬a = b
-- Bool.not_eq_true
@[simp] theorem Bool.not_eq_true (b : Bool) : (¬(b = true)) = (b = false) 
Arguments: (b : Bool)
Goal: (¬b = true) = (b = false)
-- Bool.not_eq_false
@[simp] theorem Bool.not_eq_false (b : Bool) : (¬(b = false)) = (b = true) 
Arguments: (b : Bool)
Goal: (¬b = false) = (b = true)
-- decide_eq_true_eq
@[simp] theorem decide_eq_true_eq [Decidable p] : (decide p = true) = p 
Arguments: {p : Prop} [Decidable p]
Goal: (decide p = true) = p
-- decide_not
@[simp] theorem decide_not [g : Decidable p] [h : Decidable (Not p)] : decide (Not p) = !(decide p) 
Arguments: {p : Prop} [g : Decidable p] [h : Decidable ¬p]
Goal: (decide ¬p) = !decide p
-- not_decide_eq_true
@[simp] theorem not_decide_eq_true [h : Decidable p] : ((!decide p) = true) = ¬ p 
Arguments: {p : Prop} [h : Decidable p]
Goal: ((!decide p) = true) = ¬p
-- heq_eq_eq
@[simp] theorem heq_eq_eq (a b : α) : HEq a b = (a = b) 
Arguments: {α : Sort u_1} (a b : α)
Goal: HEq a b = (a = b)
-- cond_true
@[simp] theorem cond_true (a b : α) : cond true a b = a 
Arguments: {α : Type u_1} (a b : α)
Goal: (bif true then a else b) = a
-- cond_false
@[simp] theorem cond_false (a b : α) : cond false a b = b 
Arguments: {α : Type u_1} (a b : α)
Goal: (bif false then a else b) = b
-- beq_self_eq_true
@[simp] theorem beq_self_eq_true [BEq α] [LawfulBEq α] (a : α) : (a == a) = true 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a : α)
Goal: (a == a) = true
-- beq_self_eq_true'
@[simp] theorem beq_self_eq_true' [DecidableEq α] (a : α) : (a == a) = true 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: (a == a) = true
-- bne_self_eq_false
@[simp] theorem bne_self_eq_false [BEq α] [LawfulBEq α] (a : α) : (a != a) = false 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a : α)
Goal: (a != a) = false
-- bne_self_eq_false'
@[simp] theorem bne_self_eq_false' [DecidableEq α] (a : α) : (a != a) = false 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: (a != a) = false
-- decide_False
@[simp] theorem decide_False : decide False = false 
Goal: decide False = false
-- decide_True
@[simp] theorem decide_True  : decide True  = true 
Goal: decide True = true
-- bne_iff_ne
@[simp] theorem bne_iff_ne [BEq α] [LawfulBEq α] (a b : α) : a != b ↔ a ≠ b 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a b : α)
Goal: (a != b) = true ↔ a ≠ b
-- beq_eq_false_iff_ne
@[simp] theorem beq_eq_false_iff_ne [BEq α] [LawfulBEq α]
    (a b : α) : (a == b) = false ↔ a ≠ b 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a b : α)
Goal: (a == b) = false ↔ a ≠ b
-- bne_eq_false_iff_eq
@[simp] theorem bne_eq_false_iff_eq [BEq α] [LawfulBEq α] (a b : α) :
    (a != b) = false ↔ a = b 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] (a b : α)
Goal: (a != b) = false ↔ a = b
-- Nat.le_zero_eq
@[simp] theorem Nat.le_zero_eq (a : Nat) : (a ≤ 0) = (a = 0) 
Arguments: (a : Nat)
Goal: (a ≤ 0) = (a = 0)
-- List.mem_toArray
@[simp] theorem mem_toArray {a : α} {l : List α} : a ∈ l.toArray ↔ a ∈ l 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: a ∈ List.toArray l ↔ a ∈ l
-- List.drop_one
@[simp]
theorem drop_one : ∀ l : List α, drop 1 l = tail l
  
Arguments: {α : Type u_1} (l : List α)
Goal: List.drop 1 l = l.tail
-- List.zipWith_distrib_tail
theorem zipWith_distrib_tail : (zipWith f l l').tail = zipWith f l.tail l'.tail 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : α → α_1 → α_2} {l : List α} {l' : List α_1},
  (List.zipWith f l l').tail = List.zipWith f l.tail l'.tail
-- List.subset_def
theorem subset_def {l₁ l₂ : List α} : l₁ ⊆ l₂ ↔ ∀ {a : α}, a ∈ l₁ → a ∈ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ ⊆ l₂ ↔ ∀ {a : α}, a ∈ l₁ → a ∈ l₂
-- List.nil_subset
@[simp] theorem nil_subset (l : List α) : [] ⊆ l 
Arguments: {α : Type u_1} (l : List α)
Goal: [] ⊆ l
-- List.Subset.refl
@[simp] theorem Subset.refl (l : List α) : l ⊆ l 
Arguments: {α : Type u_1} (l : List α)
Goal: l ⊆ l
-- List.Subset.trans
theorem Subset.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ ⊆ l₂) (h₂ : l₂ ⊆ l₃) : l₁ ⊆ l₃ 
Arguments: {α : Type u_1} {l₁ l₂ l₃ : List α} (h₁ : l₁ ⊆ l₂) (h₂ : l₂ ⊆ l₃)
Goal: l₁ ⊆ l₃
-- List.subset_cons
@[simp] theorem subset_cons (a : α) (l : List α) : l ⊆ a :: l 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: l ⊆ a :: l
-- List.subset_of_cons_subset
theorem subset_of_cons_subset {a : α} {l₁ l₂ : List α} : a :: l₁ ⊆ l₂ → l₁ ⊆ l₂ 
Arguments: {α : Type u_1} {a : α} {l₁ l₂ : List α}
Goal: a :: l₁ ⊆ l₂ → l₁ ⊆ l₂
-- List.subset_cons_of_subset
theorem subset_cons_of_subset (a : α) {l₁ l₂ : List α} : l₁ ⊆ l₂ → l₁ ⊆ a :: l₂ 
Arguments: {α : Type u_1} (a : α) {l₁ l₂ : List α}
Goal: l₁ ⊆ l₂ → l₁ ⊆ a :: l₂
-- List.cons_subset_cons
theorem cons_subset_cons {l₁ l₂ : List α} (a : α) (s : l₁ ⊆ l₂) : a :: l₁ ⊆ a :: l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (a : α) (s : l₁ ⊆ l₂)
Goal: a :: l₁ ⊆ a :: l₂
-- List.subset_append_left
@[simp] theorem subset_append_left (l₁ l₂ : List α) : l₁ ⊆ l₁ ++ l₂ 
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: l₁ ⊆ l₁ ++ l₂
-- List.subset_append_right
@[simp] theorem subset_append_right (l₁ l₂ : List α) : l₂ ⊆ l₁ ++ l₂ 
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: l₂ ⊆ l₁ ++ l₂
-- List.subset_append_of_subset_left
theorem subset_append_of_subset_left (l₂ : List α) : l ⊆ l₁ → l ⊆ l₁ ++ l₂ 
Arguments: {α : Type u_1} {l l₁ : List α} (l₂ : List α)
Goal: l ⊆ l₁ → l ⊆ l₁ ++ l₂
-- List.subset_append_of_subset_right
theorem subset_append_of_subset_right (l₁ : List α) : l ⊆ l₂ → l ⊆ l₁ ++ l₂ 
Arguments: {α : Type u_1} {l l₂ : List α} (l₁ : List α)
Goal: l ⊆ l₂ → l ⊆ l₁ ++ l₂
-- List.cons_subset
@[simp] theorem cons_subset : a :: l ⊆ m ↔ a ∈ m ∧ l ⊆ m 
Goal: ∀ {α : Type u_1} {a : α} {l m : List α}, a :: l ⊆ m ↔ a ∈ m ∧ l ⊆ m
-- List.append_subset
@[simp] theorem append_subset {l₁ l₂ l : List α} :
    l₁ ++ l₂ ⊆ l ↔ l₁ ⊆ l ∧ l₂ ⊆ l 
Arguments: {α : Type u_1} {l₁ l₂ l : List α}
Goal: l₁ ++ l₂ ⊆ l ↔ l₁ ⊆ l ∧ l₂ ⊆ l
-- List.subset_nil
theorem subset_nil {l : List α} : l ⊆ [] ↔ l = [] 
Arguments: {α : Type u_1} {l : List α}
Goal: l ⊆ [] ↔ l = []
-- List.map_subset
theorem map_subset {l₁ l₂ : List α} (f : α → β) (H : l₁ ⊆ l₂) : map f l₁ ⊆ map f l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α} (f : α → β) (H : l₁ ⊆ l₂)
Goal: List.map f l₁ ⊆ List.map f l₂
-- List.nil_sublist
@[simp] theorem nil_sublist : ∀ l : List α, [] <+ l
  
Arguments: {α : Type u_1} (l : List α)
Goal: [] <+ l
-- List.Sublist.refl
@[simp] theorem Sublist.refl : ∀ l : List α, l <+ l
  
Arguments: {α : Type u_1} (l : List α)
Goal: l <+ l
-- List.Sublist.trans
theorem Sublist.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ <+ l₂) (h₂ : l₂ <+ l₃) : l₁ <+ l₃ 
Arguments: {α : Type u_1} {l₁ l₂ l₃ : List α} (h₁ : l₁ <+ l₂) (h₂ : l₂ <+ l₃)
Goal: l₁ <+ l₃
-- List.sublist_cons
@[simp] theorem sublist_cons (a : α) (l : List α) : l <+ a :: l 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: l <+ a :: l
-- List.sublist_of_cons_sublist
theorem sublist_of_cons_sublist : a :: l₁ <+ l₂ → l₁ <+ l₂ 
Goal: ∀ {α : Type u_1} {a : α} {l₁ l₂ : List α}, a :: l₁ <+ l₂ → l₁ <+ l₂
-- List.sublist_append_left
@[simp] theorem sublist_append_left : ∀ l₁ l₂ : List α, l₁ <+ l₁ ++ l₂
  
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: l₁ <+ l₁ ++ l₂
-- List.sublist_append_right
@[simp] theorem sublist_append_right : ∀ l₁ l₂ : List α, l₂ <+ l₁ ++ l₂
  
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: l₂ <+ l₁ ++ l₂
-- List.sublist_append_of_sublist_left
theorem sublist_append_of_sublist_left (s : l <+ l₁) : l <+ l₁ ++ l₂ 
Goal: ∀ {α : Type u_1} {l l₁ l₂ : List α}, l <+ l₁ → l <+ l₁ ++ l₂
-- List.sublist_append_of_sublist_right
theorem sublist_append_of_sublist_right (s : l <+ l₂) : l <+ l₁ ++ l₂ 
Goal: ∀ {α : Type u_1} {l l₂ l₁ : List α}, l <+ l₂ → l <+ l₁ ++ l₂
-- List.cons_sublist_cons
@[simp]
theorem cons_sublist_cons : a :: l₁ <+ a :: l₂ ↔ l₁ <+ l₂ 
Goal: ∀ {α : Type u_1} {a : α} {l₁ l₂ : List α}, a :: l₁ <+ a :: l₂ ↔ l₁ <+ l₂
-- List.append_sublist_append_left
@[simp] theorem append_sublist_append_left : ∀ l, l ++ l₁ <+ l ++ l₂ ↔ l₁ <+ l₂
  
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α} (l : List α), l ++ l₁ <+ l ++ l₂ ↔ l₁ <+ l₂
-- List.Sublist.append_left
theorem Sublist.append_left : l₁ <+ l₂ → ∀ l, l ++ l₁ <+ l ++ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → ∀ (l : List α), l ++ l₁ <+ l ++ l₂
-- List.Sublist.append_right
theorem Sublist.append_right : l₁ <+ l₂ → ∀ l, l₁ ++ l <+ l₂ ++ l
  
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → ∀ (l : List α), l₁ ++ l <+ l₂ ++ l
-- List.sublist_or_mem_of_sublist
theorem sublist_or_mem_of_sublist (h : l <+ l₁ ++ a :: l₂) : l <+ l₁ ++ l₂ ∨ a ∈ l 
Goal: ∀ {α : Type u_1} {l l₁ : List α} {a : α} {l₂ : List α}, l <+ l₁ ++ a :: l₂ → l <+ l₁ ++ l₂ ∨ a ∈ l
-- List.Sublist.reverse
theorem Sublist.reverse : l₁ <+ l₂ → l₁.reverse <+ l₂.reverse
  
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → l₁.reverse <+ l₂.reverse
-- List.reverse_sublist
@[simp] theorem reverse_sublist : l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂
-- List.append_sublist_append_right
@[simp] theorem append_sublist_append_right (l) : l₁ ++ l <+ l₂ ++ l ↔ l₁ <+ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α} (l : List α), l₁ ++ l <+ l₂ ++ l ↔ l₁ <+ l₂
-- List.Sublist.append
theorem Sublist.append (hl : l₁ <+ l₂) (hr : r₁ <+ r₂) : l₁ ++ r₁ <+ l₂ ++ r₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ r₁ r₂ : List α}, l₁ <+ l₂ → r₁ <+ r₂ → l₁ ++ r₁ <+ l₂ ++ r₂
-- List.Sublist.subset
theorem Sublist.subset : l₁ <+ l₂ → l₁ ⊆ l₂
  
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → l₁ ⊆ l₂
-- List.Sublist.length_le
theorem Sublist.length_le : l₁ <+ l₂ → length l₁ ≤ length l₂
  
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → l₁.length ≤ l₂.length
-- List.sublist_nil
@[simp] theorem sublist_nil {l : List α} : l <+ [] ↔ l = [] 
Arguments: {α : Type u_1} {l : List α}
Goal: l <+ [] ↔ l = []
-- List.Sublist.eq_of_length
theorem Sublist.eq_of_length : l₁ <+ l₂ → length l₁ = length l₂ → l₁ = l₂
  
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → l₁.length = l₂.length → l₁ = l₂
-- List.Sublist.eq_of_length_le
theorem Sublist.eq_of_length_le (s : l₁ <+ l₂) (h : length l₂ ≤ length l₁) : l₁ = l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+ l₂ → l₂.length ≤ l₁.length → l₁ = l₂
-- List.singleton_sublist
@[simp] theorem singleton_sublist {a : α} {l} : [a] <+ l ↔ a ∈ l 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: [a] <+ l ↔ a ∈ l
-- List.replicate_sublist_replicate
@[simp] theorem replicate_sublist_replicate {m n} (a : α) :
    replicate m a <+ replicate n a ↔ m ≤ n 
Arguments: {α : Type u_1} {m n : Nat} (a : α)
Goal: List.replicate m a <+ List.replicate n a ↔ m ≤ n
-- List.isSublist_iff_sublist
theorem isSublist_iff_sublist [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
    l₁.isSublist l₂ ↔ l₁ <+ l₂ 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {l₁ l₂ : List α}
Goal: l₁.isSublist l₂ = true ↔ l₁ <+ l₂
-- List.tail_eq_tailD
theorem tail_eq_tailD (l) : @tail α l = tailD l [] 
Arguments: {α : Type u_1} (l : List α)
Goal: l.tail = l.tailD []
-- List.tail_eq_tail?
theorem tail_eq_tail? (l) : @tail α l = (tail? l).getD [] 
Arguments: {α : Type u_1} (l : List α)
Goal: l.tail = l.tail?.getD []
-- List.next?_nil
@[simp] theorem next?_nil : @next? α [] = none 
Arguments: {α : Type u_1}
Goal: [].next? = none
-- List.next?_cons
@[simp] theorem next?_cons (a l) : @next? α (a :: l) = some (a, l) 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: (a :: l).next? = some (a, l)
-- List.getElem_eq_iff
theorem getElem_eq_iff {l : List α} {n : Nat} {h : n < l.length} : l[n] = x ↔ l[n]? = some x 
Arguments: {α : Type u_1} {x : α} {l : List α} {n : Nat} {h : n < l.length}
Goal: l[n] = x ↔ l[n]? = some x
-- List.get_eq_iff
@[deprecated getElem_eq_iff (since := "2024-06-12")]
theorem get_eq_iff : List.get l n = x ↔ l.get? n.1 = some x 
Goal: ∀ {α : Type u_1} {l : List α} {n : Fin l.length} {x : α}, l.get n = x ↔ l.get? ↑n = some x
-- List.getElem?_inj
theorem getElem?_inj
    (h₀ : i < xs.length) (h₁ : Nodup xs) (h₂ : xs[i]? = xs[j]?) : i = j 
Arguments: {i : Nat}
Goal: ∀ {α : Type u_1} {xs : List α} {j : Nat}, i < xs.length → xs.Nodup → xs[i]? = xs[j]? → i = j
-- List.get?_inj
@[deprecated getElem?_inj (since := "2024-06-12")]
theorem get?_inj
    (h₀ : i < xs.length) (h₁ : Nodup xs) (h₂ : xs.get? i = xs.get? j) : i = j 
Arguments: {i : Nat}
Goal: ∀ {α : Type u_1} {xs : List α} {j : Nat}, i < xs.length → xs.Nodup → xs.get? i = xs.get? j → i = j
-- List.tail_drop
theorem tail_drop (l : List α) (n : Nat) : (l.drop n).tail = l.drop (n + 1) 
Arguments: {α : Type u_1} (l : List α) (n : Nat)
Goal: (List.drop n l).tail = List.drop (n + 1) l
-- List.modifyNth_nil
@[simp] theorem modifyNth_nil (f : α → α) (n) : [].modifyNth f n = [] 
Arguments: {α : Type u_1} (f : α → α) (n : Nat)
Goal: List.modifyNth f n [] = []
-- List.modifyNth_zero_cons
@[simp] theorem modifyNth_zero_cons (f : α → α) (a : α) (l : List α) :
    (a :: l).modifyNth f 0 = f a :: l 
Arguments: {α : Type u_1} (f : α → α) (a : α) (l : List α)
Goal: List.modifyNth f 0 (a :: l) = f a :: l
-- List.modifyNth_succ_cons
@[simp] theorem modifyNth_succ_cons (f : α → α) (a : α) (l : List α) (n) :
    (a :: l).modifyNth f (n + 1) = a :: l.modifyNth f n 
Arguments: {α : Type u_1} (f : α → α) (a : α) (l : List α) (n : Nat)
Goal: List.modifyNth f (n + 1) (a :: l) = a :: List.modifyNth f n l
-- List.modifyNthTail_id
theorem modifyNthTail_id : ∀ n (l : List α), l.modifyNthTail id n = l
  
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.modifyNthTail id n l = l
-- List.eraseIdx_eq_modifyNthTail
theorem eraseIdx_eq_modifyNthTail : ∀ n (l : List α), eraseIdx l n = modifyNthTail tail n l
  
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: l.eraseIdx n = List.modifyNthTail List.tail n l
-- List.getElem?_modifyNth
theorem getElem?_modifyNth (f : α → α) :
    ∀ n (l : List α) m, (modifyNth f n l)[m]? = (fun a => if n = m then f a else a) <$> l[m]?
  
Arguments: {α : Type u_1} (f : α → α) (n : Nat) (l : List α) (m : Nat)
Goal: (List.modifyNth f n l)[m]? = (fun a => if n = m then f a else a) <$> l[m]?
-- List.get?_modifyNth
@[deprecated getElem?_modifyNth (since := "2024-06-12")]
theorem get?_modifyNth (f : α → α) (n) (l : List α) (m) :
    (modifyNth f n l).get? m = (fun a => if n = m then f a else a) <$> l.get? m 
Arguments: {α : Type u_1} (f : α → α) (n : Nat) (l : List α) (m : Nat)
Goal: (List.modifyNth f n l).get? m = (fun a => if n = m then f a else a) <$> l.get? m
-- List.modifyNthTail_length
theorem modifyNthTail_length (f : List α → List α) (H : ∀ l, length (f l) = length l) :
    ∀ n l, length (modifyNthTail f n l) = length l
  
Arguments: {α : Type u_1} (f : List α → List α) (H : ∀ (l : List α), (f l).length = l.length) (n : Nat) (l : List α)
Goal: (List.modifyNthTail f n l).length = l.length
-- List.modifyNthTail_add
theorem modifyNthTail_add (f : List α → List α) (n) (l₁ l₂ : List α) :
    modifyNthTail f (l₁.length + n) (l₁ ++ l₂) = l₁ ++ modifyNthTail f n l₂ 
Arguments: {α : Type u_1} (f : List α → List α) (n : Nat) (l₁ l₂ : List α)
Goal: List.modifyNthTail f (l₁.length + n) (l₁ ++ l₂) = l₁ ++ List.modifyNthTail f n l₂
-- List.exists_of_modifyNthTail
theorem exists_of_modifyNthTail (f : List α → List α) {n} {l : List α} (h : n ≤ l.length) :
    ∃ l₁ l₂, l = l₁ ++ l₂ ∧ l₁.length = n ∧ modifyNthTail f n l = l₁ ++ f l₂ 
Arguments: {α : Type u_1} (f : List α → List α) {n : Nat} {l : List α} (h : n ≤ l.length)
Goal: ∃ l₁ l₂, l = l₁ ++ l₂ ∧ l₁.length = n ∧ List.modifyNthTail f n l = l₁ ++ f l₂
-- List.modify_get?_length
@[simp] theorem modify_get?_length (f : α → α) : ∀ n l, length (modifyNth f n l) = length l 
Arguments: {α : Type u_1} (f : α → α) (n : Nat) (l : List α)
Goal: (List.modifyNth f n l).length = l.length
-- List.getElem?_modifyNth_eq
@[simp] theorem getElem?_modifyNth_eq (f : α → α) (n) (l : List α) :
    (modifyNth f n l)[n]? = f <$> l[n]? 
Arguments: {α : Type u_1} (f : α → α) (n : Nat) (l : List α)
Goal: (List.modifyNth f n l)[n]? = f <$> l[n]?
-- List.get?_modifyNth_eq
@[deprecated getElem?_modifyNth_eq (since := "2024-06-12")]
theorem get?_modifyNth_eq (f : α → α) (n) (l : List α) :
    (modifyNth f n l).get? n = f <$> l.get? n 
Arguments: {α : Type u_1} (f : α → α) (n : Nat) (l : List α)
Goal: (List.modifyNth f n l).get? n = f <$> l.get? n
-- List.getElem?_modifyNth_ne
@[simp] theorem getElem?_modifyNth_ne (f : α → α) {m n} (l : List α) (h : m ≠ n) :
    (modifyNth f m l)[n]? = l[n]? 
Arguments: {α : Type u_1} (f : α → α) {m n : Nat} (l : List α) (h : m ≠ n)
Goal: (List.modifyNth f m l)[n]? = l[n]?
-- List.get?_modifyNth_ne
@[deprecated getElem?_modifyNth_ne (since := "2024-06-12")]
theorem get?_modifyNth_ne (f : α → α) {m n} (l : List α) (h : m ≠ n) :
    (modifyNth f m l).get? n = l.get? n 
Arguments: {α : Type u_1} (f : α → α) {m n : Nat} (l : List α) (h : m ≠ n)
Goal: (List.modifyNth f m l).get? n = l.get? n
-- List.exists_of_modifyNth
theorem exists_of_modifyNth (f : α → α) {n} {l : List α} (h : n < l.length) :
    ∃ l₁ a l₂, l = l₁ ++ a :: l₂ ∧ l₁.length = n ∧ modifyNth f n l = l₁ ++ f a :: l₂ 
Arguments: {α : Type u_1} (f : α → α) {n : Nat} {l : List α} (h : n < l.length)
Goal: ∃ l₁ a l₂, l = l₁ ++ a :: l₂ ∧ l₁.length = n ∧ List.modifyNth f n l = l₁ ++ f a :: l₂
-- List.modifyNthTail_eq_take_drop
theorem modifyNthTail_eq_take_drop (f : List α → List α) (H : f [] = []) :
    ∀ n l, modifyNthTail f n l = take n l ++ f (drop n l)
  
Arguments: {α : Type u_1} (f : List α → List α) (H : f [] = []) (n : Nat) (l : List α)
Goal: List.modifyNthTail f n l = List.take n l ++ f (List.drop n l)
-- List.modifyNth_eq_take_drop
theorem modifyNth_eq_take_drop (f : α → α) :
    ∀ n l, modifyNth f n l = take n l ++ modifyHead f (drop n l) 
Arguments: {α : Type u_1} (f : α → α) (n : Nat) (l : List α)
Goal: List.modifyNth f n l = List.take n l ++ List.modifyHead f (List.drop n l)