ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.range'_concat
theorem range'_concat (s n : Nat) : range' s (n + 1) step = range' s n step ++ [s + step * n] 
Arguments: {step : Nat} (s n : Nat)
Goal: List.range' s (n + 1) step = List.range' s n step ++ [s + step * n]
-- List.range'_1_concat
theorem range'_1_concat (s n : Nat) : range' s (n + 1) = range' s n ++ [s + n] 
Arguments: (s n : Nat)
Goal: List.range' s (n + 1) = List.range' s n ++ [s + n]
-- List.range_loop_range'
theorem range_loop_range' : ∀ s n : Nat, range.loop s (range' s n) = range' 0 (n + s)
  
Arguments: (s n : Nat)
Goal: List.range.loop s (List.range' s n) = List.range' 0 (n + s)
-- List.range_eq_range'
theorem range_eq_range' (n : Nat) : range n = range' 0 n 
Arguments: (n : Nat)
Goal: List.range n = List.range' 0 n
-- List.range_succ_eq_map
theorem range_succ_eq_map (n : Nat) : range (n + 1) = 0 :: map succ (range n) 
Arguments: (n : Nat)
Goal: List.range (n + 1) = 0 :: List.map Nat.succ (List.range n)
-- List.range'_eq_map_range
theorem range'_eq_map_range (s n : Nat) : range' s n = map (s + ·) (range n) 
Arguments: (s n : Nat)
Goal: List.range' s n = List.map (fun x => s + x) (List.range n)
-- List.length_range
@[simp] theorem length_range (n : Nat) : length (range n) = n 
Arguments: (n : Nat)
Goal: (List.range n).length = n
-- List.range_eq_nil
@[simp] theorem range_eq_nil {n : Nat} : range n = [] ↔ n = 0 
Arguments: {n : Nat}
Goal: List.range n = [] ↔ n = 0
-- List.range_sublist
@[simp]
theorem range_sublist {m n : Nat} : range m <+ range n ↔ m ≤ n 
Arguments: {m n : Nat}
Goal: List.range m <+ List.range n ↔ m ≤ n
-- List.range_subset
@[simp]
theorem range_subset {m n : Nat} : range m ⊆ range n ↔ m ≤ n 
Arguments: {m n : Nat}
Goal: List.range m ⊆ List.range n ↔ m ≤ n
-- List.mem_range
@[simp]
theorem mem_range {m n : Nat} : m ∈ range n ↔ m < n 
Arguments: {m n : Nat}
Goal: m ∈ List.range n ↔ m < n
-- List.not_mem_range_self
theorem not_mem_range_self {n : Nat} : n ∉ range n 
Arguments: {n : Nat}
Goal: ¬n ∈ List.range n
-- List.self_mem_range_succ
theorem self_mem_range_succ (n : Nat) : n ∈ range (n + 1) 
Arguments: (n : Nat)
Goal: n ∈ List.range (n + 1)
-- List.getElem?_range
theorem getElem?_range {m n : Nat} (h : m < n) : (range n)[m]? = some m 
Arguments: {m n : Nat} (h : m < n)
Goal: (List.range n)[m]? = some m
-- List.getElem_range
@[simp] theorem getElem_range {n : Nat} (m) (h : m < (range n).length) : (range n)[m] = m 
Arguments: {n : Nat} (m : Nat) (h : m < (List.range n).length)
Goal: (List.range n)[m] = m
-- List.get?_range
@[deprecated getElem?_range (since := "2024-06-12")]
theorem get?_range {m n : Nat} (h : m < n) : get? (range n) m = some m 
Arguments: {m n : Nat} (h : m < n)
Goal: (List.range n).get? m = some m
-- List.get_range
@[deprecated getElem_range (since := "2024-06-12")]
theorem get_range {n} (i) (H : i < (range n).length) : get (range n) ⟨i, H⟩ = i 
Arguments: {n : Nat} (i : Nat) (H : i < (List.range n).length)
Goal: (List.range n).get ⟨i, H⟩ = i
-- List.range_succ
theorem range_succ (n : Nat) : range (succ n) = range n ++ [n] 
Arguments: (n : Nat)
Goal: List.range n.succ = List.range n ++ [n]
-- List.range_add
theorem range_add (a b : Nat) : range (a + b) = range a ++ (range b).map (a + ·) 
Arguments: (a b : Nat)
Goal: List.range (a + b) = List.range a ++ List.map (fun x => a + x) (List.range b)
-- List.iota_eq_reverse_range'
theorem iota_eq_reverse_range' : ∀ n : Nat, iota n = reverse (range' 1 n)
  
Arguments: (n : Nat)
Goal: List.iota n = (List.range' 1 n).reverse
-- List.length_iota
@[simp] theorem length_iota (n : Nat) : length (iota n) = n 
Arguments: (n : Nat)
Goal: (List.iota n).length = n
-- List.mem_iota
@[simp]
theorem mem_iota {m n : Nat} : m ∈ iota n ↔ 1 ≤ m ∧ m ≤ n 
Arguments: {m n : Nat}
Goal: m ∈ List.iota n ↔ 1 ≤ m ∧ m ≤ n
-- List.reverse_range'
theorem reverse_range' : ∀ s n : Nat, reverse (range' s n) = map (s + n - 1 - ·) (range n)
  
Arguments: (s n : Nat)
Goal: (List.range' s n).reverse = List.map (fun x => s + n - 1 - x) (List.range n)
-- List.enumFrom_map_fst
@[simp] theorem enumFrom_map_fst (n) :
    ∀ (l : List α), map Prod.fst (enumFrom n l) = range' n l.length
  
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: List.map Prod.fst (List.enumFrom n l) = List.range' n l.length
-- List.enum_map_fst
@[simp] theorem enum_map_fst (l : List α) : map Prod.fst (enum l) = range l.length 
Arguments: {α : Type u_1} (l : List α)
Goal: List.map Prod.fst l.enum = List.range l.length
-- List.foldrIdx_start
theorem foldrIdx_start :
    (xs : List α).foldrIdx f i s = (xs : List α).foldrIdx (fun i => f (i + s)) i 
Arguments: {α : Type u_1} {xs : List α}
Goal: ∀ {α_1 : Sort u_2} {f : Nat → α → α_1 → α_1} {i : α_1} {s : Nat},
  List.foldrIdx f i xs s = List.foldrIdx (fun i => f (i + s)) i xs
-- List.foldrIdx_cons
@[simp] theorem foldrIdx_cons :
    (x :: xs : List α).foldrIdx f i s = f s x (foldrIdx f i xs (s + 1)) 
Arguments: {α : Type u_1} {x : α} {xs : List α}
Goal: ∀ {α_1 : Sort u_2} {f : Nat → α → α_1 → α_1} {i : α_1} {s : Nat},
  List.foldrIdx f i (x :: xs) s = f s x (List.foldrIdx f i xs (s + 1))
-- List.findIdxs_cons_aux
theorem findIdxs_cons_aux (p : α → Bool) :
    foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs s =
      map (· + 1) (foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs s) 
Arguments: {α : Type u_1} {xs : List α} {s : Nat} (p : α → Bool)
Goal: List.foldrIdx (fun i a is => if p a = true then (i + 1) :: is else is) [] xs s =
  List.map (fun x => x + 1) (List.foldrIdx (fun i a is => if p a = true then i :: is else is) [] xs s)
-- List.findIdxs_cons
theorem findIdxs_cons :
    (x :: xs : List α).findIdxs p =
      bif p x then 0 :: (xs.findIdxs p).map (· + 1) else (xs.findIdxs p).map (· + 1) 
Arguments: {α : Type u_1} {x : α} {xs : List α} {p : α → Bool}
Goal: List.findIdxs p (x :: xs) =
  bif p x then 0 :: List.map (fun x => x + 1) (List.findIdxs p xs) else List.map (fun x => x + 1) (List.findIdxs p xs)
-- List.indexesOf_nil
@[simp] theorem indexesOf_nil [BEq α] : ([] : List α).indexesOf x = [] 
Arguments: {α : Type u_1} {x : α} [BEq α]
Goal: List.indexesOf x [] = []
-- List.indexesOf_cons
theorem indexesOf_cons [BEq α] : (x :: xs : List α).indexesOf y =
    bif x == y then 0 :: (xs.indexesOf y).map (· + 1) else (xs.indexesOf y).map (· + 1) 
Arguments: {α : Type u_1} {x : α} {xs : List α} {y : α} [BEq α]
Goal: List.indexesOf y (x :: xs) =
  bif x == y then 0 :: List.map (fun x => x + 1) (List.indexesOf y xs)
  else List.map (fun x => x + 1) (List.indexesOf y xs)
-- List.indexOf_nil
@[simp] theorem indexOf_nil [BEq α] : ([] : List α).indexOf x = 0 
Arguments: {α : Type u_1} {x : α} [BEq α]
Goal: List.indexOf x [] = 0
-- List.indexOf_cons
theorem indexOf_cons [BEq α] :
    (x :: xs : List α).indexOf y = bif x == y then 0 else xs.indexOf y + 1 
Arguments: {α : Type u_1} {x : α} {xs : List α} {y : α} [BEq α]
Goal: List.indexOf y (x :: xs) = bif x == y then 0 else List.indexOf y xs + 1
-- List.indexOf_mem_indexesOf
theorem indexOf_mem_indexesOf [BEq α] [LawfulBEq α] {xs : List α} (m : x ∈ xs) :
    xs.indexOf x ∈ xs.indexesOf x 
Arguments: {α : Type u_1} {x : α} [BEq α] [LawfulBEq α] {xs : List α} (m : x ∈ xs)
Goal: List.indexOf x xs ∈ List.indexesOf x xs
-- List.merge_loop_nil_left
theorem merge_loop_nil_left (s : α → α → Bool) (r t) :
    merge.loop s [] r t = reverseAux t r 
Arguments: {α : Type u_1} (s : α → α → Bool) (r t : List α)
Goal: List.merge.loop s [] r t = t.reverseAux r
-- List.merge_loop_nil_right
theorem merge_loop_nil_right (s : α → α → Bool) (l t) :
    merge.loop s l [] t = reverseAux t l 
Arguments: {α : Type u_1} (s : α → α → Bool) (l t : List α)
Goal: List.merge.loop s l [] t = t.reverseAux l
-- List.merge_loop
theorem merge_loop (s : α → α → Bool) (l r t) :
    merge.loop s l r t = reverseAux t (merge s l r) 
Arguments: {α : Type u_1} (s : α → α → Bool) (l r t : List α)
Goal: List.merge.loop s l r t = t.reverseAux (List.merge s l r)
-- List.merge_nil
@[simp] theorem merge_nil (s : α → α → Bool) (l) : merge s l [] = l 
Arguments: {α : Type u_1} (s : α → α → Bool) (l : List α)
Goal: List.merge s l [] = l
-- List.nil_merge
@[simp] theorem nil_merge (s : α → α → Bool) (r) : merge s [] r = r 
Arguments: {α : Type u_1} (s : α → α → Bool) (r : List α)
Goal: List.merge s [] r = r
-- List.cons_merge_cons
theorem cons_merge_cons (s : α → α → Bool) (a b l r) :
  merge s (a::l) (b::r) = if s a b then a :: merge s l (b::r) else b :: merge s (a::l) r 
Arguments: {α : Type u_1} (s : α → α → Bool) (a b : α) (l r : List α)
Goal: List.merge s (a :: l) (b :: r) = if s a b = true then a :: List.merge s l (b :: r) else b :: List.merge s (a :: l) r
-- List.cons_merge_cons_pos
@[simp] theorem cons_merge_cons_pos (s : α → α → Bool) (l r) (h : s a b) :
    merge s (a::l) (b::r) = a :: merge s l (b::r) 
Arguments: {α : Type u_1} {a b : α} (s : α → α → Bool) (l r : List α) (h : s a b = true)
Goal: List.merge s (a :: l) (b :: r) = a :: List.merge s l (b :: r)
-- List.cons_merge_cons_neg
@[simp] theorem cons_merge_cons_neg (s : α → α → Bool) (l r) (h : ¬ s a b) :
    merge s (a::l) (b::r) = b :: merge s (a::l) r 
Arguments: {α : Type u_1} {a b : α} (s : α → α → Bool) (l r : List α) (h : ¬s a b = true)
Goal: List.merge s (a :: l) (b :: r) = b :: List.merge s (a :: l) r
-- List.length_merge
@[simp] theorem length_merge (s : α → α → Bool) (l r) :
    (merge s l r).length = l.length + r.length 
Arguments: {α : Type u_1} (s : α → α → Bool) (l r : List α)
Goal: (List.merge s l r).length = l.length + r.length
-- List.mem_merge
@[simp]
theorem mem_merge {s : α → α → Bool} : x ∈ merge s l r ↔ x ∈ l ∨ x ∈ r 
Arguments: {α : Type u_1} {x : α} {l r : List α} {s : α → α → Bool}
Goal: x ∈ List.merge s l r ↔ x ∈ l ∨ x ∈ r
-- List.mem_merge_left
theorem mem_merge_left (s : α → α → Bool) (h : x ∈ l) : x ∈ merge s l r 
Arguments: {α : Type u_1} {x : α} {l r : List α} (s : α → α → Bool) (h : x ∈ l)
Goal: x ∈ List.merge s l r
-- List.mem_merge_right
theorem mem_merge_right (s : α → α → Bool) (h : x ∈ r) : x ∈ merge s l r 
Arguments: {α : Type u_1} {x : α} {r l : List α} (s : α → α → Bool) (h : x ∈ r)
Goal: x ∈ List.merge s l r
-- _private.«.lake».packages.lean4.src.lean.Init.System.Promise.0.IO.PromiseImpl.h
private structure PromiseImpl (α : Type) : Type where
  prom : PromisePointed.type
  h    : Nonempty α
Arguments: {α : Type} (self : IO.PromiseImpl α)
Goal: Nonempty α
-- Lean.Omega.IntList.get_nil
@[simp] theorem get_nil : get ([] : IntList) i = 0 
Arguments: {i : Nat}
Goal: Lean.Omega.IntList.get [] i = 0
-- Lean.Omega.IntList.get_cons_zero
@[simp] theorem get_cons_zero : get (x :: xs) 0 = x 
Arguments: {x : Int} {xs : List Int}
Goal: Lean.Omega.IntList.get (x :: xs) 0 = x
-- Lean.Omega.IntList.get_cons_succ
@[simp] theorem get_cons_succ : get (x :: xs) (i+1) = get xs i 
Arguments: {x : Int} {xs : List Int} {i : Nat}
Goal: Lean.Omega.IntList.get (x :: xs) (i + 1) = Lean.Omega.IntList.get xs i
-- Lean.Omega.IntList.get_map
theorem get_map {xs : IntList} (h : f 0 = 0) : get (xs.map f) i = f (xs.get i) 
Arguments: {f : Int → Int} {i : Nat} {xs : Lean.Omega.IntList} (h : f 0 = 0)
Goal: Lean.Omega.IntList.get (List.map f xs) i = f (xs.get i)
-- Lean.Omega.IntList.get_of_length_le
theorem get_of_length_le {xs : IntList} (h : xs.length ≤ i) : xs.get i = 0 
Arguments: {i : Nat} {xs : Lean.Omega.IntList} (h : List.length xs ≤ i)
Goal: xs.get i = 0
-- Lean.Omega.IntList.set_nil_zero
@[simp] theorem set_nil_zero : set [] 0 y = [y] 
Arguments: {y : Int}
Goal: Lean.Omega.IntList.set [] 0 y = [y]
-- Lean.Omega.IntList.set_nil_succ
@[simp] theorem set_nil_succ : set [] (i+1) y = 0 :: set [] i y 
Arguments: {i : Nat} {y : Int}
Goal: Lean.Omega.IntList.set [] (i + 1) y = 0 :: Lean.Omega.IntList.set [] i y
-- Lean.Omega.IntList.set_cons_zero
@[simp] theorem set_cons_zero : set (x :: xs) 0 y = y :: xs 
Arguments: {x : Int} {xs : List Int} {y : Int}
Goal: Lean.Omega.IntList.set (x :: xs) 0 y = y :: xs
-- Lean.Omega.IntList.set_cons_succ
@[simp] theorem set_cons_succ : set (x :: xs) (i+1) y = x :: set xs i y 
Arguments: {x : Int} {xs : List Int} {i : Nat} {y : Int}
Goal: Lean.Omega.IntList.set (x :: xs) (i + 1) y = x :: Lean.Omega.IntList.set xs i y
-- Lean.Omega.IntList.add_def
theorem add_def (xs ys : IntList) :
    xs + ys = List.zipWithAll (fun x y => x.getD 0 + y.getD 0) xs ys 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: xs + ys = List.zipWithAll (fun x y => x.getD 0 + y.getD 0) xs ys
-- Lean.Omega.IntList.add_get
@[simp] theorem add_get (xs ys : IntList) (i : Nat) : (xs + ys).get i = xs.get i + ys.get i 
Arguments: (xs ys : Lean.Omega.IntList) (i : Nat)
Goal: (xs + ys).get i = xs.get i + ys.get i
-- Lean.Omega.IntList.add_nil
@[simp] theorem add_nil (xs : IntList) : xs + [] = xs 
Arguments: (xs : Lean.Omega.IntList)
Goal: xs + [] = xs
-- Lean.Omega.IntList.nil_add
@[simp] theorem nil_add (xs : IntList) : [] + xs = xs 
Arguments: (xs : Lean.Omega.IntList)
Goal: [] + xs = xs
-- Lean.Omega.IntList.cons_add_cons
@[simp] theorem cons_add_cons (x) (xs : IntList) (y) (ys : IntList) :
    (x :: xs) + (y :: ys) = (x + y) :: (xs + ys) 
Arguments: (x : Int) (xs : Lean.Omega.IntList) (y : Int) (ys : Lean.Omega.IntList)
Goal: x :: xs + y :: ys = (x + y) :: (xs + ys)
-- Lean.Omega.IntList.mul_def
theorem mul_def (xs ys : IntList) : xs * ys = List.zipWith (· * ·) xs ys 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: xs * ys = List.zipWith (fun x x_1 => x * x_1) xs ys
-- Lean.Omega.IntList.mul_get
@[simp] theorem mul_get (xs ys : IntList) (i : Nat) : (xs * ys).get i = xs.get i * ys.get i 
Arguments: (xs ys : Lean.Omega.IntList) (i : Nat)
Goal: (xs * ys).get i = xs.get i * ys.get i
-- Lean.Omega.IntList.mul_nil_left
@[simp] theorem mul_nil_left : ([] : IntList) * ys = [] 
Arguments: {ys : List Int}
Goal: [] * ys = []
-- Lean.Omega.IntList.mul_nil_right
@[simp] theorem mul_nil_right : xs * ([] : IntList) = [] 
Arguments: {xs : List Int}
Goal: xs * [] = []
-- Lean.Omega.IntList.mul_cons₂
@[simp] theorem mul_cons₂ : (x::xs : IntList) * (y::ys) = (x * y) :: (xs * ys) 
Arguments: {x : Int} {xs : List Int} {y : Int} {ys : List Int}
Goal: (x :: xs) * (y :: ys) = x * y :: xs * ys
-- Lean.Omega.IntList.neg_def
theorem neg_def (xs : IntList) : - xs = xs.map fun x => -x 
Arguments: (xs : Lean.Omega.IntList)
Goal: -xs = List.map (fun x => -x) xs
-- Lean.Omega.IntList.neg_get
@[simp] theorem neg_get (xs : IntList) (i : Nat) : (- xs).get i = - xs.get i 
Arguments: (xs : Lean.Omega.IntList) (i : Nat)
Goal: (-xs).get i = -xs.get i
-- Lean.Omega.IntList.neg_nil
@[simp] theorem neg_nil : (- ([] : IntList)) = [] 
Goal: -[] = []
-- Lean.Omega.IntList.neg_cons
@[simp] theorem neg_cons : (- (x::xs : IntList)) = -x :: -xs 
Arguments: {x : Int} {xs : List Int}
Goal: -(x :: xs) = -x :: -xs
-- Lean.Omega.IntList.sub_def
theorem sub_def (xs ys : IntList) :
    xs - ys = List.zipWithAll (fun x y => x.getD 0 - y.getD 0) xs ys 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: xs - ys = List.zipWithAll (fun x y => x.getD 0 - y.getD 0) xs ys
-- Lean.Omega.IntList.smul_def
theorem smul_def (xs : IntList) (i : Int) : i * xs = xs.map fun x => i * x 
Arguments: (xs : Lean.Omega.IntList) (i : Int)
Goal: i * xs = List.map (fun x => i * x) xs
-- Lean.Omega.IntList.smul_get
@[simp] theorem smul_get (xs : IntList) (a : Int) (i : Nat) : (a * xs).get i = a * xs.get i 
Arguments: (xs : Lean.Omega.IntList) (a : Int) (i : Nat)
Goal: (a * xs).get i = a * xs.get i
-- Lean.Omega.IntList.smul_nil
@[simp] theorem smul_nil {i : Int} : i * ([] : IntList) = [] 
Arguments: {i : Int}
Goal: i * [] = []
-- Lean.Omega.IntList.smul_cons
@[simp] theorem smul_cons {i : Int} : i * (x::xs : IntList) = i * x :: i * xs 
Arguments: {x : Int} {xs : List Int} {i : Int}
Goal: i * (x :: xs) = i * x :: i * xs
-- Lean.Omega.IntList.combo_eq_smul_add_smul
theorem combo_eq_smul_add_smul (a : Int) (xs : IntList) (b : Int) (ys : IntList) :
    combo a xs b ys = a * xs + b * ys 
Arguments: (a : Int) (xs : Lean.Omega.IntList) (b : Int) (ys : Lean.Omega.IntList)
Goal: Lean.Omega.IntList.combo a xs b ys = a * xs + b * ys
-- Lean.Omega.IntList.mul_distrib_left
theorem mul_distrib_left (xs ys zs : IntList) : (xs + ys) * zs = xs * zs + ys * zs 
Arguments: (xs ys zs : Lean.Omega.IntList)
Goal: (xs + ys) * zs = xs * zs + ys * zs
-- Lean.Omega.IntList.mul_neg_left
theorem mul_neg_left (xs ys : IntList) : (-xs) * ys = -(xs * ys) 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: -xs * ys = -(xs * ys)
-- Lean.Omega.IntList.sub_eq_add_neg
theorem sub_eq_add_neg (xs ys : IntList) : xs - ys = xs + (-ys) 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: xs - ys = xs + -ys
-- Lean.Omega.IntList.mul_smul_left
@[simp] theorem mul_smul_left {i : Int} {xs ys : IntList} : (i * xs) * ys = i * (xs * ys) 
Arguments: {i : Int} {xs ys : Lean.Omega.IntList}
Goal: i * xs * ys = i * (xs * ys)
-- Lean.Omega.IntList.sum_nil
@[simp] theorem sum_nil : sum ([] : IntList) = 0 
Goal: Lean.Omega.IntList.sum [] = 0
-- Lean.Omega.IntList.sum_cons
@[simp] theorem sum_cons : sum (x::xs : IntList) = x + sum xs 
Arguments: {x : Int} {xs : List Int}
Goal: Lean.Omega.IntList.sum (x :: xs) = x + Lean.Omega.IntList.sum xs
-- Lean.Omega.IntList.sum_add
theorem sum_add (xs ys : IntList) : (xs + ys).sum = xs.sum + ys.sum 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: (xs + ys).sum = xs.sum + ys.sum
-- Lean.Omega.IntList.sum_neg
@[simp]
theorem sum_neg (xs : IntList) : (-xs).sum = -(xs.sum) 
Arguments: (xs : Lean.Omega.IntList)
Goal: (-xs).sum = -xs.sum
-- Lean.Omega.IntList.sum_smul
@[simp]
theorem sum_smul (i : Int) (xs : IntList) : (i * xs).sum = i * (xs.sum) 
Arguments: (i : Int) (xs : Lean.Omega.IntList)
Goal: (i * xs).sum = i * xs.sum
-- Lean.Omega.IntList.dot_nil_left
@[local simp] theorem dot_nil_left : dot ([] : IntList) ys = 0 
Arguments: {ys : Lean.Omega.IntList}
Goal: Lean.Omega.IntList.dot [] ys = 0
-- Lean.Omega.IntList.dot_nil_right
@[simp] theorem dot_nil_right : dot xs ([] : IntList) = 0 
Arguments: {xs : Lean.Omega.IntList}
Goal: xs.dot [] = 0
-- Lean.Omega.IntList.dot_cons₂
@[simp] theorem dot_cons₂ : dot (x::xs) (y::ys) = x * y + dot xs ys 
Arguments: {x : Int} {xs : List Int} {y : Int} {ys : List Int}
Goal: Lean.Omega.IntList.dot (x :: xs) (y :: ys) = x * y + Lean.Omega.IntList.dot xs ys
-- Lean.Omega.IntList.dot_set_left
@[simp] theorem dot_set_left (xs ys : IntList) (i : Nat) (z : Int) :
    dot (xs.set i z) ys = dot xs ys + (z - xs.get i) * ys.get i 
Arguments: (xs ys : Lean.Omega.IntList) (i : Nat) (z : Int)
Goal: (xs.set i z).dot ys = xs.dot ys + (z - xs.get i) * ys.get i
-- Lean.Omega.IntList.dot_distrib_left
theorem dot_distrib_left (xs ys zs : IntList) : (xs + ys).dot zs = xs.dot zs + ys.dot zs 
Arguments: (xs ys zs : Lean.Omega.IntList)
Goal: (xs + ys).dot zs = xs.dot zs + ys.dot zs
-- Lean.Omega.IntList.dot_neg_left
@[simp] theorem dot_neg_left (xs ys : IntList) : (-xs).dot ys = -(xs.dot ys) 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: (-xs).dot ys = -xs.dot ys
-- Lean.Omega.IntList.dot_smul_left
@[simp] theorem dot_smul_left (xs ys : IntList) (i : Int) : (i * xs).dot ys = i * xs.dot ys 
Arguments: (xs ys : Lean.Omega.IntList) (i : Int)
Goal: (i * xs).dot ys = i * xs.dot ys
-- Lean.Omega.IntList.dot_of_left_zero
theorem dot_of_left_zero (w : ∀ x, x ∈ xs → x = 0) : dot xs ys = 0 
Arguments: {xs ys : Lean.Omega.IntList} (w : ∀ (x : Int), x ∈ xs → x = 0)
Goal: xs.dot ys = 0
-- Lean.Omega.IntList.sdiv_nil
@[simp] theorem sdiv_nil : sdiv [] g = [] 
Arguments: {g : Int}
Goal: Lean.Omega.IntList.sdiv [] g = []
-- Lean.Omega.IntList.sdiv_cons
@[simp] theorem sdiv_cons : sdiv (x::xs) g = (x / g) :: sdiv xs g 
Arguments: {x : Int} {xs : List Int} {g : Int}
Goal: Lean.Omega.IntList.sdiv (x :: xs) g = x / g :: Lean.Omega.IntList.sdiv xs g
-- Lean.Omega.IntList.gcd_nil
@[simp] theorem gcd_nil : gcd [] = 0 
Goal: Lean.Omega.IntList.gcd [] = 0
-- Lean.Omega.IntList.gcd_cons
@[simp] theorem gcd_cons : gcd (x :: xs) = Nat.gcd x.natAbs (gcd xs) 
Arguments: {x : Int} {xs : List Int}
Goal: Lean.Omega.IntList.gcd (x :: xs) = x.natAbs.gcd (Lean.Omega.IntList.gcd xs)
-- Lean.Omega.IntList.gcd_cons_div_left
theorem gcd_cons_div_left : (gcd (x::xs) : Int) ∣ x 
Arguments: {x : Int} {xs : List Int}
Goal: ↑(Lean.Omega.IntList.gcd (x :: xs)) ∣ x
-- Lean.Omega.IntList.gcd_cons_div_right
theorem gcd_cons_div_right : gcd (x::xs) ∣ gcd xs 
Arguments: {x : Int} {xs : List Int}
Goal: Lean.Omega.IntList.gcd (x :: xs) ∣ Lean.Omega.IntList.gcd xs
-- Lean.Omega.IntList.gcd_cons_div_right'
theorem gcd_cons_div_right' : (gcd (x::xs) : Int) ∣ (gcd xs : Int) 
Arguments: {x : Int} {xs : List Int}
Goal: ↑(Lean.Omega.IntList.gcd (x :: xs)) ∣ ↑(Lean.Omega.IntList.gcd xs)
-- Lean.Omega.IntList.gcd_dvd
theorem gcd_dvd (xs : IntList) {a : Int} (m : a ∈ xs) : (xs.gcd : Int) ∣ a 
Arguments: (xs : Lean.Omega.IntList) {a : Int} (m : a ∈ xs)
Goal: ↑xs.gcd ∣ a
-- Lean.Omega.IntList.dvd_gcd
theorem dvd_gcd (xs : IntList) (c : Nat) (w : ∀ {a : Int}, a ∈ xs → (c : Int) ∣ a) :
    c ∣ xs.gcd 
Arguments: (xs : Lean.Omega.IntList) (c : Nat) (w : ∀ {a : Int}, a ∈ xs → ↑c ∣ a)
Goal: c ∣ xs.gcd
-- Lean.Omega.IntList.gcd_eq_iff
theorem gcd_eq_iff (xs : IntList) (g : Nat) :
    xs.gcd = g ↔
      (∀ {a : Int}, a ∈ xs → (g : Int) ∣ a) ∧
        (∀ (c : Nat), (∀ {a : Int}, a ∈ xs → (c : Int) ∣ a) → c ∣ g) 
Arguments: (xs : Lean.Omega.IntList) (g : Nat)
Goal: xs.gcd = g ↔ (∀ {a : Int}, a ∈ xs → ↑g ∣ a) ∧ ∀ (c : Nat), (∀ {a : Int}, a ∈ xs → ↑c ∣ a) → c ∣ g
-- Lean.Omega.IntList.gcd_eq_zero
@[simp] theorem gcd_eq_zero (xs : IntList) : xs.gcd = 0 ↔ ∀ x, x ∈ xs → x = 0 
Arguments: (xs : Lean.Omega.IntList)
Goal: xs.gcd = 0 ↔ ∀ (x : Int), x ∈ xs → x = 0
-- Lean.Omega.IntList.dot_mod_gcd_left
@[simp] theorem dot_mod_gcd_left (xs ys : IntList) : dot xs ys % xs.gcd = 0 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: xs.dot ys % ↑xs.gcd = 0
-- Lean.Omega.IntList.gcd_dvd_dot_left
theorem gcd_dvd_dot_left (xs ys : IntList) : (xs.gcd : Int) ∣ dot xs ys 
Arguments: (xs ys : Lean.Omega.IntList)
Goal: ↑xs.gcd ∣ xs.dot ys
-- Lean.Omega.IntList.dot_eq_zero_of_left_eq_zero
@[simp]
theorem dot_eq_zero_of_left_eq_zero {xs ys : IntList} (h : ∀ x, x ∈ xs → x = 0) : dot xs ys = 0 
Arguments: {xs ys : Lean.Omega.IntList} (h : ∀ (x : Int), x ∈ xs → x = 0)
Goal: xs.dot ys = 0
-- Lean.Omega.IntList.dot_sdiv_left
theorem dot_sdiv_left (xs ys : IntList) {d : Int} (h : d ∣ xs.gcd) :
    dot (xs.sdiv d) ys = (dot xs ys) / d 
Arguments: (xs ys : Lean.Omega.IntList) {d : Int} (h : d ∣ ↑xs.gcd)
Goal: (xs.sdiv d).dot ys = xs.dot ys / d
-- Lean.Omega.IntList.bmod_length
theorem bmod_length (x : IntList) (m) : (bmod x m).length ≤ x.length 
Arguments: (x : Lean.Omega.IntList) (m : Nat)
Goal: List.length (x.bmod m) ≤ List.length x
-- Lean.Omega.IntList.dvd_bmod_dot_sub_dot_bmod
theorem dvd_bmod_dot_sub_dot_bmod (m : Nat) (xs ys : IntList) :
    (m : Int) ∣ bmod_dot_sub_dot_bmod m xs ys 
Arguments: (m : Nat) (xs ys : Lean.Omega.IntList)
Goal: ↑m ∣ Lean.Omega.IntList.bmod_dot_sub_dot_bmod m xs ys
-- Lean.Grind.intro_with_eq
theorem intro_with_eq (p p' q : Prop) (he : p = p') (h : p' → q) : p → q 
Arguments: (p p' q : Prop) (he : p = p') (h : p' → q)
Goal: p → q
-- ST.Ref.h
structure Ref (σ : Type) (α : Type) : Type where
  ref : RefPointed.type
  h   : Nonempty α
Arguments: {σ α : Type} (self : ST.Ref σ α)
Goal: Nonempty α
-- id_def
theorem id_def {α : Sort u} (a : α) : id a = a 
Arguments: {α : Sort u} (a : α)
Goal: id a = a
-- Function.const_apply
@[simp] theorem Function.const_apply {y : β} {x : α} : const α y x = y 
Arguments: {β : Sort u_1} {α : Sort u_2} {y : β} {x : α}
Goal: Function.const α y x = y
-- Function.comp_apply
@[simp] theorem Function.comp_apply {f : β → δ} {g : α → β} {x : α} : comp f g x = f (g x) 
Arguments: {β : Sort u_1} {δ : Sort u_2} {α : Sort u_3} {f : β → δ} {g : α → β} {x : α}
Goal: (f ∘ g) x = f (g x)
-- Function.comp_def
theorem Function.comp_def {α β δ} (f : β → δ) (g : α → β) : f ∘ g = fun x => f (g x) 
Arguments: {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β)
Goal: f ∘ g = fun x => f (g x)
-- Thunk.sizeOf_eq
@[simp] theorem Thunk.sizeOf_eq [SizeOf α] (a : Thunk α) : sizeOf a = 1 + sizeOf a.get 
Arguments: {α : Type u_1} [SizeOf α] (a : Thunk α)
Goal: sizeOf a = 1 + sizeOf a.get
-- Iff.mp
structure Iff (a b : Prop) : Prop where
    intro ::
    mp : a → b
    mpr : b → a
Arguments: {a b : Prop} (self : a ↔ b)
Goal: a → b
-- Iff.mpr
structure Iff (a b : Prop) : Prop where
    intro ::
    mp : a → b
    mpr : b → a
Arguments: {a b : Prop} (self : a ↔ b)
Goal: b → a