ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.ofNat_mul
@[norm_cast] theorem ofNat_mul (n m : Nat) : (↑(n * m) : Int) = n * m 
Arguments: (n m : Nat)
Goal: ↑(n * m) = ↑n * ↑m
-- Int.ofNat_succ
theorem ofNat_succ (n : Nat) : (succ n : Int) = n + 1 
Arguments: (n : Nat)
Goal: ↑n.succ = ↑n + 1
-- Int.neg_ofNat_zero
@[local simp] theorem neg_ofNat_zero : -((0 : Nat) : Int) = 0 
Goal: -↑0 = 0
-- Int.neg_ofNat_succ
@[local simp] theorem neg_ofNat_succ (n : Nat) : -(succ n : Int) = -[n+1] 
Arguments: (n : Nat)
Goal: -↑n.succ = Int.negSucc n
-- Int.neg_negSucc
@[local simp] theorem neg_negSucc (n : Nat) : -(-[n+1]) = succ n 
Arguments: (n : Nat)
Goal: -Int.negSucc n = ↑n.succ
-- Int.negSucc_coe
theorem negSucc_coe (n : Nat) : -[n+1] = -↑(n + 1) 
Arguments: (n : Nat)
Goal: Int.negSucc n = -↑(n + 1)
-- Int.negOfNat_eq
theorem negOfNat_eq : negOfNat n = -ofNat n 
Arguments: {n : Nat}
Goal: Int.negOfNat n = -Int.ofNat n
-- Int.add_def
@[simp] theorem add_def {a b : Int} : Int.add a b = a + b 
Arguments: {a b : Int}
Goal: a.add b = a + b
-- Int.ofNat_add_ofNat
@[local simp] theorem ofNat_add_ofNat (m n : Nat) : (↑m + ↑n : Int) = ↑(m + n) 
Arguments: (m n : Nat)
Goal: ↑m + ↑n = ↑(m + n)
-- Int.ofNat_add_negSucc
@[local simp] theorem ofNat_add_negSucc (m n : Nat) : ↑m + -[n+1] = subNatNat m (succ n) 
Arguments: (m n : Nat)
Goal: ↑m + Int.negSucc n = Int.subNatNat m n.succ
-- Int.negSucc_add_ofNat
@[local simp] theorem negSucc_add_ofNat (m n : Nat) : -[m+1] + ↑n = subNatNat n (succ m) 
Arguments: (m n : Nat)
Goal: Int.negSucc m + ↑n = Int.subNatNat n m.succ
-- Int.negSucc_add_negSucc
@[local simp] theorem negSucc_add_negSucc (m n : Nat) : -[m+1] + -[n+1] = -[succ (m + n) +1] 
Arguments: (m n : Nat)
Goal: Int.negSucc m + Int.negSucc n = Int.negSucc (m + n).succ
-- Int.mul_def
@[simp] theorem mul_def {a b : Int} : Int.mul a b = a * b 
Arguments: {a b : Int}
Goal: a.mul b = a * b
-- Int.ofNat_mul_ofNat
@[local simp] theorem ofNat_mul_ofNat (m n : Nat) : (↑m * ↑n : Int) = ↑(m * n) 
Arguments: (m n : Nat)
Goal: ↑m * ↑n = ↑(m * n)
-- Int.ofNat_mul_negSucc'
@[local simp] theorem ofNat_mul_negSucc' (m n : Nat) : ↑m * -[n+1] = negOfNat (m * succ n) 
Arguments: (m n : Nat)
Goal: ↑m * Int.negSucc n = Int.negOfNat (m * n.succ)
-- Int.negSucc_mul_ofNat'
@[local simp] theorem negSucc_mul_ofNat' (m n : Nat) : -[m+1] * ↑n = negOfNat (succ m * n) 
Arguments: (m n : Nat)
Goal: Int.negSucc m * ↑n = Int.negOfNat (m.succ * n)
-- Int.negSucc_mul_negSucc'
@[local simp] theorem negSucc_mul_negSucc' (m n : Nat) :
    -[m+1] * -[n+1] = ofNat (succ m * succ n) 
Arguments: (m n : Nat)
Goal: Int.negSucc m * Int.negSucc n = Int.ofNat (m.succ * n.succ)
-- Int.ofNat_inj
@[norm_cast] theorem ofNat_inj : ((m : Nat) : Int) = (n : Nat) ↔ m = n 
Arguments: {m n : Nat}
Goal: ↑m = ↑n ↔ m = n
-- Int.ofNat_eq_zero
theorem ofNat_eq_zero : ((n : Nat) : Int) = 0 ↔ n = 0 
Arguments: {n : Nat}
Goal: ↑n = 0 ↔ n = 0
-- Int.ofNat_ne_zero
theorem ofNat_ne_zero : ((n : Nat) : Int) ≠ 0 ↔ n ≠ 0 
Arguments: {n : Nat}
Goal: ↑n ≠ 0 ↔ n ≠ 0
-- Int.negSucc_inj
theorem negSucc_inj : negSucc m = negSucc n ↔ m = n 
Arguments: {m n : Nat}
Goal: Int.negSucc m = Int.negSucc n ↔ m = n
-- Int.negSucc_eq
theorem negSucc_eq (n : Nat) : -[n+1] = -((n : Int) + 1) 
Arguments: (n : Nat)
Goal: Int.negSucc n = -(↑n + 1)
-- Int.negSucc_ne_zero
@[simp] theorem negSucc_ne_zero (n : Nat) : -[n+1] ≠ 0 
Arguments: (n : Nat)
Goal: Int.negSucc n ≠ 0
-- Int.zero_ne_negSucc
@[simp] theorem zero_ne_negSucc (n : Nat) : 0 ≠ -[n+1] 
Arguments: (n : Nat)
Goal: 0 ≠ Int.negSucc n
-- Int.Nat.cast_ofNat_Int
@[simp, norm_cast] theorem Nat.cast_ofNat_Int :
  (Nat.cast (no_index (OfNat.ofNat n)) : Int) = OfNat.ofNat n 
Arguments: {n : Nat}
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- Int.neg_neg
@[simp] protected theorem neg_neg : ∀ a : Int, -(-a) = a
  
Arguments: (a : Int)
Goal: - -a = a
-- Int.neg_inj
protected theorem neg_inj {a b : Int} : -a = -b ↔ a = b 
Arguments: {a b : Int}
Goal: -a = -b ↔ a = b
-- Int.neg_eq_zero
@[simp] protected theorem neg_eq_zero : -a = 0 ↔ a = 0 
Arguments: {a : Int}
Goal: -a = 0 ↔ a = 0
-- Int.neg_ne_zero
protected theorem neg_ne_zero : -a ≠ 0 ↔ a ≠ 0 
Arguments: {a : Int}
Goal: -a ≠ 0 ↔ a ≠ 0
-- Int.sub_eq_add_neg
protected theorem sub_eq_add_neg {a b : Int} : a - b = a + -b 
Arguments: {a b : Int}
Goal: a - b = a + -b
-- Int.add_neg_one
theorem add_neg_one (i : Int) : i + -1 = i - 1 
Arguments: (i : Int)
Goal: i + -1 = i - 1
-- Int.subNatNat_elim
theorem subNatNat_elim (m n : Nat) (motive : Nat → Nat → Int → Prop)
    (hp : ∀ i n, motive (n + i) n i)
    (hn : ∀ i m, motive m (m + i + 1) -[i+1]) :
    motive m n (subNatNat m n) 
Arguments: (m n : Nat) (motive : Nat → Nat → Int → Prop) (hp : ∀ (i n : Nat), motive (n + i) n ↑i) (hn : ∀ (i m : Nat), motive m (m + i + 1) (Int.negSucc i))
Goal: motive m n (Int.subNatNat m n)
-- Int.subNatNat_add_left
theorem subNatNat_add_left : subNatNat (m + n) m = n 
Arguments: {m n : Nat}
Goal: Int.subNatNat (m + n) m = ↑n
-- Int.subNatNat_add_right
theorem subNatNat_add_right : subNatNat m (m + n + 1) = negSucc n 
Arguments: {m n : Nat}
Goal: Int.subNatNat m (m + n + 1) = Int.negSucc n
-- Int.subNatNat_add_add
theorem subNatNat_add_add (m n k : Nat) : subNatNat (m + k) (n + k) = subNatNat m n 
Arguments: (m n k : Nat)
Goal: Int.subNatNat (m + k) (n + k) = Int.subNatNat m n
-- Int.subNatNat_of_le
theorem subNatNat_of_le {m n : Nat} (h : n ≤ m) : subNatNat m n = ↑(m - n) 
Arguments: {m n : Nat} (h : n ≤ m)
Goal: Int.subNatNat m n = ↑(m - n)
-- Int.subNatNat_of_lt
theorem subNatNat_of_lt {m n : Nat} (h : m < n) : subNatNat m n = -[pred (n - m) +1] 
Arguments: {m n : Nat} (h : m < n)
Goal: Int.subNatNat m n = Int.negSucc (n - m).pred
-- Int.add_comm
protected theorem add_comm : ∀ a b : Int, a + b = b + a
  
Arguments: (a b : Int)
Goal: a + b = b + a
-- Int.add_zero
@[simp] protected theorem add_zero : ∀ a : Int, a + 0 = a
  
Arguments: (a : Int)
Goal: a + 0 = a
-- Int.zero_add
@[simp] protected theorem zero_add (a : Int) : 0 + a = a 
Arguments: (a : Int)
Goal: 0 + a = a
-- Int.ofNat_add_negSucc_of_lt
theorem ofNat_add_negSucc_of_lt (h : m < n.succ) : ofNat m + -[n+1] = -[n - m+1] 
Arguments: {m n : Nat} (h : m < n.succ)
Goal: Int.ofNat m + Int.negSucc n = Int.negSucc (n - m)
-- Int.subNatNat_sub
theorem subNatNat_sub (h : n ≤ m) (k : Nat) : subNatNat (m - n) k = subNatNat m (k + n) 
Arguments: {n m : Nat} (h : n ≤ m) (k : Nat)
Goal: Int.subNatNat (m - n) k = Int.subNatNat m (k + n)
-- Int.subNatNat_add
theorem subNatNat_add (m n k : Nat) : subNatNat (m + n) k = m + subNatNat n k 
Arguments: (m n k : Nat)
Goal: Int.subNatNat (m + n) k = ↑m + Int.subNatNat n k
-- Int.subNatNat_add_negSucc
theorem subNatNat_add_negSucc (m n k : Nat) :
    subNatNat m n + -[k+1] = subNatNat m (n + succ k) 
Arguments: (m n k : Nat)
Goal: Int.subNatNat m n + Int.negSucc k = Int.subNatNat m (n + k.succ)
-- Int.add_assoc
protected theorem add_assoc : ∀ a b c : Int, a + b + c = a + (b + c)
  
Arguments: (a b c : Int)
Goal: a + b + c = a + (b + c)
-- Int.add_assoc.aux2
protected theorem add_assoc : ∀ a b c : Int, a + b + c = a + (b + c)
  
Arguments: (m n k : Nat)
Goal: Int.negSucc m + Int.negSucc n + ↑k = Int.negSucc m + (Int.negSucc n + ↑k)
-- Int.add_assoc.aux1
protected theorem add_assoc : ∀ a b c : Int, a + b + c = a + (b + c)
  
Arguments: (m n : Nat) (c : Int)
Goal: ↑m + ↑n + c = ↑m + (↑n + c)
-- Int.add_left_comm
protected theorem add_left_comm (a b c : Int) : a + (b + c) = b + (a + c) 
Arguments: (a b c : Int)
Goal: a + (b + c) = b + (a + c)
-- Int.add_right_comm
protected theorem add_right_comm (a b c : Int) : a + b + c = a + c + b 
Arguments: (a b c : Int)
Goal: a + b + c = a + c + b
-- Int.subNatNat_self
theorem subNatNat_self : ∀ n, subNatNat n n = 0
  
Arguments: (n : Nat)
Goal: Int.subNatNat n n = 0
-- Int.add_left_neg
@[local simp] protected theorem add_left_neg : ∀ a : Int, -a + a = 0
  
Arguments: (a : Int)
Goal: -a + a = 0
-- Int.add_right_neg
@[local simp] protected theorem add_right_neg (a : Int) : a + -a = 0 
Arguments: (a : Int)
Goal: a + -a = 0
-- Int.neg_eq_of_add_eq_zero
@[simp] protected theorem neg_eq_of_add_eq_zero {a b : Int} (h : a + b = 0) : -a = b 
Arguments: {a b : Int} (h : a + b = 0)
Goal: -a = b
-- Int.eq_neg_of_eq_neg
protected theorem eq_neg_of_eq_neg {a b : Int} (h : a = -b) : b = -a 
Arguments: {a b : Int} (h : a = -b)
Goal: b = -a
-- Int.eq_neg_comm
protected theorem eq_neg_comm {a b : Int} : a = -b ↔ b = -a 
Arguments: {a b : Int}
Goal: a = -b ↔ b = -a
-- Int.neg_eq_comm
protected theorem neg_eq_comm {a b : Int} : -a = b ↔ -b = a 
Arguments: {a b : Int}
Goal: -a = b ↔ -b = a
-- Int.neg_add_cancel_left
protected theorem neg_add_cancel_left (a b : Int) : -a + (a + b) = b 
Arguments: (a b : Int)
Goal: -a + (a + b) = b
-- Int.add_neg_cancel_left
protected theorem add_neg_cancel_left (a b : Int) : a + (-a + b) = b 
Arguments: (a b : Int)
Goal: a + (-a + b) = b
-- Int.add_neg_cancel_right
protected theorem add_neg_cancel_right (a b : Int) : a + b + -b = a 
Arguments: (a b : Int)
Goal: a + b + -b = a
-- Int.neg_add_cancel_right
protected theorem neg_add_cancel_right (a b : Int) : a + -b + b = a 
Arguments: (a b : Int)
Goal: a + -b + b = a
-- Int.add_left_cancel
protected theorem add_left_cancel {a b c : Int} (h : a + b = a + c) : b = c 
Arguments: {a b c : Int} (h : a + b = a + c)
Goal: b = c
-- Int.neg_add
@[local simp] protected theorem neg_add {a b : Int} : -(a + b) = -a + -b 
Arguments: {a b : Int}
Goal: -(a + b) = -a + -b
-- Int.negSucc_sub_one
@[simp] theorem negSucc_sub_one (n : Nat) : -[n+1] - 1 = -[n + 1 +1] 
Arguments: (n : Nat)
Goal: Int.negSucc n - 1 = Int.negSucc (n + 1)
-- Int.sub_self
@[simp] protected theorem sub_self (a : Int) : a - a = 0 
Arguments: (a : Int)
Goal: a - a = 0
-- Int.sub_zero
@[simp] protected theorem sub_zero (a : Int) : a - 0 = a 
Arguments: (a : Int)
Goal: a - 0 = a
-- Int.zero_sub
@[simp] protected theorem zero_sub (a : Int) : 0 - a = -a 
Arguments: (a : Int)
Goal: 0 - a = -a
-- Int.sub_eq_zero_of_eq
protected theorem sub_eq_zero_of_eq {a b : Int} (h : a = b) : a - b = 0 
Arguments: {a b : Int} (h : a = b)
Goal: a - b = 0
-- Int.eq_of_sub_eq_zero
protected theorem eq_of_sub_eq_zero {a b : Int} (h : a - b = 0) : a = b 
Arguments: {a b : Int} (h : a - b = 0)
Goal: a = b
-- Int.sub_eq_zero
protected theorem sub_eq_zero {a b : Int} : a - b = 0 ↔ a = b 
Arguments: {a b : Int}
Goal: a - b = 0 ↔ a = b
-- Int.sub_sub
protected theorem sub_sub (a b c : Int) : a - b - c = a - (b + c) 
Arguments: (a b c : Int)
Goal: a - b - c = a - (b + c)
-- Int.neg_sub
protected theorem neg_sub (a b : Int) : -(a - b) = b - a 
Arguments: (a b : Int)
Goal: -(a - b) = b - a
-- Int.sub_sub_self
protected theorem sub_sub_self (a b : Int) : a - (a - b) = b 
Arguments: (a b : Int)
Goal: a - (a - b) = b
-- Int.sub_neg
protected theorem sub_neg (a b : Int) : a - -b = a + b 
Arguments: (a b : Int)
Goal: a - -b = a + b
-- Int.sub_add_cancel
@[simp] protected theorem sub_add_cancel (a b : Int) : a - b + b = a 
Arguments: (a b : Int)
Goal: a - b + b = a
-- Int.add_sub_cancel
@[simp] protected theorem add_sub_cancel (a b : Int) : a + b - b = a 
Arguments: (a b : Int)
Goal: a + b - b = a
-- Int.add_sub_assoc
protected theorem add_sub_assoc (a b c : Int) : a + b - c = a + (b - c) 
Arguments: (a b c : Int)
Goal: a + b - c = a + (b - c)
-- Int.ofNat_sub
@[norm_cast] theorem ofNat_sub (h : m ≤ n) : ((n - m : Nat) : Int) = n - m 
Arguments: {m n : Nat} (h : m ≤ n)
Goal: ↑(n - m) = ↑n - ↑m
-- Int.negSucc_coe'
theorem negSucc_coe' (n : Nat) : -[n+1] = -↑n - 1 
Arguments: (n : Nat)
Goal: Int.negSucc n = -↑n - 1
-- Int.subNatNat_eq_coe
protected theorem subNatNat_eq_coe {m n : Nat} : subNatNat m n = ↑m - ↑n 
Arguments: {m n : Nat}
Goal: Int.subNatNat m n = ↑m - ↑n
-- Int.toNat_sub
theorem toNat_sub (m n : Nat) : toNat (m - n) = m - n 
Arguments: (m n : Nat)
Goal: (↑m - ↑n).toNat = m - n
-- Int.add_right_inj
@[simp]
protected theorem add_right_inj (i j k : Int) : (i + k = j + k) ↔ i = j 
Arguments: (i j k : Int)
Goal: i + k = j + k ↔ i = j
-- Int.add_left_inj
@[simp]
protected theorem add_left_inj (i j k : Int) : (k + i = k + j) ↔ i = j 
Arguments: (i j k : Int)
Goal: k + i = k + j ↔ i = j
-- Int.sub_left_inj
@[simp]
protected theorem sub_left_inj (i j k : Int) : (k - i = k - j) ↔ i = j 
Arguments: (i j k : Int)
Goal: k - i = k - j ↔ i = j
-- Int.sub_right_inj
@[simp]
protected theorem sub_right_inj (i j k : Int) : (i - k = j - k) ↔ i = j 
Arguments: (i j k : Int)
Goal: i - k = j - k ↔ i = j
-- Int.ofNat_mul_negSucc
@[simp] theorem ofNat_mul_negSucc (m n : Nat) : (m : Int) * -[n+1] = -↑(m * succ n) 
Arguments: (m n : Nat)
Goal: ↑m * Int.negSucc n = -↑(m * n.succ)
-- Int.negSucc_mul_ofNat
@[simp] theorem negSucc_mul_ofNat (m n : Nat) : -[m+1] * n = -↑(succ m * n) 
Arguments: (m n : Nat)
Goal: Int.negSucc m * ↑n = -↑(m.succ * n)
-- Int.negSucc_mul_negSucc
@[simp] theorem negSucc_mul_negSucc (m n : Nat) : -[m+1] * -[n+1] = succ m * succ n 
Arguments: (m n : Nat)
Goal: Int.negSucc m * Int.negSucc n = ↑m.succ * ↑n.succ
-- Int.mul_comm
protected theorem mul_comm (a b : Int) : a * b = b * a 
Arguments: (a b : Int)
Goal: a * b = b * a
-- Int.ofNat_mul_negOfNat
theorem ofNat_mul_negOfNat (m n : Nat) : (m : Nat) * negOfNat n = negOfNat (m * n) 
Arguments: (m n : Nat)
Goal: ↑m * Int.negOfNat n = Int.negOfNat (m * n)
-- Int.negOfNat_mul_ofNat
theorem negOfNat_mul_ofNat (m n : Nat) : negOfNat m * (n : Nat) = negOfNat (m * n) 
Arguments: (m n : Nat)
Goal: Int.negOfNat m * ↑n = Int.negOfNat (m * n)
-- Int.negSucc_mul_negOfNat
theorem negSucc_mul_negOfNat (m n : Nat) : -[m+1] * negOfNat n = ofNat (succ m * n) 
Arguments: (m n : Nat)
Goal: Int.negSucc m * Int.negOfNat n = Int.ofNat (m.succ * n)
-- Int.negOfNat_mul_negSucc
theorem negOfNat_mul_negSucc (m n : Nat) : negOfNat n * -[m+1] = ofNat (n * succ m) 
Arguments: (m n : Nat)
Goal: Int.negOfNat n * Int.negSucc m = Int.ofNat (n * m.succ)
-- Int.mul_assoc
protected theorem mul_assoc (a b c : Int) : a * b * c = a * (b * c) 
Arguments: (a b c : Int)
Goal: a * b * c = a * (b * c)
-- Int.mul_left_comm
protected theorem mul_left_comm (a b c : Int) : a * (b * c) = b * (a * c) 
Arguments: (a b c : Int)
Goal: a * (b * c) = b * (a * c)
-- Int.mul_right_comm
protected theorem mul_right_comm (a b c : Int) : a * b * c = a * c * b 
Arguments: (a b c : Int)
Goal: a * b * c = a * c * b
-- Int.mul_zero
@[simp] protected theorem mul_zero (a : Int) : a * 0 = 0 
Arguments: (a : Int)
Goal: a * 0 = 0
-- Int.zero_mul
@[simp] protected theorem zero_mul (a : Int) : 0 * a = 0 
Arguments: (a : Int)
Goal: 0 * a = 0
-- Int.negOfNat_eq_subNatNat_zero
theorem negOfNat_eq_subNatNat_zero (n) : negOfNat n = subNatNat 0 n 
Arguments: (n : Nat)
Goal: Int.negOfNat n = Int.subNatNat 0 n
-- Int.ofNat_mul_subNatNat
theorem ofNat_mul_subNatNat (m n k : Nat) :
    m * subNatNat n k = subNatNat (m * n) (m * k) 
Arguments: (m n k : Nat)
Goal: ↑m * Int.subNatNat n k = Int.subNatNat (m * n) (m * k)
-- Int.negOfNat_add
theorem negOfNat_add (m n : Nat) : negOfNat m + negOfNat n = negOfNat (m + n) 
Arguments: (m n : Nat)
Goal: Int.negOfNat m + Int.negOfNat n = Int.negOfNat (m + n)
-- Int.negSucc_mul_subNatNat
theorem negSucc_mul_subNatNat (m n k : Nat) :
    -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) 
Arguments: (m n k : Nat)
Goal: Int.negSucc m * Int.subNatNat n k = Int.subNatNat (m.succ * k) (m.succ * n)
-- Int.mul_add
protected theorem mul_add : ∀ a b c : Int, a * (b + c) = a * b + a * c
  
Arguments: (a b c : Int)
Goal: a * (b + c) = a * b + a * c
-- Int.add_mul
protected theorem add_mul (a b c : Int) : (a + b) * c = a * c + b * c 
Arguments: (a b c : Int)
Goal: (a + b) * c = a * c + b * c
-- Int.neg_mul_eq_neg_mul
protected theorem neg_mul_eq_neg_mul (a b : Int) : -(a * b) = -a * b 
Arguments: (a b : Int)
Goal: -(a * b) = -a * b
-- Int.neg_mul_eq_mul_neg
protected theorem neg_mul_eq_mul_neg (a b : Int) : -(a * b) = a * -b 
Arguments: (a b : Int)
Goal: -(a * b) = a * -b
-- Int.neg_mul
@[local simp] protected theorem neg_mul (a b : Int) : -a * b = -(a * b) 
Arguments: (a b : Int)
Goal: -a * b = -(a * b)
-- Int.mul_neg
@[local simp] protected theorem mul_neg (a b : Int) : a * -b = -(a * b) 
Arguments: (a b : Int)
Goal: a * -b = -(a * b)
-- Int.neg_mul_neg
protected theorem neg_mul_neg (a b : Int) : -a * -b = a * b 
Arguments: (a b : Int)
Goal: -a * -b = a * b
-- Int.neg_mul_comm
protected theorem neg_mul_comm (a b : Int) : -a * b = a * -b 
Arguments: (a b : Int)
Goal: -a * b = a * -b
-- Int.mul_sub
protected theorem mul_sub (a b c : Int) : a * (b - c) = a * b - a * c 
Arguments: (a b c : Int)
Goal: a * (b - c) = a * b - a * c
-- Int.sub_mul
protected theorem sub_mul (a b c : Int) : (a - b) * c = a * c - b * c 
Arguments: (a b c : Int)
Goal: (a - b) * c = a * c - b * c
-- Int.one_mul
@[simp] protected theorem one_mul : ∀ a : Int, 1 * a = a
  
Arguments: (a : Int)
Goal: 1 * a = a
-- Int.mul_one
@[simp] protected theorem mul_one (a : Int) : a * 1 = a 
Arguments: (a : Int)
Goal: a * 1 = a
-- Int.mul_neg_one
protected theorem mul_neg_one (a : Int) : a * -1 = -a 
Arguments: (a : Int)
Goal: a * -1 = -a
-- Int.neg_eq_neg_one_mul
protected theorem neg_eq_neg_one_mul : ∀ a : Int, -a = -1 * a
  
Arguments: (a : Int)
Goal: -a = -1 * a
-- Int.mul_eq_zero
protected theorem mul_eq_zero {a b : Int} : a * b = 0 ↔ a = 0 ∨ b = 0 
Arguments: {a b : Int}
Goal: a * b = 0 ↔ a = 0 ∨ b = 0
-- Int.mul_ne_zero
protected theorem mul_ne_zero {a b : Int} (a0 : a ≠ 0) (b0 : b ≠ 0) : a * b ≠ 0 
Arguments: {a b : Int} (a0 : a ≠ 0) (b0 : b ≠ 0)
Goal: a * b ≠ 0
-- Int.eq_of_mul_eq_mul_right
protected theorem eq_of_mul_eq_mul_right {a b c : Int} (ha : a ≠ 0) (h : b * a = c * a) : b = c 
Arguments: {a b c : Int} (ha : a ≠ 0) (h : b * a = c * a)
Goal: b = c
-- Int.eq_of_mul_eq_mul_left
protected theorem eq_of_mul_eq_mul_left {a b c : Int} (ha : a ≠ 0) (h : a * b = a * c) : b = c 
Arguments: {a b c : Int} (ha : a ≠ 0) (h : a * b = a * c)
Goal: b = c
-- Int.mul_eq_mul_left_iff
theorem mul_eq_mul_left_iff {a b c : Int} (h : c ≠ 0) : c * a = c * b ↔ a = b 
Arguments: {a b c : Int} (h : c ≠ 0)
Goal: c * a = c * b ↔ a = b
-- Int.mul_eq_mul_right_iff
theorem mul_eq_mul_right_iff {a b c : Int} (h : c ≠ 0) : a * c = b * c ↔ a = b 
Arguments: {a b c : Int} (h : c ≠ 0)
Goal: a * c = b * c ↔ a = b
-- Int.eq_one_of_mul_eq_self_left
theorem eq_one_of_mul_eq_self_left {a b : Int} (Hpos : a ≠ 0) (H : b * a = a) : b = 1 
Arguments: {a b : Int} (Hpos : a ≠ 0) (H : b * a = a)
Goal: b = 1
-- Int.eq_one_of_mul_eq_self_right
theorem eq_one_of_mul_eq_self_right {a b : Int} (Hpos : b ≠ 0) (H : b * a = b) : a = 1 
Arguments: {a b : Int} (Hpos : b ≠ 0) (H : b * a = b)
Goal: a = 1
-- Int.natCast_zero
theorem natCast_zero : ((0 : Nat) : Int) = (0 : Int) 
Goal: ↑0 = 0
-- Int.natCast_one
theorem natCast_one : ((1 : Nat) : Int) = (1 : Int) 
Goal: ↑1 = 1
-- Int.natCast_add
@[simp] theorem natCast_add (a b : Nat) : ((a + b : Nat) : Int) = (a : Int) + (b : Int) 
Arguments: (a b : Nat)
Goal: ↑(a + b) = ↑a + ↑b
-- Int.natCast_mul
@[simp] theorem natCast_mul (a b : Nat) : ((a * b : Nat) : Int) = (a : Int) * (b : Int) 
Arguments: (a b : Nat)
Goal: ↑(a * b) = ↑a * ↑b
-- List.length_nil
@[simp] theorem length_nil : length ([] : List α) = 0 
Arguments: {α : Type u}
Goal: List.nil.length = 0
-- List.length_singleton
@[simp 1100] theorem length_singleton (a : α) : length [a] = 1 
Arguments: {α : Type u} (a : α)
Goal: (a :: List.nil).length = 1
-- List.length_cons
@[simp] theorem length_cons {α} (a : α) (as : List α) : (cons a as).length = as.length + 1 
Arguments: {α : Type u_1} (a : α) (as : List α)
Goal: (a :: as).length = as.length + 1
-- List.length_set
@[simp] theorem length_set (as : List α) (i : Nat) (a : α) : (as.set i a).length = as.length 
Arguments: {α : Type u} (as : List α) (i : Nat) (a : α)
Goal: (as.set i a).length = as.length
-- List.foldl_nil
@[simp] theorem foldl_nil : [].foldl f b = b 
Goal: ∀ {α : Type u_1} {β : Type u_2} {f : α → β → α} {b : α}, List.foldl f b List.nil = b
-- List.foldl_cons
@[simp] theorem foldl_cons (l : List α) (b : β) : (a :: l).foldl f b = l.foldl f (f b a) 
Arguments: {α : Type u} {β : Type v} {a : α} {f : β → α → β} (l : List α) (b : β)
Goal: List.foldl f b (a :: l) = List.foldl f (f b a) l
-- List.length_concat
@[simp] theorem length_concat (as : List α) (a : α) : (concat as a).length = as.length + 1 
Arguments: {α : Type u} (as : List α) (a : α)
Goal: (as.concat a).length = as.length + 1
-- List.of_concat_eq_concat
theorem of_concat_eq_concat {as bs : List α} {a b : α} (h : as.concat a = bs.concat b) : as = bs ∧ a = b 
Arguments: {α : Type u} {as bs : List α} {a b : α} (h : as.concat a = bs.concat b)
Goal: as = bs ∧ a = b
-- List.isEqv_nil_nil
@[simp] theorem isEqv_nil_nil : isEqv ([] : List α) [] eqv = true 
Arguments: {α : Type u} {eqv : α → α → Bool}
Goal: List.nil.isEqv List.nil eqv = true
-- List.isEqv_nil_cons
@[simp] theorem isEqv_nil_cons : isEqv ([] : List α) (a::as) eqv = false 
Arguments: {α : Type u} {a : α} {as : List α} {eqv : α → α → Bool}
Goal: List.nil.isEqv (a :: as) eqv = false
-- List.isEqv_cons_nil
@[simp] theorem isEqv_cons_nil : isEqv (a::as : List α) [] eqv = false 
Arguments: {α : Type u} {a : α} {as : List α} {eqv : α → α → Bool}
Goal: (a :: as).isEqv List.nil eqv = false
-- List.isEqv_cons₂
theorem isEqv_cons₂ : isEqv (a::as) (b::bs) eqv = (eqv a b && isEqv as bs eqv) 
Goal: ∀ {α : Type u_1} {a : α} {as : List α} {b : α} {bs : List α} {eqv : α → α → Bool},
  (a :: as).isEqv (b :: bs) eqv = (eqv a b && as.isEqv bs eqv)
-- List.get?_nil
@[simp] theorem get?_nil : @get? α [] n = none 
Arguments: {α : Type u} {n : Nat}
Goal: List.nil.get? n = none
-- List.get?_cons_zero
@[simp] theorem get?_cons_zero : @get? α (a::l) 0 = some a 
Arguments: {α : Type u} {a : α} {l : List α}
Goal: (a :: l).get? 0 = some a
-- List.get?_cons_succ
@[simp] theorem get?_cons_succ : @get? α (a::l) (n+1) = get? l n 
Arguments: {α : Type u} {a : α} {l : List α} {n : Nat}
Goal: (a :: l).get? (n + 1) = l.get? n
-- List.ext_get?
theorem ext_get? : ∀ {l₁ l₂ : List α}, (∀ n, l₁.get? n = l₂.get? n) → l₁ = l₂
  
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: (∀ (n : Nat), l₁.get? n = l₂.get? n) → l₁ = l₂
-- List.getD_nil
@[simp] theorem getD_nil : getD [] n d = d 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {d : α}, List.nil.getD n d = d
-- List.getD_cons_zero
@[simp] theorem getD_cons_zero : getD (x :: xs) 0 d = x 
Goal: ∀ {α : Type u_1} {x : α} {xs : List α} {d : α}, (x :: xs).getD 0 d = x
-- List.getD_cons_succ
@[simp] theorem getD_cons_succ : getD (x :: xs) (n + 1) d = getD xs n d 
Goal: ∀ {α : Type u_1} {x : α} {xs : List α} {n : Nat} {d : α}, (x :: xs).getD (n + 1) d = xs.getD n d
-- List.getLast?_nil
@[simp] theorem getLast?_nil : @getLast? α [] = none 
Arguments: {α : Type u}
Goal: List.nil.getLast? = none
-- List.getLastD_nil
@[simp] theorem getLastD_nil (a) : @getLastD α [] a = a 
Arguments: {α : Type u} (a : α)
Goal: List.nil.getLastD a = a
-- List.getLastD_cons
@[simp] theorem getLastD_cons (a b l) : @getLastD α (b::l) a = getLastD l b 
Arguments: {α : Type u} (a b : α) (l : List α)
Goal: (b :: l).getLastD a = l.getLastD b
-- List.head_cons
@[simp] theorem head_cons : @head α (a::l) h = a 
Arguments: {α : Type u} {a : α} {l : List α} {h : a :: l ≠ List.nil}
Goal: (a :: l).head h = a
-- List.head?_nil
@[simp] theorem head?_nil : @head? α [] = none 
Arguments: {α : Type u}
Goal: List.nil.head? = none
-- List.head?_cons
@[simp] theorem head?_cons : @head? α (a::l) = some a 
Arguments: {α : Type u} {a : α} {l : List α}
Goal: (a :: l).head? = some a
-- List.headD_nil
@[simp 1100] theorem headD_nil : @headD α [] d = d 
Arguments: {α : Type u} {d : α}
Goal: List.nil.headD d = d
-- List.headD_cons
@[simp 1100] theorem headD_cons : @headD α (a::l) d = a 
Arguments: {α : Type u} {a : α} {l : List α} {d : α}
Goal: (a :: l).headD d = a
-- List.tail?_nil
@[simp] theorem tail?_nil : @tail? α [] = none 
Arguments: {α : Type u}
Goal: List.nil.tail? = none
-- List.tail?_cons
@[simp] theorem tail?_cons : @tail? α (a::l) = some l 
Arguments: {α : Type u} {a : α} {l : List α}
Goal: (a :: l).tail? = some l
-- List.tailD_nil
@[simp 1100] theorem tailD_nil : @tailD α [] l' = l' 
Arguments: {α : Type u} {l' : List α}
Goal: List.nil.tailD l' = l'
-- List.tailD_cons
@[simp 1100] theorem tailD_cons : @tailD α (a::l) l' = l 
Arguments: {α : Type u} {a : α} {l l' : List α}
Goal: (a :: l).tailD l' = l