ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.fmod_eq_mod
theorem fmod_eq_mod {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : fmod a b = mod a b 
Arguments: {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b)
Goal: a.fmod b = a.mod b
-- Int.ediv_neg
@[simp] protected theorem ediv_neg : ∀ a b : Int, a / (-b) = -(a / b)
  
Arguments: (a b : Int)
Goal: a / -b = -(a / b)
-- Int.ediv_neg'
theorem ediv_neg' {a b : Int} (Ha : a < 0) (Hb : 0 < b) : a / b < 0 
Arguments: {a b : Int} (Ha : a < 0) (Hb : 0 < b)
Goal: a / b < 0
-- Int.div_def
protected theorem div_def (a b : Int) : a / b = Int.ediv a b 
Arguments: (a b : Int)
Goal: a / b = a.ediv b
-- Int.negSucc_ediv
theorem negSucc_ediv (m : Nat) {b : Int} (H : 0 < b) : -[m+1] / b = -(div m b + 1) 
Arguments: (m : Nat) {b : Int} (H : 0 < b)
Goal: -[m+1] / b = -((↑m).div b + 1)
-- Int.ediv_nonneg
theorem ediv_nonneg {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : 0 ≤ a / b 
Arguments: {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b)
Goal: 0 ≤ a / b
-- Int.ediv_nonpos
theorem ediv_nonpos {a b : Int} (Ha : 0 ≤ a) (Hb : b ≤ 0) : a / b ≤ 0 
Arguments: {a b : Int} (Ha : 0 ≤ a) (Hb : b ≤ 0)
Goal: a / b ≤ 0
-- Int.add_mul_ediv_right
theorem add_mul_ediv_right (a b : Int) {c : Int} (H : c ≠ 0) : (a + b * c) / c = a / c + b 
Arguments: (a b : Int) {c : Int} (H : c ≠ 0)
Goal: (a + b * c) / c = a / c + b
-- Int.add_ediv_of_dvd_right
theorem add_ediv_of_dvd_right {a b c : Int} (H : c ∣ b) : (a + b) / c = a / c + b / c 
Arguments: {a b c : Int} (H : c ∣ b)
Goal: (a + b) / c = a / c + b / c
-- Int.add_ediv_of_dvd_left
theorem add_ediv_of_dvd_left {a b c : Int} (H : c ∣ a) : (a + b) / c = a / c + b / c 
Arguments: {a b c : Int} (H : c ∣ a)
Goal: (a + b) / c = a / c + b / c
-- Int.mul_ediv_cancel
@[simp] theorem mul_ediv_cancel (a : Int) {b : Int} (H : b ≠ 0) : (a * b) / b = a 
Arguments: (a : Int) {b : Int} (H : b ≠ 0)
Goal: a * b / b = a
-- Int.mul_ediv_cancel_left
@[simp] theorem mul_ediv_cancel_left (b : Int) (H : a ≠ 0) : (a * b) / a = b 
Arguments: {a : Int} (b : Int) (H : a ≠ 0)
Goal: a * b / a = b
-- Int.div_nonneg_iff_of_pos
theorem div_nonneg_iff_of_pos {a b : Int} (h : 0 < b) : a / b ≥ 0 ↔ a ≥ 0 
Arguments: {a b : Int} (h : 0 < b)
Goal: a / b ≥ 0 ↔ a ≥ 0
-- Int.ediv_eq_zero_of_lt
theorem ediv_eq_zero_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a / b = 0 
Arguments: {a b : Int} (H1 : 0 ≤ a) (H2 : a < b)
Goal: a / b = 0
-- Int.add_mul_ediv_left
theorem add_mul_ediv_left (a : Int) {b : Int}
    (c : Int) (H : b ≠ 0) : (a + b * c) / b = a / b + c 
Arguments: (a : Int) {b : Int} (c : Int) (H : b ≠ 0)
Goal: (a + b * c) / b = a / b + c
-- Int.mul_ediv_mul_of_pos
@[simp] theorem mul_ediv_mul_of_pos {a : Int}
    (b c : Int) (H : 0 < a) : (a * b) / (a * c) = b / c 
Arguments: {a : Int} (b c : Int) (H : 0 < a)
Goal: a * b / (a * c) = b / c
-- Int.mul_ediv_mul_of_pos_left
@[simp] theorem mul_ediv_mul_of_pos_left
    (a : Int) {b : Int} (c : Int) (H : 0 < b) : (a * b) / (c * b) = a / c 
Arguments: (a : Int) {b : Int} (c : Int) (H : 0 < b)
Goal: a * b / (c * b) = a / c
-- Int.ediv_eq_of_eq_mul_right
protected theorem ediv_eq_of_eq_mul_right {a b c : Int}
    (H1 : b ≠ 0) (H2 : a = b * c) : a / b = c 
Arguments: {a b c : Int} (H1 : b ≠ 0) (H2 : a = b * c)
Goal: a / b = c
-- Int.eq_ediv_of_mul_eq_right
protected theorem eq_ediv_of_mul_eq_right {a b c : Int}
    (H1 : a ≠ 0) (H2 : a * b = c) : b = c / a 
Arguments: {a b c : Int} (H1 : a ≠ 0) (H2 : a * b = c)
Goal: b = c / a
-- Int.ediv_eq_of_eq_mul_left
protected theorem ediv_eq_of_eq_mul_left {a b c : Int}
    (H1 : b ≠ 0) (H2 : a = c * b) : a / b = c 
Arguments: {a b c : Int} (H1 : b ≠ 0) (H2 : a = c * b)
Goal: a / b = c
-- Int.mod_def'
theorem mod_def' (m n : Int) : m % n = emod m n 
Arguments: (m n : Int)
Goal: m % n = m.emod n
-- Int.negSucc_emod
theorem negSucc_emod (m : Nat) {b : Int} (bpos : 0 < b) : -[m+1] % b = b - 1 - m % b 
Arguments: (m : Nat) {b : Int} (bpos : 0 < b)
Goal: -[m+1] % b = b - 1 - ↑m % b
-- Int.emod_negSucc
theorem emod_negSucc (m : Nat) (n : Int) :
  (Int.negSucc m) % n = Int.subNatNat (Int.natAbs n) (Nat.succ (m % Int.natAbs n)) 
Arguments: (m : Nat) (n : Int)
Goal: -[m+1] % n = Int.subNatNat n.natAbs (m % n.natAbs).succ
-- Int.ofNat_mod_ofNat
theorem ofNat_mod_ofNat (m n : Nat) : (m % n : Int) = ↑(m % n) 
Arguments: (m n : Nat)
Goal: ↑m % ↑n = ↑(m % n)
-- Int.emod_nonneg
theorem emod_nonneg : ∀ (a : Int) {b : Int}, b ≠ 0 → 0 ≤ a % b
  
Arguments: (a : Int) {b : Int}
Goal: b ≠ 0 → 0 ≤ a % b
-- Int.emod_lt_of_pos
theorem emod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : a % b < b 
Arguments: (a : Int) {b : Int} (H : 0 < b)
Goal: a % b < b
-- Int.mul_ediv_self_le
theorem mul_ediv_self_le {x k : Int} (h : k ≠ 0) : k * (x / k) ≤ x 
Arguments: {x k : Int} (h : k ≠ 0)
Goal: k * (x / k) ≤ x
-- Int.lt_mul_ediv_self_add
theorem lt_mul_ediv_self_add {x k : Int} (h : 0 < k) : x < k * (x / k) + k 
Arguments: {x k : Int} (h : 0 < k)
Goal: x < k * (x / k) + k
-- Int.add_mul_emod_self
@[simp] theorem add_mul_emod_self {a b c : Int} : (a + b * c) % c = a % c 
Arguments: {a b c : Int}
Goal: (a + b * c) % c = a % c
-- Int.add_mul_emod_self_left
@[simp] theorem add_mul_emod_self_left (a b c : Int) : (a + b * c) % b = a % b 
Arguments: (a b c : Int)
Goal: (a + b * c) % b = a % b
-- Int.add_emod_self
@[simp] theorem add_emod_self {a b : Int} : (a + b) % b = a % b 
Arguments: {a b : Int}
Goal: (a + b) % b = a % b
-- Int.add_emod_self_left
@[simp] theorem add_emod_self_left {a b : Int} : (a + b) % a = b % a 
Arguments: {a b : Int}
Goal: (a + b) % a = b % a
-- Int.neg_emod
theorem neg_emod {a b : Int} : -a % b = (b - a) % b 
Arguments: {a b : Int}
Goal: -a % b = (b - a) % b
-- Int.emod_neg
@[simp] theorem emod_neg (a b : Int) : a % -b = a % b 
Arguments: (a b : Int)
Goal: a % -b = a % b
-- Int.emod_add_emod
@[simp] theorem emod_add_emod (m n k : Int) : (m % n + k) % n = (m + k) % n 
Arguments: (m n k : Int)
Goal: (m % n + k) % n = (m + k) % n
-- Int.add_emod_emod
@[simp] theorem add_emod_emod (m n k : Int) : (m + n % k) % k = (m + n) % k 
Arguments: (m n k : Int)
Goal: (m + n % k) % k = (m + n) % k
-- Int.add_emod
theorem add_emod (a b n : Int) : (a + b) % n = (a % n + b % n) % n 
Arguments: (a b n : Int)
Goal: (a + b) % n = (a % n + b % n) % n
-- Int.add_emod_eq_add_emod_right
theorem add_emod_eq_add_emod_right {m n k : Int} (i : Int)
    (H : m % n = k % n) : (m + i) % n = (k + i) % n 
Arguments: {m n k : Int} (i : Int) (H : m % n = k % n)
Goal: (m + i) % n = (k + i) % n
-- Int.emod_add_cancel_right
theorem emod_add_cancel_right {m n k : Int} (i) : (m + i) % n = (k + i) % n ↔ m % n = k % n 
Arguments: {m n k : Int} (i : Int)
Goal: (m + i) % n = (k + i) % n ↔ m % n = k % n
-- Int.mul_emod_left
@[simp] theorem mul_emod_left (a b : Int) : (a * b) % b = 0 
Arguments: (a b : Int)
Goal: a * b % b = 0
-- Int.mul_emod_right
@[simp] theorem mul_emod_right (a b : Int) : (a * b) % a = 0 
Arguments: (a b : Int)
Goal: a * b % a = 0
-- Int.mul_emod
theorem mul_emod (a b n : Int) : (a * b) % n = (a % n) * (b % n) % n 
Arguments: (a b n : Int)
Goal: a * b % n = a % n * (b % n) % n
-- Int.emod_self
@[local simp] theorem emod_self {a : Int} : a % a = 0 
Arguments: {a : Int}
Goal: a % a = 0
-- Int.emod_emod_of_dvd
@[simp] theorem emod_emod_of_dvd (n : Int) {m k : Int}
    (h : m ∣ k) : (n % k) % m = n % m 
Arguments: (n : Int) {m k : Int} (h : m ∣ k)
Goal: n % k % m = n % m
-- Int.emod_emod
@[simp] theorem emod_emod (a b : Int) : (a % b) % b = a % b 
Arguments: (a b : Int)
Goal: a % b % b = a % b
-- Int.sub_emod
theorem sub_emod (a b n : Int) : (a - b) % n = (a % n - b % n) % n 
Arguments: (a b n : Int)
Goal: (a - b) % n = (a % n - b % n) % n
-- Int.emod_eq_of_lt
theorem emod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a % b = a 
Arguments: {a b : Int} (H1 : 0 ≤ a) (H2 : a < b)
Goal: a % b = a
-- Int.emod_self_add_one
@[simp] theorem emod_self_add_one {x : Int} (h : 0 ≤ x) : x % (x + 1) = x 
Arguments: {x : Int} (h : 0 ≤ x)
Goal: x % (x + 1) = x
-- Int.mul_ediv_cancel_of_emod_eq_zero
theorem mul_ediv_cancel_of_emod_eq_zero {a b : Int} (H : a % b = 0) : b * (a / b) = a 
Arguments: {a b : Int} (H : a % b = 0)
Goal: b * (a / b) = a
-- Int.ediv_mul_cancel_of_emod_eq_zero
theorem ediv_mul_cancel_of_emod_eq_zero {a b : Int} (H : a % b = 0) : a / b * b = a 
Arguments: {a b : Int} (H : a % b = 0)
Goal: a / b * b = a
-- Int.emod_two_eq
theorem emod_two_eq (x : Int) : x % 2 = 0 ∨ x % 2 = 1 
Arguments: (x : Int)
Goal: x % 2 = 0 ∨ x % 2 = 1
-- Int.add_emod_eq_add_emod_left
theorem add_emod_eq_add_emod_left {m n k : Int} (i : Int)
    (H : m % n = k % n) : (i + m) % n = (i + k) % n 
Arguments: {m n k : Int} (i : Int) (H : m % n = k % n)
Goal: (i + m) % n = (i + k) % n
-- Int.emod_add_cancel_left
theorem emod_add_cancel_left {m n k i : Int} : (i + m) % n = (i + k) % n ↔ m % n = k % n 
Arguments: {m n k i : Int}
Goal: (i + m) % n = (i + k) % n ↔ m % n = k % n
-- Int.emod_sub_cancel_right
theorem emod_sub_cancel_right {m n k : Int} (i) : (m - i) % n = (k - i) % n ↔ m % n = k % n 
Arguments: {m n k : Int} (i : Int)
Goal: (m - i) % n = (k - i) % n ↔ m % n = k % n
-- Int.emod_eq_emod_iff_emod_sub_eq_zero
theorem emod_eq_emod_iff_emod_sub_eq_zero {m n k : Int} : m % n = k % n ↔ (m - k) % n = 0 
Arguments: {m n k : Int}
Goal: m % n = k % n ↔ (m - k) % n = 0
-- Int.ediv_emod_unique
protected theorem ediv_emod_unique {a b r q : Int} (h : 0 < b) :
  a / b = q ∧ a % b = r ↔ r + b * q = a ∧ 0 ≤ r ∧ r < b 
Arguments: {a b r q : Int} (h : 0 < b)
Goal: a / b = q ∧ a % b = r ↔ r + b * q = a ∧ 0 ≤ r ∧ r < b
-- Int.mul_emod_mul_of_pos
@[simp] theorem mul_emod_mul_of_pos
    {a : Int} (b c : Int) (H : 0 < a) : (a * b) % (a * c) = a * (b % c) 
Arguments: {a : Int} (b c : Int) (H : 0 < a)
Goal: a * b % (a * c) = a * (b % c)
-- Int.lt_ediv_add_one_mul_self
theorem lt_ediv_add_one_mul_self (a : Int) {b : Int} (H : 0 < b) : a < (a / b + 1) * b 
Arguments: (a : Int) {b : Int} (H : 0 < b)
Goal: a < (a / b + 1) * b
-- Int.natAbs_div_le_natAbs.aux
theorem natAbs_div_le_natAbs (a b : Int) : natAbs (a / b) ≤ natAbs a 
Arguments: (a : Int) (n : Nat)
Goal: (a / ↑n).natAbs ≤ a.natAbs
-- Int.natAbs_div_le_natAbs
theorem natAbs_div_le_natAbs (a b : Int) : natAbs (a / b) ≤ natAbs a 
Arguments: (a b : Int)
Goal: (a / b).natAbs ≤ a.natAbs
-- Int.ediv_le_self
theorem ediv_le_self {a : Int} (b : Int) (Ha : 0 ≤ a) : a / b ≤ a 
Arguments: {a : Int} (b : Int) (Ha : 0 ≤ a)
Goal: a / b ≤ a
-- Int.dvd_of_emod_eq_zero
theorem dvd_of_emod_eq_zero {a b : Int} (H : b % a = 0) : a ∣ b 
Arguments: {a b : Int} (H : b % a = 0)
Goal: a ∣ b
-- Int.dvd_emod_sub_self
theorem dvd_emod_sub_self {x : Int} {m : Nat} : (m : Int) ∣ x % m - x 
Arguments: {x : Int} {m : Nat}
Goal: ↑m ∣ x % ↑m - x
-- Int.emod_eq_zero_of_dvd
theorem emod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → b % a = 0
  
Arguments: {a b : Int}
Goal: a ∣ b → b % a = 0
-- Int.dvd_iff_emod_eq_zero
theorem dvd_iff_emod_eq_zero (a b : Int) : a ∣ b ↔ b % a = 0 
Arguments: (a b : Int)
Goal: a ∣ b ↔ b % a = 0
-- Int.emod_pos_of_not_dvd
theorem emod_pos_of_not_dvd {a b : Int} (h : ¬ a ∣ b) : a = 0 ∨ 0 < b % a 
Arguments: {a b : Int} (h : ¬a ∣ b)
Goal: a = 0 ∨ 0 < b % a
-- Int.mul_ediv_assoc
protected theorem mul_ediv_assoc (a : Int) : ∀ {b c : Int}, c ∣ b → (a * b) / c = a * (b / c)
  
Arguments: (a : Int) {b c : Int}
Goal: c ∣ b → a * b / c = a * (b / c)
-- Int.mul_ediv_assoc'
protected theorem mul_ediv_assoc' (b : Int) {a c : Int}
    (h : c ∣ a) : (a * b) / c = a / c * b 
Arguments: (b : Int) {a c : Int} (h : c ∣ a)
Goal: a * b / c = a / c * b
-- Int.neg_ediv_of_dvd
theorem neg_ediv_of_dvd : ∀ {a b : Int}, b ∣ a → (-a) / b = -(a / b)
  
Arguments: {a b : Int}
Goal: b ∣ a → -a / b = -(a / b)
-- Int.sub_ediv_of_dvd
theorem sub_ediv_of_dvd (a : Int) {b c : Int}
    (hcb : c ∣ b) : (a - b) / c = a / c - b / c 
Arguments: (a : Int) {b c : Int} (hcb : c ∣ b)
Goal: (a - b) / c = a / c - b / c
-- Int.ediv_one
@[simp] theorem ediv_one : ∀ a : Int, a / 1 = a
  
Arguments: (a : Int)
Goal: a / 1 = a
-- Int.emod_one
@[simp] theorem emod_one (a : Int) : a % 1 = 0 
Arguments: (a : Int)
Goal: a % 1 = 0
-- Int.ediv_self
@[simp] protected theorem ediv_self {a : Int} (H : a ≠ 0) : a / a = 1 
Arguments: {a : Int} (H : a ≠ 0)
Goal: a / a = 1
-- Int.emod_sub_cancel
@[simp]
theorem emod_sub_cancel (x y : Int): (x - y)%y = x%y 
Arguments: (x y : Int)
Goal: (x - y) % y = x % y
-- Int.dvd_sub_of_emod_eq
theorem dvd_sub_of_emod_eq {a b c : Int} (h : a % b = c) : b ∣ a - c 
Arguments: {a b c : Int} (h : a % b = c)
Goal: b ∣ a - c
-- Int.ediv_mul_cancel
protected theorem ediv_mul_cancel {a b : Int} (H : b ∣ a) : a / b * b = a 
Arguments: {a b : Int} (H : b ∣ a)
Goal: a / b * b = a
-- Int.mul_ediv_cancel'
protected theorem mul_ediv_cancel' {a b : Int} (H : a ∣ b) : a * (b / a) = b 
Arguments: {a b : Int} (H : a ∣ b)
Goal: a * (b / a) = b
-- Int.eq_mul_of_ediv_eq_right
protected theorem eq_mul_of_ediv_eq_right {a b c : Int}
    (H1 : b ∣ a) (H2 : a / b = c) : a = b * c 
Arguments: {a b c : Int} (H1 : b ∣ a) (H2 : a / b = c)
Goal: a = b * c
-- Int.ediv_eq_iff_eq_mul_right
protected theorem ediv_eq_iff_eq_mul_right {a b c : Int}
    (H : b ≠ 0) (H' : b ∣ a) : a / b = c ↔ a = b * c 
Arguments: {a b c : Int} (H : b ≠ 0) (H' : b ∣ a)
Goal: a / b = c ↔ a = b * c
-- Int.ediv_eq_iff_eq_mul_left
protected theorem ediv_eq_iff_eq_mul_left {a b c : Int}
    (H : b ≠ 0) (H' : b ∣ a) : a / b = c ↔ a = c * b 
Arguments: {a b c : Int} (H : b ≠ 0) (H' : b ∣ a)
Goal: a / b = c ↔ a = c * b
-- Int.eq_mul_of_ediv_eq_left
protected theorem eq_mul_of_ediv_eq_left {a b c : Int}
    (H1 : b ∣ a) (H2 : a / b = c) : a = c * b 
Arguments: {a b c : Int} (H1 : b ∣ a) (H2 : a / b = c)
Goal: a = c * b
-- Int.eq_zero_of_ediv_eq_zero
protected theorem eq_zero_of_ediv_eq_zero {d n : Int} (h : d ∣ n) (H : n / d = 0) : n = 0 
Arguments: {d n : Int} (h : d ∣ n) (H : n / d = 0)
Goal: n = 0
-- Int.sub_ediv_of_dvd_sub
theorem sub_ediv_of_dvd_sub {a b c : Int}
    (hcab : c ∣ a - b) : (a - b) / c = a / c - b / c 
Arguments: {a b c : Int} (hcab : c ∣ a - b)
Goal: (a - b) / c = a / c - b / c
-- Int.ediv_left_inj
@[simp] protected theorem ediv_left_inj {a b d : Int}
    (hda : d ∣ a) (hdb : d ∣ b) : a / d = b / d ↔ a = b 
Arguments: {a b d : Int} (hda : d ∣ a) (hdb : d ∣ b)
Goal: a / d = b / d ↔ a = b
-- Int.ediv_sign
theorem ediv_sign : ∀ a b, a / sign b = a * sign b
  
Arguments: (a b : Int)
Goal: a / b.sign = a * b.sign
-- Int.ediv_mul_le
protected theorem ediv_mul_le (a : Int) {b : Int} (H : b ≠ 0) : a / b * b ≤ a 
Arguments: (a : Int) {b : Int} (H : b ≠ 0)
Goal: a / b * b ≤ a
-- Int.le_of_mul_le_mul_left
theorem le_of_mul_le_mul_left {a b c : Int} (w : a * b ≤ a * c) (h : 0 < a) : b ≤ c 
Arguments: {a b c : Int} (w : a * b ≤ a * c) (h : 0 < a)
Goal: b ≤ c
-- Int.le_of_mul_le_mul_right
theorem le_of_mul_le_mul_right {a b c : Int} (w : b * a ≤ c * a) (h : 0 < a) : b ≤ c 
Arguments: {a b c : Int} (w : b * a ≤ c * a) (h : 0 < a)
Goal: b ≤ c
-- Int.ediv_le_of_le_mul
protected theorem ediv_le_of_le_mul {a b c : Int} (H : 0 < c) (H' : a ≤ b * c) : a / c ≤ b 
Arguments: {a b c : Int} (H : 0 < c) (H' : a ≤ b * c)
Goal: a / c ≤ b
-- Int.mul_lt_of_lt_ediv
protected theorem mul_lt_of_lt_ediv {a b c : Int} (H : 0 < c) (H3 : a < b / c) : a * c < b 
Arguments: {a b c : Int} (H : 0 < c) (H3 : a < b / c)
Goal: a * c < b
-- Int.mul_le_of_le_ediv
protected theorem mul_le_of_le_ediv {a b c : Int} (H1 : 0 < c) (H2 : a ≤ b / c) : a * c ≤ b 
Arguments: {a b c : Int} (H1 : 0 < c) (H2 : a ≤ b / c)
Goal: a * c ≤ b
-- Int.ediv_lt_of_lt_mul
protected theorem ediv_lt_of_lt_mul {a b c : Int} (H : 0 < c) (H' : a < b * c) : a / c < b 
Arguments: {a b c : Int} (H : 0 < c) (H' : a < b * c)
Goal: a / c < b
-- Int.lt_of_mul_lt_mul_left
theorem lt_of_mul_lt_mul_left {a b c : Int} (w : a * b < a * c) (h : 0 ≤ a) : b < c 
Arguments: {a b c : Int} (w : a * b < a * c) (h : 0 ≤ a)
Goal: b < c
-- Int.lt_of_mul_lt_mul_right
theorem lt_of_mul_lt_mul_right {a b c : Int} (w : b * a < c * a) (h : 0 ≤ a) : b < c 
Arguments: {a b c : Int} (w : b * a < c * a) (h : 0 ≤ a)
Goal: b < c
-- Int.le_ediv_of_mul_le
protected theorem le_ediv_of_mul_le {a b c : Int} (H1 : 0 < c) (H2 : a * c ≤ b) : a ≤ b / c 
Arguments: {a b c : Int} (H1 : 0 < c) (H2 : a * c ≤ b)
Goal: a ≤ b / c
-- Int.le_ediv_iff_mul_le
protected theorem le_ediv_iff_mul_le {a b c : Int} (H : 0 < c) : a ≤ b / c ↔ a * c ≤ b 
Arguments: {a b c : Int} (H : 0 < c)
Goal: a ≤ b / c ↔ a * c ≤ b
-- Int.ediv_le_ediv
protected theorem ediv_le_ediv {a b c : Int} (H : 0 < c) (H' : a ≤ b) : a / c ≤ b / c 
Arguments: {a b c : Int} (H : 0 < c) (H' : a ≤ b)
Goal: a / c ≤ b / c
-- Int.lt_mul_of_ediv_lt
protected theorem lt_mul_of_ediv_lt {a b c : Int} (H1 : 0 < c) (H2 : a / c < b) : a < b * c 
Arguments: {a b c : Int} (H1 : 0 < c) (H2 : a / c < b)
Goal: a < b * c
-- Int.ediv_lt_iff_lt_mul
protected theorem ediv_lt_iff_lt_mul {a b c : Int} (H : 0 < c) : a / c < b ↔ a < b * c 
Arguments: {a b c : Int} (H : 0 < c)
Goal: a / c < b ↔ a < b * c
-- Int.le_mul_of_ediv_le
protected theorem le_mul_of_ediv_le {a b c : Int} (H1 : 0 ≤ b) (H2 : b ∣ a) (H3 : a / b ≤ c) :
    a ≤ c * b 
Arguments: {a b c : Int} (H1 : 0 ≤ b) (H2 : b ∣ a) (H3 : a / b ≤ c)
Goal: a ≤ c * b
-- Int.lt_ediv_of_mul_lt
protected theorem lt_ediv_of_mul_lt {a b c : Int} (H1 : 0 ≤ b) (H2 : b ∣ c) (H3 : a * b < c) :
    a < c / b 
Arguments: {a b c : Int} (H1 : 0 ≤ b) (H2 : b ∣ c) (H3 : a * b < c)
Goal: a < c / b
-- Int.lt_ediv_iff_mul_lt
protected theorem lt_ediv_iff_mul_lt {a b : Int} (c : Int) (H : 0 < c) (H' : c ∣ b) :
    a < b / c ↔ a * c < b 
Arguments: {a b : Int} (c : Int) (H : 0 < c) (H' : c ∣ b)
Goal: a < b / c ↔ a * c < b
-- Int.ediv_pos_of_pos_of_dvd
theorem ediv_pos_of_pos_of_dvd {a b : Int} (H1 : 0 < a) (H2 : 0 ≤ b) (H3 : b ∣ a) : 0 < a / b 
Arguments: {a b : Int} (H1 : 0 < a) (H2 : 0 ≤ b) (H3 : b ∣ a)
Goal: 0 < a / b
-- Int.ediv_eq_ediv_of_mul_eq_mul
theorem ediv_eq_ediv_of_mul_eq_mul {a b c d : Int}
    (H2 : d ∣ c) (H3 : b ≠ 0) (H4 : d ≠ 0) (H5 : a * d = b * c) : a / b = c / d 
Arguments: {a b c d : Int} (H2 : d ∣ c) (H3 : b ≠ 0) (H4 : d ≠ 0) (H5 : a * d = b * c)
Goal: a / b = c / d
-- Int.div_one
@[simp] protected theorem div_one : ∀ a : Int, a.div 1 = a
  
Arguments: (a : Int)
Goal: a.div 1 = a
-- Int.div_neg
@[simp] protected theorem div_neg : ∀ a b : Int, a.div (-b) = -(a.div b)
  
Arguments: (a b : Int)
Goal: a.div (-b) = -a.div b
-- Int.neg_div
@[simp] protected theorem neg_div : ∀ a b : Int, (-a).div b = -(a.div b)
  
Arguments: (a b : Int)
Goal: (-a).div b = -a.div b
-- Int.neg_div_neg
protected theorem neg_div_neg (a b : Int) : (-a).div (-b) = a.div b 
Arguments: (a b : Int)
Goal: (-a).div (-b) = a.div b
-- Int.div_nonneg
protected theorem div_nonneg {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : 0 ≤ a.div b 
Arguments: {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b)
Goal: 0 ≤ a.div b
-- Int.div_nonpos
protected theorem div_nonpos {a b : Int} (Ha : 0 ≤ a) (Hb : b ≤ 0) : a.div b ≤ 0 
Arguments: {a b : Int} (Ha : 0 ≤ a) (Hb : b ≤ 0)
Goal: a.div b ≤ 0
-- Int.div_eq_zero_of_lt
theorem div_eq_zero_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a.div b = 0 
Arguments: {a b : Int} (H1 : 0 ≤ a) (H2 : a < b)
Goal: a.div b = 0
-- Int.mul_div_cancel
@[simp] protected theorem mul_div_cancel (a : Int) {b : Int} (H : b ≠ 0) : (a * b).div b = a 
Arguments: (a : Int) {b : Int} (H : b ≠ 0)
Goal: (a * b).div b = a
-- Int.mul_div_cancel_left
@[simp] protected theorem mul_div_cancel_left (b : Int) (H : a ≠ 0) : (a * b).div a = b 
Arguments: {a : Int} (b : Int) (H : a ≠ 0)
Goal: (a * b).div a = b
-- Int.div_self
@[simp] protected theorem div_self {a : Int} (H : a ≠ 0) : a.div a = 1 
Arguments: {a : Int} (H : a ≠ 0)
Goal: a.div a = 1
-- Int.mul_div_cancel_of_mod_eq_zero
theorem mul_div_cancel_of_mod_eq_zero {a b : Int} (H : a.mod b = 0) : b * (a.div b) = a 
Arguments: {a b : Int} (H : a.mod b = 0)
Goal: b * a.div b = a
-- Int.div_mul_cancel_of_mod_eq_zero
theorem div_mul_cancel_of_mod_eq_zero {a b : Int} (H : a.mod b = 0) : a.div b * b = a 
Arguments: {a b : Int} (H : a.mod b = 0)
Goal: a.div b * b = a
-- Int.dvd_of_mod_eq_zero
theorem dvd_of_mod_eq_zero {a b : Int} (H : mod b a = 0) : a ∣ b 
Arguments: {a b : Int} (H : b.mod a = 0)
Goal: a ∣ b
-- Int.mul_div_assoc
protected theorem mul_div_assoc (a : Int) : ∀ {b c : Int}, c ∣ b → (a * b).div c = a * (b.div c)
  
Arguments: (a : Int) {b c : Int}
Goal: c ∣ b → (a * b).div c = a * b.div c
-- Int.mul_div_assoc'
protected theorem mul_div_assoc' (b : Int) {a c : Int} (h : c ∣ a) :
    (a * b).div c = a.div c * b 
Arguments: (b : Int) {a c : Int} (h : c ∣ a)
Goal: (a * b).div c = a.div c * b
-- Int.div_dvd_div
theorem div_dvd_div : ∀ {a b c : Int}, a ∣ b → b ∣ c → b.div a ∣ c.div a
  
Arguments: {a b c : Int}
Goal: a ∣ b → b ∣ c → b.div a ∣ c.div a
-- Int.natAbs_div
@[simp] theorem natAbs_div (a b : Int) : natAbs (a.div b) = (natAbs a).div (natAbs b) 
Arguments: (a b : Int)
Goal: (a.div b).natAbs = a.natAbs.div b.natAbs
-- Int.div_eq_of_eq_mul_right
protected theorem div_eq_of_eq_mul_right {a b c : Int}
    (H1 : b ≠ 0) (H2 : a = b * c) : a.div b = c 
Arguments: {a b c : Int} (H1 : b ≠ 0) (H2 : a = b * c)
Goal: a.div b = c
-- Int.eq_div_of_mul_eq_right
protected theorem eq_div_of_mul_eq_right {a b c : Int}
    (H1 : a ≠ 0) (H2 : a * b = c) : b = c.div a 
Arguments: {a b c : Int} (H1 : a ≠ 0) (H2 : a * b = c)
Goal: b = c.div a
-- Int.ofNat_mod
theorem ofNat_mod (m n : Nat) : (↑(m % n) : Int) = mod m n 
Arguments: (m n : Nat)
Goal: ↑(m % n) = (↑m).mod ↑n
-- Int.mod_one
@[simp] theorem mod_one (a : Int) : mod a 1 = 0 
Arguments: (a : Int)
Goal: a.mod 1 = 0
-- Int.mod_eq_of_lt
theorem mod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : mod a b = a 
Arguments: {a b : Int} (H1 : 0 ≤ a) (H2 : a < b)
Goal: a.mod b = a
-- Int.mod_lt_of_pos
theorem mod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : mod a b < b 
Arguments: (a : Int) {b : Int} (H : 0 < b)
Goal: a.mod b < b
-- Int.mod_nonneg
theorem mod_nonneg : ∀ {a : Int} (b : Int), 0 ≤ a → 0 ≤ mod a b
  
Arguments: {a : Int} (b : Int)
Goal: 0 ≤ a → 0 ≤ a.mod b
-- Int.mod_neg
@[simp] theorem mod_neg (a b : Int) : mod a (-b) = mod a b 
Arguments: (a b : Int)
Goal: a.mod (-b) = a.mod b
-- Int.mul_mod_left
@[simp] theorem mul_mod_left (a b : Int) : (a * b).mod b = 0 
Arguments: (a b : Int)
Goal: (a * b).mod b = 0
-- Int.mul_mod_right
@[simp] theorem mul_mod_right (a b : Int) : (a * b).mod a = 0 
Arguments: (a b : Int)
Goal: (a * b).mod a = 0
-- Int.mod_eq_zero_of_dvd
theorem mod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → mod b a = 0
  
Arguments: {a b : Int}
Goal: a ∣ b → b.mod a = 0
-- Int.dvd_iff_mod_eq_zero
theorem dvd_iff_mod_eq_zero (a b : Int) : a ∣ b ↔ mod b a = 0 
Arguments: (a b : Int)
Goal: a ∣ b ↔ b.mod a = 0
-- Int.div_mul_cancel
protected theorem div_mul_cancel {a b : Int} (H : b ∣ a) : a.div b * b = a 
Arguments: {a b : Int} (H : b ∣ a)
Goal: a.div b * b = a
-- Int.mul_div_cancel'
protected theorem mul_div_cancel' {a b : Int} (H : a ∣ b) : a * b.div a = b 
Arguments: {a b : Int} (H : a ∣ b)
Goal: a * b.div a = b
-- Int.eq_mul_of_div_eq_right
protected theorem eq_mul_of_div_eq_right {a b c : Int}
    (H1 : b ∣ a) (H2 : a.div b = c) : a = b * c 
Arguments: {a b c : Int} (H1 : b ∣ a) (H2 : a.div b = c)
Goal: a = b * c
-- Int.mod_self
@[simp] theorem mod_self {a : Int} : a.mod a = 0 
Arguments: {a : Int}
Goal: a.mod a = 0
-- Int.lt_div_add_one_mul_self
theorem lt_div_add_one_mul_self (a : Int) {b : Int} (H : 0 < b) : a < (a.div b + 1) * b 
Arguments: (a : Int) {b : Int} (H : 0 < b)
Goal: a < (a.div b + 1) * b
-- Int.div_eq_iff_eq_mul_right
protected theorem div_eq_iff_eq_mul_right {a b c : Int}
    (H : b ≠ 0) (H' : b ∣ a) : a.div b = c ↔ a = b * c 
Arguments: {a b c : Int} (H : b ≠ 0) (H' : b ∣ a)
Goal: a.div b = c ↔ a = b * c
-- Int.div_eq_iff_eq_mul_left
protected theorem div_eq_iff_eq_mul_left {a b c : Int}
    (H : b ≠ 0) (H' : b ∣ a) : a.div b = c ↔ a = c * b 
Arguments: {a b c : Int} (H : b ≠ 0) (H' : b ∣ a)
Goal: a.div b = c ↔ a = c * b
-- Int.eq_mul_of_div_eq_left
protected theorem eq_mul_of_div_eq_left {a b c : Int}
    (H1 : b ∣ a) (H2 : a.div b = c) : a = c * b 
Arguments: {a b c : Int} (H1 : b ∣ a) (H2 : a.div b = c)
Goal: a = c * b
-- Int.div_eq_of_eq_mul_left
protected theorem div_eq_of_eq_mul_left {a b c : Int}
    (H1 : b ≠ 0) (H2 : a = c * b) : a.div b = c 
Arguments: {a b c : Int} (H1 : b ≠ 0) (H2 : a = c * b)
Goal: a.div b = c
-- Int.eq_zero_of_div_eq_zero
protected theorem eq_zero_of_div_eq_zero {d n : Int} (h : d ∣ n) (H : n.div d = 0) : n = 0 
Arguments: {d n : Int} (h : d ∣ n) (H : n.div d = 0)
Goal: n = 0