ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.div_left_inj
@[simp] protected theorem div_left_inj {a b d : Int}
    (hda : d ∣ a) (hdb : d ∣ b) : a.div d = b.div d ↔ a = b 
Arguments: {a b d : Int} (hda : d ∣ a) (hdb : d ∣ b)
Goal: a.div d = b.div d ↔ a = b
-- Int.div_sign
theorem div_sign : ∀ a b, a.div (sign b) = a * sign b
  
Arguments: (a b : Int)
Goal: a.div b.sign = a * b.sign
-- Int.sign_eq_div_abs
protected theorem sign_eq_div_abs (a : Int) : sign a = a.div (natAbs a) 
Arguments: (a : Int)
Goal: a.sign = a.div ↑a.natAbs
-- Int.fdiv_nonneg
theorem fdiv_nonneg {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b) : 0 ≤ a.fdiv b 
Arguments: {a b : Int} (Ha : 0 ≤ a) (Hb : 0 ≤ b)
Goal: 0 ≤ a.fdiv b
-- Int.fdiv_nonpos
theorem fdiv_nonpos : ∀ {a b : Int}, 0 ≤ a → b ≤ 0 → a.fdiv b ≤ 0
  
Arguments: {a b : Int}
Goal: 0 ≤ a → b ≤ 0 → a.fdiv b ≤ 0
-- Int.fdiv_neg'
theorem fdiv_neg' : ∀ {a b : Int}, a < 0 → 0 < b → a.fdiv b < 0
  
Arguments: {a b : Int}
Goal: a < 0 → 0 < b → a.fdiv b < 0
-- Int.fdiv_one
@[simp] theorem fdiv_one : ∀ a : Int, a.fdiv 1 = a
  
Arguments: (a : Int)
Goal: a.fdiv 1 = a
-- Int.mul_fdiv_cancel
@[simp] theorem mul_fdiv_cancel (a : Int) {b : Int} (H : b ≠ 0) : fdiv (a * b) b = a 
Arguments: (a : Int) {b : Int} (H : b ≠ 0)
Goal: (a * b).fdiv b = a
-- Int.mul_fdiv_cancel_left
@[simp] theorem mul_fdiv_cancel_left (b : Int) (H : a ≠ 0) : fdiv (a * b) a = b 
Arguments: {a : Int} (b : Int) (H : a ≠ 0)
Goal: (a * b).fdiv a = b
-- Int.fdiv_self
@[simp] protected theorem fdiv_self {a : Int} (H : a ≠ 0) : a.fdiv a = 1 
Arguments: {a : Int} (H : a ≠ 0)
Goal: a.fdiv a = 1
-- Int.lt_fdiv_add_one_mul_self
theorem lt_fdiv_add_one_mul_self (a : Int) {b : Int} (H : 0 < b) : a < (a.fdiv b + 1) * b 
Arguments: (a : Int) {b : Int} (H : 0 < b)
Goal: a < (a.fdiv b + 1) * b
-- Int.ofNat_fmod
theorem ofNat_fmod (m n : Nat) : ↑(m % n) = fmod m n 
Arguments: (m n : Nat)
Goal: ↑(m % n) = (↑m).fmod ↑n
-- Int.fmod_one
@[simp] theorem fmod_one (a : Int) : a.fmod 1 = 0 
Arguments: (a : Int)
Goal: a.fmod 1 = 0
-- Int.fmod_eq_of_lt
theorem fmod_eq_of_lt {a b : Int} (H1 : 0 ≤ a) (H2 : a < b) : a.fmod b = a 
Arguments: {a b : Int} (H1 : 0 ≤ a) (H2 : a < b)
Goal: a.fmod b = a
-- Int.fmod_nonneg
theorem fmod_nonneg {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a.fmod b 
Arguments: {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: 0 ≤ a.fmod b
-- Int.fmod_nonneg'
theorem fmod_nonneg' (a : Int) {b : Int} (hb : 0 < b) : 0 ≤ a.fmod b 
Arguments: (a : Int) {b : Int} (hb : 0 < b)
Goal: 0 ≤ a.fmod b
-- Int.fmod_lt_of_pos
theorem fmod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : a.fmod b < b 
Arguments: (a : Int) {b : Int} (H : 0 < b)
Goal: a.fmod b < b
-- Int.mul_fmod_left
@[simp] theorem mul_fmod_left (a b : Int) : (a * b).fmod b = 0 
Arguments: (a b : Int)
Goal: (a * b).fmod b = 0
-- Int.mul_fmod_right
@[simp] theorem mul_fmod_right (a b : Int) : (a * b).fmod a = 0 
Arguments: (a b : Int)
Goal: (a * b).fmod a = 0
-- Int.fmod_self
@[simp] theorem fmod_self {a : Int} : a.fmod a = 0 
Arguments: {a : Int}
Goal: a.fmod a = 0
-- Int.div_eq_ediv_of_dvd
theorem div_eq_ediv_of_dvd {a b : Int} (h : b ∣ a) : a.div b = a / b 
Arguments: {a b : Int} (h : b ∣ a)
Goal: a.div b = a / b
-- Int.fdiv_eq_ediv_of_dvd
theorem fdiv_eq_ediv_of_dvd : ∀ {a b : Int}, b ∣ a → a.fdiv b = a / b
  
Arguments: {a b : Int}
Goal: b ∣ a → a.fdiv b = a / b
-- Int.bmod_emod
@[simp] theorem bmod_emod : bmod x m % m = x % m 
Arguments: {x : Int} {m : Nat}
Goal: x.bmod m % ↑m = x % ↑m
-- Int.emod_bmod_congr
@[simp]
theorem emod_bmod_congr (x : Int) (n : Nat) : Int.bmod (x%n) n = Int.bmod x n 
Arguments: (x : Int) (n : Nat)
Goal: (x % ↑n).bmod n = x.bmod n
-- Int.bmod_def
theorem bmod_def (x : Int) (m : Nat) : bmod x m =
  if (x % m) < (m + 1) / 2 then
    x % m
  else
    (x % m) - m 
Arguments: (x : Int) (m : Nat)
Goal: x.bmod m = if x % ↑m < (↑m + 1) / 2 then x % ↑m else x % ↑m - ↑m
-- Int.bmod_pos
theorem bmod_pos (x : Int) (m : Nat) (p : x % m < (m + 1) / 2) : bmod x m = x % m 
Arguments: (x : Int) (m : Nat) (p : x % ↑m < (↑m + 1) / 2)
Goal: x.bmod m = x % ↑m
-- Int.bmod_neg
theorem bmod_neg (x : Int) (m : Nat) (p : x % m ≥ (m + 1) / 2) : bmod x m = (x % m) - m 
Arguments: (x : Int) (m : Nat) (p : x % ↑m ≥ (↑m + 1) / 2)
Goal: x.bmod m = x % ↑m - ↑m
-- Int.bmod_one_is_zero
@[simp]
theorem bmod_one_is_zero (x : Int) : Int.bmod x 1 = 0 
Arguments: (x : Int)
Goal: x.bmod 1 = 0
-- Int.bmod_add_cancel
@[simp]
theorem bmod_add_cancel (x : Int) (n : Nat) : Int.bmod (x + n) n = Int.bmod x n 
Arguments: (x : Int) (n : Nat)
Goal: (x + ↑n).bmod n = x.bmod n
-- Int.bmod_add_mul_cancel
@[simp]
theorem bmod_add_mul_cancel (x : Int) (n : Nat) (k : Int) : Int.bmod (x + n * k) n = Int.bmod x n 
Arguments: (x : Int) (n : Nat) (k : Int)
Goal: (x + ↑n * k).bmod n = x.bmod n
-- Int.bmod_sub_cancel
@[simp]
theorem bmod_sub_cancel (x : Int) (n : Nat) : Int.bmod (x - n) n = Int.bmod x n 
Arguments: (x : Int) (n : Nat)
Goal: (x - ↑n).bmod n = x.bmod n
-- Int.emod_add_bmod_congr
@[simp]
theorem emod_add_bmod_congr (x : Int) (n : Nat) : Int.bmod (x%n + y) n = Int.bmod (x + y) n 
Arguments: {y : Int} (x : Int) (n : Nat)
Goal: (x % ↑n + y).bmod n = (x + y).bmod n
-- Int.emod_mul_bmod_congr
@[simp]
theorem emod_mul_bmod_congr (x : Int) (n : Nat) : Int.bmod (x%n * y) n = Int.bmod (x * y) n 
Arguments: {y : Int} (x : Int) (n : Nat)
Goal: (x % ↑n * y).bmod n = (x * y).bmod n
-- Int.bmod_add_bmod_congr
@[simp]
theorem bmod_add_bmod_congr : Int.bmod (Int.bmod x n + y) n = Int.bmod (x + y) n 
Arguments: {x : Int} {n : Nat} {y : Int}
Goal: (x.bmod n + y).bmod n = (x + y).bmod n
-- Int.add_bmod_bmod
@[simp] theorem add_bmod_bmod : Int.bmod (x + Int.bmod y n) n = Int.bmod (x + y) n 
Arguments: {x y : Int} {n : Nat}
Goal: (x + y.bmod n).bmod n = (x + y).bmod n
-- Int.bmod_mul_bmod
@[simp]
theorem bmod_mul_bmod : Int.bmod (Int.bmod x n * y) n = Int.bmod (x * y) n 
Arguments: {x : Int} {n : Nat} {y : Int}
Goal: (x.bmod n * y).bmod n = (x * y).bmod n
-- Int.mul_bmod_bmod
@[simp] theorem mul_bmod_bmod : Int.bmod (x * Int.bmod y n) n = Int.bmod (x * y) n 
Arguments: {x y : Int} {n : Nat}
Goal: (x * y.bmod n).bmod n = (x * y).bmod n
-- Int.add_bmod
theorem add_bmod (a b : Int) (n : Nat) : (a + b).bmod n = (a.bmod n + b.bmod n).bmod n 
Arguments: (a b : Int) (n : Nat)
Goal: (a + b).bmod n = (a.bmod n + b.bmod n).bmod n
-- Int.emod_bmod
theorem emod_bmod {x : Int} {m : Nat} : bmod (x % m) m = bmod x m 
Arguments: {x : Int} {m : Nat}
Goal: (x % ↑m).bmod m = x.bmod m
-- Int.bmod_bmod
@[simp] theorem bmod_bmod : bmod (bmod x m) m = bmod x m 
Arguments: {x : Int} {m : Nat}
Goal: (x.bmod m).bmod m = x.bmod m
-- Int.bmod_zero
@[simp] theorem bmod_zero : Int.bmod 0 m = 0 
Arguments: {m : Nat}
Goal: Int.bmod 0 m = 0
-- Int.dvd_bmod_sub_self
theorem dvd_bmod_sub_self {x : Int} {m : Nat} : (m : Int) ∣ bmod x m - x 
Arguments: {x : Int} {m : Nat}
Goal: ↑m ∣ x.bmod m - x
-- Int.le_bmod
theorem le_bmod {x : Int} {m : Nat} (h : 0 < m) : - (m/2) ≤ Int.bmod x m 
Arguments: {x : Int} {m : Nat} (h : 0 < m)
Goal: -(↑m / 2) ≤ x.bmod m
-- Int.bmod_lt
theorem bmod_lt {x : Int} {m : Nat} (h : 0 < m) : bmod x m < (m + 1) / 2 
Arguments: {x : Int} {m : Nat} (h : 0 < m)
Goal: x.bmod m < (↑m + 1) / 2
-- Int.bmod_le
theorem bmod_le {x : Int} {m : Nat} (h : 0 < m) : bmod x m ≤ (m - 1) / 2 
Arguments: {x : Int} {m : Nat} (h : 0 < m)
Goal: x.bmod m ≤ (↑m - 1) / 2
-- Int.bmod_natAbs_plus_one
theorem bmod_natAbs_plus_one (x : Int) (w : 1 < x.natAbs) : bmod x (x.natAbs + 1) = - x.sign 
Arguments: (x : Int) (w : 1 < x.natAbs)
Goal: x.bmod (x.natAbs + 1) = -x.sign
-- Char.le_def
theorem le_def {a b : Char} : a ≤ b ↔ a.1 ≤ b.1 
Arguments: {a b : Char}
Goal: a ≤ b ↔ a.val ≤ b.val
-- Char.lt_def
theorem lt_def {a b : Char} : a < b ↔ a.1 < b.1 
Arguments: {a b : Char}
Goal: a < b ↔ a.val < b.val
-- Char.lt_iff_val_lt_val
theorem lt_iff_val_lt_val {a b : Char} : a < b ↔ a.val < b.val 
Arguments: {a b : Char}
Goal: a < b ↔ a.val < b.val
-- Char.not_le
@[simp] protected theorem not_le {a b : Char} : ¬ a ≤ b ↔ b < a 
Arguments: {a b : Char}
Goal: ¬a ≤ b ↔ b < a
-- Char.not_lt
@[simp] protected theorem not_lt {a b : Char} : ¬ a < b ↔ b ≤ a 
Arguments: {a b : Char}
Goal: ¬a < b ↔ b ≤ a
-- Char.le_refl
@[simp] protected theorem le_refl (a : Char) : a ≤ a 
Arguments: (a : Char)
Goal: a ≤ a
-- Char.lt_irrefl
@[simp] protected theorem lt_irrefl (a : Char) : ¬ a < a 
Arguments: (a : Char)
Goal: ¬a < a
-- Char.le_trans
protected theorem le_trans {a b c : Char} : a ≤ b → b ≤ c → a ≤ c 
Arguments: {a b c : Char}
Goal: a ≤ b → b ≤ c → a ≤ c
-- Char.lt_trans
protected theorem lt_trans {a b c : Char} : a < b → b < c → a < c 
Arguments: {a b c : Char}
Goal: a < b → b < c → a < c
-- Char.le_total
protected theorem le_total (a b : Char) : a ≤ b ∨ b ≤ a 
Arguments: (a b : Char)
Goal: a ≤ b ∨ b ≤ a
-- Char.lt_asymm
protected theorem lt_asymm {a b : Char} (h : a < b) : ¬ b < a 
Arguments: {a b : Char} (h : a < b)
Goal: ¬b < a
-- Char.ne_of_lt
protected theorem ne_of_lt {a b : Char} (h : a < b) : a ≠ b 
Arguments: {a b : Char} (h : a < b)
Goal: a ≠ b
-- Char.utf8Size_eq
theorem utf8Size_eq (c : Char) : c.utf8Size = 1 ∨ c.utf8Size = 2 ∨ c.utf8Size = 3 ∨ c.utf8Size = 4 
Arguments: (c : Char)
Goal: c.utf8Size = 1 ∨ c.utf8Size = 2 ∨ c.utf8Size = 3 ∨ c.utf8Size = 4
-- Char.ofNat_toNat
@[simp] theorem ofNat_toNat (c : Char) : Char.ofNat c.toNat = c 
Arguments: (c : Char)
Goal: Char.ofNat c.toNat = c
-- Char.Char.ext
@[ext] theorem Char.ext : {a b : Char} → a.val = b.val → a = b
  
Arguments: {a b : Char}
Goal: a.val = b.val → a = b
-- Char.Char.ext_iff
theorem Char.ext_iff {x y : Char} : x = y ↔ x.val = y.val 
Arguments: {x y : Char}
Goal: x = y ↔ x.val = y.val
-- String.data_eq_of_eq
protected theorem data_eq_of_eq {a b : String} (h : a = b) : a.data = b.data 
Arguments: {a b : String} (h : a = b)
Goal: a.data = b.data
-- String.ne_of_data_ne
protected theorem ne_of_data_ne {a b : String} (h : a.data ≠ b.data) : a ≠ b 
Arguments: {a b : String} (h : a.data ≠ b.data)
Goal: a ≠ b
-- String.lt_irrefl
@[simp] protected theorem lt_irrefl (s : String) : ¬ s < s 
Arguments: (s : String)
Goal: ¬s < s
-- String.ne_of_lt
protected theorem ne_of_lt {a b : String} (h : a < b) : a ≠ b 
Arguments: {a b : String} (h : a < b)
Goal: a ≠ b
-- Nat.div_rec_lemma
theorem div_rec_lemma {x y : Nat} : 0 < y ∧ y ≤ x → x - y < x 
Arguments: {x y : Nat}
Goal: 0 < y ∧ y ≤ x → x - y < x
-- Nat.div_eq
theorem div_eq (x y : Nat) : x / y = if 0 < y ∧ y ≤ x then (x - y) / y + 1 else 0 
Arguments: (x y : Nat)
Goal: x / y = ite (0 < y ∧ y ≤ x) ((x - y) / y + 1) 0
-- Nat.div_le_self
theorem div_le_self (n k : Nat) : n / k ≤ n 
Arguments: (n k : Nat)
Goal: n / k ≤ n
-- Nat.div_lt_self
theorem div_lt_self {n k : Nat} (hLtN : 0 < n) (hLtK : 1 < k) : n / k < n 
Arguments: {n k : Nat} (hLtN : 0 < n) (hLtK : 1 < k)
Goal: n / k < n
-- Nat.modCore_eq_mod
protected theorem modCore_eq_mod (n m : Nat) : Nat.modCore n m = n % m 
Arguments: (n m : Nat)
Goal: n.modCore m = n % m
-- Nat.mod_eq
theorem mod_eq (x y : Nat) : x % y = if 0 < y ∧ y ≤ x then (x - y) % y else x 
Arguments: (x y : Nat)
Goal: x % y = ite (0 < y ∧ y ≤ x) ((x - y) % y) x
-- Nat.mod_zero
@[simp] theorem mod_zero (a : Nat) : a % 0 = a 
Arguments: (a : Nat)
Goal: a % 0 = a
-- Nat.mod_eq_of_lt
theorem mod_eq_of_lt {a b : Nat} (h : a < b) : a % b = a 
Arguments: {a b : Nat} (h : a < b)
Goal: a % b = a
-- Nat.mod_eq_sub_mod
theorem mod_eq_sub_mod {a b : Nat} (h : a ≥ b) : a % b = (a - b) % b 
Arguments: {a b : Nat} (h : a ≥ b)
Goal: a % b = (a - b) % b
-- Nat.mod_lt
theorem mod_lt (x : Nat) {y : Nat} : y > 0 → x % y < y 
Arguments: (x : Nat) {y : Nat}
Goal: y > 0 → x % y < y
-- Nat.mod_le
theorem mod_le (x y : Nat) : x % y ≤ x 
Arguments: (x y : Nat)
Goal: x % y ≤ x
-- Nat.zero_mod
@[simp] theorem zero_mod (b : Nat) : 0 % b = 0 
Arguments: (b : Nat)
Goal: 0 % b = 0
-- Nat.mod_self
@[simp] theorem mod_self (n : Nat) : n % n = 0 
Arguments: (n : Nat)
Goal: n % n = 0
-- Nat.mod_one
theorem mod_one (x : Nat) : x % 1 = 0 
Arguments: (x : Nat)
Goal: x % 1 = 0
-- Nat.div_add_mod
theorem div_add_mod (m n : Nat) : n * (m / n) + m % n = m 
Arguments: (m n : Nat)
Goal: n * (m / n) + m % n = m
-- Nat.div_eq_sub_div
theorem div_eq_sub_div (h₁ : 0 < b) (h₂ : b ≤ a) : a / b = (a - b) / b + 1 
Arguments: {b a : Nat} (h₁ : 0 < b) (h₂ : b ≤ a)
Goal: a / b = (a - b) / b + 1
-- Nat.mod_add_div
theorem mod_add_div (m k : Nat) : m % k + k * (m / k) = m 
Arguments: (m k : Nat)
Goal: m % k + k * (m / k) = m
-- Nat.div_one
@[simp] protected theorem div_one (n : Nat) : n / 1 = n 
Arguments: (n : Nat)
Goal: n / 1 = n
-- Nat.div_zero
@[simp] protected theorem div_zero (n : Nat) : n / 0 = 0 
Arguments: (n : Nat)
Goal: n / 0 = 0
-- Nat.zero_div
@[simp] protected theorem zero_div (b : Nat) : 0 / b = 0 
Arguments: (b : Nat)
Goal: 0 / b = 0
-- Nat.le_div_iff_mul_le
theorem le_div_iff_mul_le (k0 : 0 < k) : x ≤ y / k ↔ x * k ≤ y 
Arguments: {k x y : Nat} (k0 : 0 < k)
Goal: x ≤ y / k ↔ x * k ≤ y
-- Nat.div_div_eq_div_mul
protected theorem div_div_eq_div_mul (m n k : Nat) : m / n / k = m / (n * k) 
Arguments: (m n k : Nat)
Goal: m / n / k = m / (n * k)
-- Nat.div_mul_le_self
theorem div_mul_le_self : ∀ (m n : Nat), m / n * n ≤ m
  
Arguments: (m n : Nat)
Goal: m / n * n ≤ m
-- Nat.div_lt_iff_lt_mul
theorem div_lt_iff_lt_mul (Hk : 0 < k) : x / k < y ↔ x < y * k 
Arguments: {k x y : Nat} (Hk : 0 < k)
Goal: x / k < y ↔ x < y * k
-- Nat.add_div_right
@[simp] theorem add_div_right (x : Nat) {z : Nat} (H : 0 < z) : (x + z) / z = (x / z) + 1 
Arguments: (x : Nat) {z : Nat} (H : 0 < z)
Goal: (x + z) / z = x / z + 1
-- Nat.add_div_left
@[simp] theorem add_div_left (x : Nat) {z : Nat} (H : 0 < z) : (z + x) / z = (x / z) + 1 
Arguments: (x : Nat) {z : Nat} (H : 0 < z)
Goal: (z + x) / z = x / z + 1
-- Nat.add_mul_div_left
theorem add_mul_div_left (x z : Nat) {y : Nat} (H : 0 < y) : (x + y * z) / y = x / y + z 
Arguments: (x z : Nat) {y : Nat} (H : 0 < y)
Goal: (x + y * z) / y = x / y + z
-- Nat.add_mul_div_right
theorem add_mul_div_right (x y : Nat) {z : Nat} (H : 0 < z) : (x + y * z) / z = x / z + y 
Arguments: (x y : Nat) {z : Nat} (H : 0 < z)
Goal: (x + y * z) / z = x / z + y
-- Nat.add_mod_right
@[simp] theorem add_mod_right (x z : Nat) : (x + z) % z = x % z 
Arguments: (x z : Nat)
Goal: (x + z) % z = x % z
-- Nat.add_mod_left
@[simp] theorem add_mod_left (x z : Nat) : (x + z) % x = z % x 
Arguments: (x z : Nat)
Goal: (x + z) % x = z % x
-- Nat.add_mul_mod_self_left
@[simp] theorem add_mul_mod_self_left (x y z : Nat) : (x + y * z) % y = x % y 
Arguments: (x y z : Nat)
Goal: (x + y * z) % y = x % y
-- Nat.add_mul_mod_self_right
@[simp] theorem add_mul_mod_self_right (x y z : Nat) : (x + y * z) % z = x % z 
Arguments: (x y z : Nat)
Goal: (x + y * z) % z = x % z
-- Nat.mul_mod_right
@[simp] theorem mul_mod_right (m n : Nat) : (m * n) % m = 0 
Arguments: (m n : Nat)
Goal: m * n % m = 0
-- Nat.mul_mod_left
@[simp] theorem mul_mod_left (m n : Nat) : (m * n) % n = 0 
Arguments: (m n : Nat)
Goal: m * n % n = 0
-- Nat.div_eq_of_lt_le
protected theorem div_eq_of_lt_le (lo : k * n ≤ m) (hi : m < (k + 1) * n) : m / n = k 
Arguments: {k n m : Nat} (lo : k * n ≤ m) (hi : m < (k + 1) * n)
Goal: m / n = k
-- Nat.sub_mul_div
theorem sub_mul_div (x n p : Nat) (h₁ : n*p ≤ x) : (x - n*p) / n = x / n - p 
Arguments: (x n p : Nat) (h₁ : n * p ≤ x)
Goal: (x - n * p) / n = x / n - p
-- Nat.mul_sub_div
theorem mul_sub_div (x n p : Nat) (h₁ : x < n*p) : (n * p - (x + 1)) / n = p - ((x / n) + 1) 
Arguments: (x n p : Nat) (h₁ : x < n * p)
Goal: (n * p - (x + 1)) / n = p - (x / n + 1)
-- Nat.mul_mod_mul_left
theorem mul_mod_mul_left (z x y : Nat) : (z * x) % (z * y) = z * (x % y) 
Arguments: (z x y : Nat)
Goal: z * x % (z * y) = z * (x % y)
-- Nat.div_eq_of_lt
theorem div_eq_of_lt (h₀ : a < b) : a / b = 0 
Arguments: {a b : Nat} (h₀ : a < b)
Goal: a / b = 0
-- Nat.mul_div_cancel
protected theorem mul_div_cancel (m : Nat) {n : Nat} (H : 0 < n) : m * n / n = m 
Arguments: (m : Nat) {n : Nat} (H : 0 < n)
Goal: m * n / n = m
-- Nat.mul_div_cancel_left
protected theorem mul_div_cancel_left (m : Nat) {n : Nat} (H : 0 < n) : n * m / n = m 
Arguments: (m : Nat) {n : Nat} (H : 0 < n)
Goal: n * m / n = m
-- Nat.div_le_of_le_mul
protected theorem div_le_of_le_mul {m n : Nat} : ∀ {k}, m ≤ k * n → m / k ≤ n
  
Arguments: {m n k : Nat}
Goal: m ≤ k * n → m / k ≤ n
-- Nat.mul_div_right
@[simp] theorem mul_div_right (n : Nat) {m : Nat} (H : 0 < m) : m * n / m = n 
Arguments: (n : Nat) {m : Nat} (H : 0 < m)
Goal: m * n / m = n
-- Nat.mul_div_left
@[simp] theorem mul_div_left (m : Nat) {n : Nat} (H : 0 < n) : m * n / n = m 
Arguments: (m : Nat) {n : Nat} (H : 0 < n)
Goal: m * n / n = m
-- Nat.div_self
protected theorem div_self (H : 0 < n) : n / n = 1 
Arguments: {n : Nat} (H : 0 < n)
Goal: n / n = 1
-- Nat.div_eq_of_eq_mul_left
protected theorem div_eq_of_eq_mul_left (H1 : 0 < n) (H2 : m = k * n) : m / n = k 
Arguments: {n m k : Nat} (H1 : 0 < n) (H2 : m = k * n)
Goal: m / n = k
-- Nat.div_eq_of_eq_mul_right
protected theorem div_eq_of_eq_mul_right (H1 : 0 < n) (H2 : m = n * k) : m / n = k 
Arguments: {n m k : Nat} (H1 : 0 < n) (H2 : m = n * k)
Goal: m / n = k
-- Nat.mul_div_mul_left
protected theorem mul_div_mul_left {m : Nat} (n k : Nat) (H : 0 < m) :
    m * n / (m * k) = n / k 
Arguments: {m : Nat} (n k : Nat) (H : 0 < m)
Goal: m * n / (m * k) = n / k
-- Nat.mul_div_mul_right
protected theorem mul_div_mul_right {m : Nat} (n k : Nat) (H : 0 < m) :
    n * m / (k * m) = n / k 
Arguments: {m : Nat} (n k : Nat) (H : 0 < m)
Goal: n * m / (k * m) = n / k
-- Nat.mul_div_le
theorem mul_div_le (m n : Nat) : n * (m / n) ≤ m 
Arguments: (m n : Nat)
Goal: n * (m / n) ≤ m
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.one_div_two
@[local simp]
private theorem one_div_two : 1/2 = 0 
Goal: 1 / 2 = 0
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.two_pow_succ_sub_succ_div_two
private theorem two_pow_succ_sub_succ_div_two : (2 ^ (n+1) - (x + 1)) / 2 = 2^n - (x/2 + 1) 
Arguments: {n x : Nat}
Goal: (2 ^ (n + 1) - (x + 1)) / 2 = 2 ^ n - (x / 2 + 1)
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.two_pow_succ_sub_one_div_two
private theorem two_pow_succ_sub_one_div_two : (2 ^ (n+1) - 1) / 2 = 2^n - 1 
Arguments: {n : Nat}
Goal: (2 ^ (n + 1) - 1) / 2 = 2 ^ n - 1
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.two_mul_sub_one
private theorem two_mul_sub_one {n : Nat} (n_pos : n > 0) : (2*n - 1) % 2 = 1 
Arguments: {n : Nat} (n_pos : n > 0)
Goal: (2 * n - 1) % 2 = 1
-- Nat.zero_and
@[simp] theorem zero_and (x : Nat) : 0 &&& x = 0 
Arguments: (x : Nat)
Goal: 0 &&& x = 0
-- Nat.and_zero
@[simp] theorem and_zero (x : Nat) : x &&& 0 = 0 
Arguments: (x : Nat)
Goal: x &&& 0 = 0
-- Nat.one_and_eq_mod_two
@[simp] theorem one_and_eq_mod_two (n : Nat) : 1 &&& n = n % 2 
Arguments: (n : Nat)
Goal: 1 &&& n = n % 2
-- Nat.and_one_is_mod
@[simp] theorem and_one_is_mod (x : Nat) : x &&& 1 = x % 2 
Arguments: (x : Nat)
Goal: x &&& 1 = x % 2
-- Nat.zero_testBit
@[simp] theorem zero_testBit (i : Nat) : testBit 0 i = false 
Arguments: (i : Nat)
Goal: Nat.testBit 0 i = false
-- Nat.testBit_zero
@[simp] theorem testBit_zero (x : Nat) : testBit x 0 = decide (x % 2 = 1) 
Arguments: (x : Nat)
Goal: x.testBit 0 = decide (x % 2 = 1)
-- Nat.testBit_succ
@[simp] theorem testBit_succ (x i : Nat) : testBit x (succ i) = testBit (x/2) i 
Arguments: (x i : Nat)
Goal: x.testBit i.succ = (x / 2).testBit i
-- Nat.testBit_add_one
@[simp] theorem testBit_add_one (x i : Nat) : testBit x (i + 1) = testBit (x/2) i 
Arguments: (x i : Nat)
Goal: x.testBit (i + 1) = (x / 2).testBit i
-- Nat.testBit_to_div_mod
theorem testBit_to_div_mod {x : Nat} : testBit x i = decide (x / 2^i % 2 = 1) 
Arguments: {i x : Nat}
Goal: x.testBit i = decide (x / 2 ^ i % 2 = 1)
-- Nat.toNat_testBit
theorem toNat_testBit (x i : Nat) :
    (x.testBit i).toNat = x / 2 ^ i % 2 
Arguments: (x i : Nat)
Goal: (x.testBit i).toNat = x / 2 ^ i % 2
-- Nat.ne_zero_implies_bit_true
theorem ne_zero_implies_bit_true {x : Nat} (xnz : x ≠ 0) : ∃ i, testBit x i 
Arguments: {x : Nat} (xnz : x ≠ 0)
Goal: ∃ i, x.testBit i = true
-- Nat.ne_implies_bit_diff
theorem ne_implies_bit_diff {x y : Nat} (p : x ≠ y) : ∃ i, testBit x i ≠ testBit y i 
Arguments: {x y : Nat} (p : x ≠ y)
Goal: ∃ i, x.testBit i ≠ y.testBit i
-- Nat.eq_of_testBit_eq
theorem eq_of_testBit_eq {x y : Nat} (pred : ∀i, testBit x i = testBit y i) : x = y 
Arguments: {x y : Nat} (pred : ∀ (i : Nat), x.testBit i = y.testBit i)
Goal: x = y
-- Nat.ge_two_pow_implies_high_bit_true
theorem ge_two_pow_implies_high_bit_true {x : Nat} (p : x ≥ 2^n) : ∃ i, i ≥ n ∧ testBit x i 
Arguments: {n x : Nat} (p : x ≥ 2 ^ n)
Goal: ∃ i, i ≥ n ∧ x.testBit i = true
-- Nat.testBit_implies_ge
theorem testBit_implies_ge {x : Nat} (p : testBit x i = true) : x ≥ 2^i 
Arguments: {i x : Nat} (p : x.testBit i = true)
Goal: x ≥ 2 ^ i
-- Nat.testBit_lt_two_pow
theorem testBit_lt_two_pow {x i : Nat} (lt : x < 2^i) : x.testBit i = false 
Arguments: {x i : Nat} (lt : x < 2 ^ i)
Goal: x.testBit i = false
-- Nat.lt_pow_two_of_testBit
theorem lt_pow_two_of_testBit (x : Nat) (p : ∀i, i ≥ n → testBit x i = false) : x < 2^n 
Arguments: {n : Nat} (x : Nat) (p : ∀ (i : Nat), i ≥ n → x.testBit i = false)
Goal: x < 2 ^ n
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.succ_mod_two
private theorem succ_mod_two : succ x % 2 = 1 - x % 2 
Arguments: {x : Nat}
Goal: x.succ % 2 = 1 - x % 2
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_succ_zero
private theorem testBit_succ_zero : testBit (x + 1) 0 = not (testBit x 0) 
Arguments: {x : Nat}
Goal: (x + 1).testBit 0 = !x.testBit 0
-- Nat.testBit_two_pow_add_eq
theorem testBit_two_pow_add_eq (x i : Nat) : testBit (2^i + x) i = not (testBit x i) 
Arguments: (x i : Nat)
Goal: (2 ^ i + x).testBit i = !x.testBit i
-- Nat.testBit_mul_two_pow_add_eq
theorem testBit_mul_two_pow_add_eq (a b i : Nat) :
    testBit (2^i*a + b) i = Bool.xor (a%2 = 1) (testBit b i) 
Arguments: (a b i : Nat)
Goal: (2 ^ i * a + b).testBit i = (decide (a % 2 = 1)).xor (b.testBit i)
-- Nat.testBit_two_pow_add_gt
theorem testBit_two_pow_add_gt {i j : Nat} (j_lt_i : j < i) (x : Nat) :
    testBit (2^i + x) j = testBit x j 
Arguments: {i j : Nat} (j_lt_i : j < i) (x : Nat)
Goal: (2 ^ i + x).testBit j = x.testBit j
-- Nat.testBit_mod_two_pow
@[simp] theorem testBit_mod_two_pow (x j i : Nat) :
    testBit (x % 2^j) i = (decide (i < j) && testBit x i) 
Arguments: (x j i : Nat)
Goal: (x % 2 ^ j).testBit i = (decide (i < j) && x.testBit i)
-- Nat.testBit_one_zero
theorem testBit_one_zero : testBit 1 0 = true 
Goal: Nat.testBit 1 0 = true
-- Nat.not_decide_mod_two_eq_one
theorem not_decide_mod_two_eq_one (x : Nat)
    : (!decide (x % 2 = 1)) = decide (x % 2 = 0) 
Arguments: (x : Nat)
Goal: (!decide (x % 2 = 1)) = decide (x % 2 = 0)
-- Nat.testBit_two_pow_sub_succ
theorem testBit_two_pow_sub_succ (h₂ : x < 2 ^ n) (i : Nat) :
    testBit (2^n - (x + 1)) i = (decide (i < n) && ! testBit x i) 
Arguments: {x n : Nat} (h₂ : x < 2 ^ n) (i : Nat)
Goal: (2 ^ n - (x + 1)).testBit i = (decide (i < n) && !x.testBit i)
-- Nat.testBit_two_pow_sub_one
@[simp] theorem testBit_two_pow_sub_one (n i : Nat) : testBit (2^n-1) i = decide (i < n) 
Arguments: (n i : Nat)
Goal: (2 ^ n - 1).testBit i = decide (i < n)
-- Nat.testBit_bool_to_nat
theorem testBit_bool_to_nat (b : Bool) (i : Nat) :
    testBit (Bool.toNat b) i = (decide (i = 0) && b) 
Arguments: (b : Bool) (i : Nat)
Goal: b.toNat.testBit i = (decide (i = 0) && b)
-- Nat.testBit_one_eq_true_iff_self_eq_zero
theorem testBit_one_eq_true_iff_self_eq_zero {i : Nat} :
    Nat.testBit 1 i = true ↔ i = 0 
Arguments: {i : Nat}
Goal: Nat.testBit 1 i = true ↔ i = 0
-- Nat.testBit_bitwise
theorem testBit_bitwise
  (false_false_axiom : f false false = false) (x y i : Nat)
: (bitwise f x y).testBit i = f (x.testBit i) (y.testBit i) 
Arguments: {f : Bool → Bool → Bool} (false_false_axiom : f false false = false) (x y i : Nat)
Goal: (Nat.bitwise f x y).testBit i = f (x.testBit i) (y.testBit i)
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.eq_0_of_lt_one
@[local simp]
private theorem eq_0_of_lt_one (x : Nat) : x < 1 ↔ x = 0 
Arguments: (x : Nat)
Goal: x < 1 ↔ x = 0