ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.mul_mod_mul_right
theorem mul_mod_mul_right (z x y : Nat) : (x * z) % (y * z) = (x % y) * z 
Arguments: (z x y : Nat)
Goal: x * z % (y * z) = x % y * z
-- Nat.sub_mul_mod
theorem sub_mul_mod {x k n : Nat} (h₁ : n*k ≤ x) : (x - n*k) % n = x % n 
Arguments: {x k n : Nat} (h₁ : n * k ≤ x)
Goal: (x - n * k) % n = x % n
-- Nat.mod_mod
@[simp] theorem mod_mod (a n : Nat) : (a % n) % n = a % n 
Arguments: (a n : Nat)
Goal: a % n % n = a % n
-- Nat.mul_mod
theorem mul_mod (a b n : Nat) : a * b % n = (a % n) * (b % n) % n 
Arguments: (a b n : Nat)
Goal: a * b % n = a % n * (b % n) % n
-- Nat.mod_add_mod
@[simp] theorem mod_add_mod (m n k : Nat) : (m % n + k) % n = (m + k) % n 
Arguments: (m n k : Nat)
Goal: (m % n + k) % n = (m + k) % n
-- Nat.add_mod_mod
@[simp] theorem add_mod_mod (m n k : Nat) : (m + n % k) % k = (m + n) % k 
Arguments: (m n k : Nat)
Goal: (m + n % k) % k = (m + n) % k
-- Nat.add_mod
theorem add_mod (a b n : Nat) : (a + b) % n = ((a % n) + (b % n)) % n 
Arguments: (a b n : Nat)
Goal: (a + b) % n = (a % n + b % n) % n
-- Nat.pow_succ'
theorem pow_succ' {m n : Nat} : m ^ n.succ = m * m ^ n 
Arguments: {m n : Nat}
Goal: m ^ n.succ = m * m ^ n
-- Nat.pow_add_one'
theorem pow_add_one' {m n : Nat} : m ^ (n + 1) = m * m ^ n 
Arguments: {m n : Nat}
Goal: m ^ (n + 1) = m * m ^ n
-- Nat.pow_eq
@[simp] theorem pow_eq {m n : Nat} : m.pow n = m ^ n 
Arguments: {m n : Nat}
Goal: m.pow n = m ^ n
-- Nat.one_shiftLeft
theorem one_shiftLeft (n : Nat) : 1 <<< n = 2 ^ n 
Arguments: (n : Nat)
Goal: 1 <<< n = 2 ^ n
-- Nat.zero_pow
protected theorem zero_pow {n : Nat} (H : 0 < n) : 0 ^ n = 0 
Arguments: {n : Nat} (H : 0 < n)
Goal: 0 ^ n = 0
-- Nat.one_pow
@[simp] protected theorem one_pow (n : Nat) : 1 ^ n = 1 
Arguments: (n : Nat)
Goal: 1 ^ n = 1
-- Nat.pow_one
@[simp] protected theorem pow_one (a : Nat) : a ^ 1 = a 
Arguments: (a : Nat)
Goal: a ^ 1 = a
-- Nat.pow_two
protected theorem pow_two (a : Nat) : a ^ 2 = a * a 
Arguments: (a : Nat)
Goal: a ^ 2 = a * a
-- Nat.pow_add
protected theorem pow_add (a m n : Nat) : a ^ (m + n) = a ^ m * a ^ n 
Arguments: (a m n : Nat)
Goal: a ^ (m + n) = a ^ m * a ^ n
-- Nat.pow_add'
protected theorem pow_add' (a m n : Nat) : a ^ (m + n) = a ^ n * a ^ m 
Arguments: (a m n : Nat)
Goal: a ^ (m + n) = a ^ n * a ^ m
-- Nat.pow_mul
protected theorem pow_mul (a m n : Nat) : a ^ (m * n) = (a ^ m) ^ n 
Arguments: (a m n : Nat)
Goal: a ^ (m * n) = (a ^ m) ^ n
-- Nat.pow_mul'
protected theorem pow_mul' (a m n : Nat) : a ^ (m * n) = (a ^ n) ^ m 
Arguments: (a m n : Nat)
Goal: a ^ (m * n) = (a ^ n) ^ m
-- Nat.pow_right_comm
protected theorem pow_right_comm (a m n : Nat) : (a ^ m) ^ n = (a ^ n) ^ m 
Arguments: (a m n : Nat)
Goal: (a ^ m) ^ n = (a ^ n) ^ m
-- Nat.mul_pow
protected theorem mul_pow (a b n : Nat) : (a * b) ^ n = a ^ n * b ^ n 
Arguments: (a b n : Nat)
Goal: (a * b) ^ n = a ^ n * b ^ n
-- Nat.one_lt_two_pow
protected theorem one_lt_two_pow (h : n ≠ 0) : 1 < 2 ^ n 
Arguments: {n : Nat} (h : n ≠ 0)
Goal: 1 < 2 ^ n
-- Nat.one_lt_two_pow_iff
@[simp] protected theorem one_lt_two_pow_iff : 1 < 2 ^ n ↔ n ≠ 0 
Arguments: {n : Nat}
Goal: 1 < 2 ^ n ↔ n ≠ 0
-- Nat.one_le_two_pow
protected theorem one_le_two_pow : 1 ≤ 2 ^ n 
Arguments: {n : Nat}
Goal: 1 ≤ 2 ^ n
-- Nat.pow_pos
protected theorem pow_pos (h : 0 < a) : 0 < a^n 
Arguments: {a n : Nat} (h : 0 < a)
Goal: 0 < a ^ n
-- Nat.pow_lt_pow_succ
protected theorem pow_lt_pow_succ (h : 1 < a) : a ^ n < a ^ (n + 1) 
Arguments: {a n : Nat} (h : 1 < a)
Goal: a ^ n < a ^ (n + 1)
-- Nat.pow_lt_pow_of_lt
protected theorem pow_lt_pow_of_lt {a n m : Nat} (h : 1 < a) (w : n < m) : a ^ n < a ^ m 
Arguments: {a n m : Nat} (h : 1 < a) (w : n < m)
Goal: a ^ n < a ^ m
-- Nat.pow_le_pow_of_le
protected theorem pow_le_pow_of_le {a n m : Nat} (h : 1 < a) (w : n ≤ m) : a ^ n ≤ a ^ m 
Arguments: {a n m : Nat} (h : 1 < a) (w : n ≤ m)
Goal: a ^ n ≤ a ^ m
-- Nat.pow_le_pow_iff_right
protected theorem pow_le_pow_iff_right {a n m : Nat} (h : 1 < a) :
    a ^ n ≤ a ^ m ↔ n ≤ m 
Arguments: {a n m : Nat} (h : 1 < a)
Goal: a ^ n ≤ a ^ m ↔ n ≤ m
-- Nat.pow_lt_pow_iff_right
protected theorem pow_lt_pow_iff_right {a n m : Nat} (h : 1 < a) :
    a ^ n < a ^ m ↔ n < m 
Arguments: {a n m : Nat} (h : 1 < a)
Goal: a ^ n < a ^ m ↔ n < m
-- Nat.log2_zero
@[simp]
theorem log2_zero : Nat.log2 0 = 0 
Goal: Nat.log2 0 = 0
-- Nat.le_log2
theorem le_log2 (h : n ≠ 0) : k ≤ n.log2 ↔ 2 ^ k ≤ n 
Arguments: {n k : Nat} (h : n ≠ 0)
Goal: k ≤ n.log2 ↔ 2 ^ k ≤ n
-- Nat.log2_lt
theorem log2_lt (h : n ≠ 0) : n.log2 < k ↔ n < 2 ^ k 
Arguments: {n k : Nat} (h : n ≠ 0)
Goal: n.log2 < k ↔ n < 2 ^ k
-- Nat.log2_self_le
theorem log2_self_le (h : n ≠ 0) : 2 ^ n.log2 ≤ n 
Arguments: {n : Nat} (h : n ≠ 0)
Goal: 2 ^ n.log2 ≤ n
-- Nat.lt_log2_self
theorem lt_log2_self : n < 2 ^ (n.log2 + 1) 
Arguments: {n : Nat}
Goal: n < 2 ^ (n.log2 + 1)
-- Nat.eq_mul_of_div_eq_right
protected theorem eq_mul_of_div_eq_right {a b c : Nat} (H1 : b ∣ a) (H2 : a / b = c) :
    a = b * c 
Arguments: {a b c : Nat} (H1 : b ∣ a) (H2 : a / b = c)
Goal: a = b * c
-- Nat.div_eq_iff_eq_mul_right
protected theorem div_eq_iff_eq_mul_right {a b c : Nat} (H : 0 < b) (H' : b ∣ a) :
    a / b = c ↔ a = b * c 
Arguments: {a b c : Nat} (H : 0 < b) (H' : b ∣ a)
Goal: a / b = c ↔ a = b * c
-- Nat.div_eq_iff_eq_mul_left
protected theorem div_eq_iff_eq_mul_left {a b c : Nat} (H : 0 < b) (H' : b ∣ a) :
    a / b = c ↔ a = c * b 
Arguments: {a b c : Nat} (H : 0 < b) (H' : b ∣ a)
Goal: a / b = c ↔ a = c * b
-- Nat.pow_dvd_pow_iff_pow_le_pow
theorem pow_dvd_pow_iff_pow_le_pow {k l : Nat} :
    ∀ {x : Nat}, 0 < x → (x ^ k ∣ x ^ l ↔ x ^ k ≤ x ^ l)
  
Arguments: {k l x : Nat}
Goal: 0 < x → (x ^ k ∣ x ^ l ↔ x ^ k ≤ x ^ l)
-- Nat.pow_dvd_pow_iff_le_right
theorem pow_dvd_pow_iff_le_right {x k l : Nat} (w : 1 < x) : x ^ k ∣ x ^ l ↔ k ≤ l 
Arguments: {x k l : Nat} (w : 1 < x)
Goal: x ^ k ∣ x ^ l ↔ k ≤ l
-- Nat.pow_dvd_pow_iff_le_right'
theorem pow_dvd_pow_iff_le_right' {b k l : Nat} : (b + 2) ^ k ∣ (b + 2) ^ l ↔ k ≤ l 
Arguments: {b k l : Nat}
Goal: (b + 2) ^ k ∣ (b + 2) ^ l ↔ k ≤ l
-- Nat.pow_dvd_pow
protected theorem pow_dvd_pow {m n : Nat} (a : Nat) (h : m ≤ n) : a ^ m ∣ a ^ n 
Arguments: {m n : Nat} (a : Nat) (h : m ≤ n)
Goal: a ^ m ∣ a ^ n
-- Nat.pow_sub_mul_pow
protected theorem pow_sub_mul_pow (a : Nat) {m n : Nat} (h : m ≤ n) :
    a ^ (n - m) * a ^ m = a ^ n 
Arguments: (a : Nat) {m n : Nat} (h : m ≤ n)
Goal: a ^ (n - m) * a ^ m = a ^ n
-- Nat.pow_dvd_of_le_of_pow_dvd
theorem pow_dvd_of_le_of_pow_dvd {p m n k : Nat} (hmn : m ≤ n) (hdiv : p ^ n ∣ k) : p ^ m ∣ k 
Arguments: {p m n k : Nat} (hmn : m ≤ n) (hdiv : p ^ n ∣ k)
Goal: p ^ m ∣ k
-- Nat.dvd_of_pow_dvd
theorem dvd_of_pow_dvd {p k m : Nat} (hk : 1 ≤ k) (hpk : p ^ k ∣ m) : p ∣ m 
Arguments: {p k m : Nat} (hk : 1 ≤ k) (hpk : p ^ k ∣ m)
Goal: p ∣ m
-- Nat.pow_div
protected theorem pow_div {x m n : Nat} (h : n ≤ m) (hx : 0 < x) : x ^ m / x ^ n = x ^ (m - n) 
Arguments: {x m n : Nat} (h : n ≤ m) (hx : 0 < x)
Goal: x ^ m / x ^ n = x ^ (m - n)
-- Nat.shiftLeft_zero
@[simp] theorem shiftLeft_zero : n <<< 0 = n 
Arguments: {n : Nat}
Goal: n <<< 0 = n
-- Nat.shiftLeft_succ_inside
theorem shiftLeft_succ_inside (m n : Nat) : m <<< (n+1) = (2*m) <<< n 
Arguments: (m n : Nat)
Goal: m <<< (n + 1) = (2 * m) <<< n
-- Nat.shiftLeft_succ
theorem shiftLeft_succ : ∀(m n), m <<< (n + 1) = 2 * (m <<< n)

Arguments: (m n : Nat)
Goal: m <<< (n + 1) = 2 * m <<< n
-- Nat.shiftRight_succ_inside
theorem shiftRight_succ_inside : ∀m n, m >>> (n+1) = (m/2) >>> n

Arguments: (m n : Nat)
Goal: m >>> (n + 1) = (m / 2) >>> n
-- Nat.zero_shiftLeft
@[simp] theorem zero_shiftLeft : ∀ n, 0 <<< n = 0
  
Arguments: (n : Nat)
Goal: 0 <<< n = 0
-- Nat.zero_shiftRight
@[simp] theorem zero_shiftRight : ∀ n, 0 >>> n = 0
  
Arguments: (n : Nat)
Goal: 0 >>> n = 0
-- Nat.shiftLeft_add
theorem shiftLeft_add (m n : Nat) : ∀ k, m <<< (n + k) = (m <<< n) <<< k
  
Arguments: (m n k : Nat)
Goal: m <<< (n + k) = m <<< n <<< k
-- Nat.shiftLeft_shiftLeft
@[deprecated shiftLeft_add (since := "2024-06-02")]
theorem shiftLeft_shiftLeft (m n : Nat) : ∀ k, (m <<< n) <<< k = m <<< (n + k)
  
Arguments: (m n k : Nat)
Goal: m <<< n <<< k = m <<< (n + k)
-- Nat.shiftLeft_shiftRight
@[simp] theorem shiftLeft_shiftRight (x n : Nat) : x <<< n >>> n = x 
Arguments: (x n : Nat)
Goal: x <<< n >>> n = x
-- Nat.mul_add_div
theorem mul_add_div {m : Nat} (m_pos : m > 0) (x y : Nat) : (m * x + y) / m = x + y / m 
Arguments: {m : Nat} (m_pos : m > 0) (x y : Nat)
Goal: (m * x + y) / m = x + y / m
-- Nat.mul_add_mod
theorem mul_add_mod (m x y : Nat) : (m * x + y) % m = y % m 
Arguments: (m x y : Nat)
Goal: (m * x + y) % m = y % m
-- Nat.mod_div_self
@[simp] theorem mod_div_self (m n : Nat) : m % n / n = 0 
Arguments: (m n : Nat)
Goal: m % n / n = 0
-- BitVec.iunfoldr.fst_eq
theorem iunfoldr.fst_eq
    {f : Fin w → α → α × Bool} (state : Nat → α) (s : α)
    (init : s = state 0)
    (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
    (iunfoldr f s).fst = state w 
Arguments: {w : Nat} {α : Type u_1} {f : Fin w → α → α × Bool} (state : Nat → α) (s : α) (init : s = state 0) (ind : ∀ (i : Fin w), (f i (state ↑i)).fst = state (↑i + 1))
Goal: (BitVec.iunfoldr f s).fst = state w
-- _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Folds.0.BitVec.iunfoldr.eq_test
private theorem iunfoldr.eq_test
    {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
    (init : state 0 = a)
    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
    iunfoldr f a = (state w, BitVec.truncate w value) 
Arguments: {w : Nat} {α : Type u_1} {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α) (init : state 0 = a) (step : ∀ (i : Fin w), f i (state ↑i) = (state (↑i + 1), value.getLsb ↑i))
Goal: BitVec.iunfoldr f a = (state w, BitVec.truncate w value)
-- BitVec.iunfoldr_getLsb'
theorem iunfoldr_getLsb' {f : Fin w → α → α × Bool} (state : Nat → α)
    (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
  (∀ i : Fin w, getLsb (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd)
  ∧ (iunfoldr f (state 0)).fst = state w 
Arguments: {w : Nat} {α : Type u_1} {f : Fin w → α → α × Bool} (state : Nat → α) (ind : ∀ (i : Fin w), (f i (state ↑i)).fst = state (↑i + 1))
Goal: (∀ (i : Fin w), (BitVec.iunfoldr f (state 0)).snd.getLsb ↑i = (f i (state ↑i)).snd) ∧
  (BitVec.iunfoldr f (state 0)).fst = state w
-- BitVec.iunfoldr_getLsb
theorem iunfoldr_getLsb {f : Fin w → α → α × Bool} (state : Nat → α) (i : Fin w)
    (ind : ∀(i : Fin w), (f i (state i.val)).fst = state (i.val+1)) :
  getLsb (iunfoldr f (state 0)).snd i.val = (f i (state i.val)).snd 
Arguments: {w : Nat} {α : Type u_1} {f : Fin w → α → α × Bool} (state : Nat → α) (i : Fin w) (ind : ∀ (i : Fin w), (f i (state ↑i)).fst = state (↑i + 1))
Goal: (BitVec.iunfoldr f (state 0)).snd.getLsb ↑i = (f i (state ↑i)).snd
-- BitVec.iunfoldr_replace
theorem iunfoldr_replace
    {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
    (init : state 0 = a)
    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
    iunfoldr f a = (state w, value) 
Arguments: {w : Nat} {α : Type u_1} {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α) (init : state 0 = a) (step : ∀ (i : Fin w), f i (state ↑i) = (state (↑i + 1), value.getLsb ↑i))
Goal: BitVec.iunfoldr f a = (state w, value)
-- BitVec.iunfoldr_replace_snd
theorem iunfoldr_replace_snd
  {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)
    (init : state 0 = a)
    (step : ∀(i : Fin w), f i (state i.val) = (state (i.val+1), value.getLsb i.val)) :
    (iunfoldr f a).snd = value 
Arguments: {w : Nat} {α : Type u_1} {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α) (init : state 0 = a) (step : ∀ (i : Fin w), f i (state ↑i) = (state (↑i + 1), value.getLsb ↑i))
Goal: (BitVec.iunfoldr f a).snd = value
-- BitVec.isLt
theorem isLt (x : BitVec w) : x.toNat < 2^w 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.toNat < 2 ^ w
-- BitVec.toNat_lt
@[deprecated isLt (since := "2024-03-12")]
theorem toNat_lt (x : BitVec n) : x.toNat < 2^n 
Arguments: {n : Nat} (x : BitVec n)
Goal: x.toNat < 2 ^ n
-- BitVec.ofNat_eq_ofNat
-- TODO: This needs more usage data to assess which direction the simp should go.
@[simp, bv_toNat] theorem ofNat_eq_ofNat : @OfNat.ofNat (BitVec n) i _ = .ofNat n i 
Arguments: {n i : Nat}
Goal: OfNat.ofNat i = BitVec.ofNat n i
-- BitVec.natCast_eq_ofNat
@[simp] theorem natCast_eq_ofNat (w x : Nat) : @Nat.cast (BitVec w) _ x = .ofNat w x 
Arguments: (w x : Nat)
Goal: ↑x = BitVec.ofNat w x
-- BitVec.eq_nil
theorem eq_nil (x : BitVec 0) : x = nil 
Arguments: (x : BitVec 0)
Goal: x = BitVec.nil
-- BitVec.ofBool_false
@[simp] theorem ofBool_false : ofBool false = 0 
Goal: BitVec.ofBool false = 0
-- BitVec.ofBool_true
@[simp] theorem ofBool_true  : ofBool true  = 1 
Goal: BitVec.ofBool true = 1
-- BitVec.cast_ofNat
@[simp] theorem cast_ofNat {n m : Nat} (h : n = m) (x : Nat) :
    cast h (BitVec.ofNat n x) = BitVec.ofNat m x 
Arguments: {n m : Nat} (h : n = m) (x : Nat)
Goal: BitVec.cast h (BitVec.ofNat n x) = BitVec.ofNat m x
-- BitVec.cast_cast
@[simp] theorem cast_cast {n m k : Nat} (h₁ : n = m) (h₂ : m = k) (x : BitVec n) :
    cast h₂ (cast h₁ x) = cast (h₁ ▸ h₂) x 
Arguments: {n m k : Nat} (h₁ : n = m) (h₂ : m = k) (x : BitVec n)
Goal: BitVec.cast h₂ (BitVec.cast h₁ x) = BitVec.cast ⋯ x
-- BitVec.cast_eq
@[simp] theorem cast_eq {n : Nat} (h : n = n) (x : BitVec n) : cast h x = x 
Arguments: {n : Nat} (h : n = n) (x : BitVec n)
Goal: BitVec.cast h x = x
-- BitVec.append_ofBool
theorem append_ofBool (msbs : BitVec w) (lsb : Bool) :
    msbs ++ ofBool lsb = concat msbs lsb 
Arguments: {w : Nat} (msbs : BitVec w) (lsb : Bool)
Goal: msbs ++ BitVec.ofBool lsb = msbs.concat lsb
-- BitVec.ofBool_append
theorem ofBool_append (msb : Bool) (lsbs : BitVec w) :
    ofBool msb ++ lsbs = (cons msb lsbs).cast (Nat.add_comm ..) 
Arguments: {w : Nat} (msb : Bool) (lsbs : BitVec w)
Goal: BitVec.ofBool msb ++ lsbs = BitVec.cast ⋯ (BitVec.cons msb lsbs)
-- BitVec.append_eq
@[simp] theorem append_eq (x : BitVec w) (y : BitVec v)   : BitVec.append x y = x ++ y        
Arguments: {w v : Nat} (x : BitVec w) (y : BitVec v)
Goal: x.append y = x ++ y
-- BitVec.shiftLeft_eq
@[simp] theorem shiftLeft_eq (x : BitVec w) (n : Nat)     : BitVec.shiftLeft x n = x <<< n    
Arguments: {w : Nat} (x : BitVec w) (n : Nat)
Goal: x.shiftLeft n = x <<< n
-- BitVec.ushiftRight_eq
@[simp] theorem ushiftRight_eq (x : BitVec w) (n : Nat)   : BitVec.ushiftRight x n = x >>> n  
Arguments: {w : Nat} (x : BitVec w) (n : Nat)
Goal: x.ushiftRight n = x >>> n
-- BitVec.not_eq
@[simp] theorem not_eq (x : BitVec w)                     : BitVec.not x = ~~~x               
Arguments: {w : Nat} (x : BitVec w)
Goal: x.not = ~~~x
-- BitVec.and_eq
@[simp] theorem and_eq (x y : BitVec w)                   : BitVec.and x y = x &&& y          
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.and y = x &&& y
-- BitVec.or_eq
@[simp] theorem or_eq (x y : BitVec w)                    : BitVec.or x y = x ||| y           
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.or y = x ||| y
-- BitVec.xor_eq
@[simp] theorem xor_eq (x y : BitVec w)                   : BitVec.xor x y = x ^^^ y          
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.xor y = x ^^^ y
-- BitVec.neg_eq
@[simp] theorem neg_eq (x : BitVec w)                     : BitVec.neg x = -x                 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.neg = -x
-- BitVec.add_eq
@[simp] theorem add_eq (x y : BitVec w)                   : BitVec.add x y = x + y            
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.add y = x + y
-- BitVec.sub_eq
@[simp] theorem sub_eq (x y : BitVec w)                   : BitVec.sub x y = x - y            
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.sub y = x - y
-- BitVec.mul_eq
@[simp] theorem mul_eq (x y : BitVec w)                   : BitVec.mul x y = x * y            
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.mul y = x * y
-- BitVec.zero_eq
@[simp] theorem zero_eq                                   : BitVec.zero n = 0#n               
Arguments: {n : Nat}
Goal: BitVec.zero n = 0#n
-- Array.size_mkArray
@[simp] theorem size_mkArray (n : Nat) (v : α) : (mkArray n v).size = n 
Arguments: {α : Type u} (n : Nat) (v : α)
Goal: (mkArray n v).size = n
-- Array.size_set
@[simp] theorem size_set (a : Array α) (i : Fin a.size) (v : α) : (set a i v).size = a.size 
Arguments: {α : Type u} (a : Array α) (i : Fin a.size) (v : α)
Goal: (a.set i v).size = a.size
-- Array.size_push
@[simp] theorem size_push (a : Array α) (v : α) : (push a v).size = a.size + 1 
Arguments: {α : Type u} (a : Array α) (v : α)
Goal: (a.push v).size = a.size + 1
-- Array.ext.extAux
theorem ext (a b : Array α)
    (h₁ : a.size = b.size)
    (h₂ : (i : Nat) → (hi₁ : i < a.size) → (hi₂ : i < b.size) → a[i] = b[i])
    : a = b 
Arguments: {α : Type u_1} (a b : List α) (h₁ : a.length = b.length) (h₂ : ∀ (i : Nat) (hi₁ : i < a.length) (hi₂ : i < b.length), a.get ⟨i, hi₁⟩ = b.get ⟨i, hi₂⟩)
Goal: a = b
-- Array.ext
theorem ext (a b : Array α)
    (h₁ : a.size = b.size)
    (h₂ : (i : Nat) → (hi₁ : i < a.size) → (hi₂ : i < b.size) → a[i] = b[i])
    : a = b 
Arguments: {α : Type u_1} (a b : Array α) (h₁ : a.size = b.size) (h₂ : ∀ (i : Nat) (hi₁ : i < a.size) (hi₂ : i < b.size), getElem a i hi₁ = getElem b i hi₂)
Goal: a = b
-- Array.extLit
theorem extLit {n : Nat}
    (a b : Array α)
    (hsz₁ : a.size = n) (hsz₂ : b.size = n)
    (h : (i : Nat) → (hi : i < n) → a.getLit i hsz₁ hi = b.getLit i hsz₂ hi) : a = b 
Arguments: {α : Type u_1} {n : Nat} (a b : Array α) (hsz₁ : a.size = n) (hsz₂ : b.size = n) (h : ∀ (i : Nat) (hi : i < n), a.getLit i hsz₁ hi = b.getLit i hsz₂ hi)
Goal: a = b
-- Array.size_swap
@[simp] theorem size_swap (a : Array α) (i j : Fin a.size) : (a.swap i j).size = a.size 
Arguments: {α : Type u_1} (a : Array α) (i j : Fin a.size)
Goal: (a.swap i j).size = a.size
-- Array.size_pop
@[simp] theorem size_pop (a : Array α) : a.pop.size = a.size - 1 
Arguments: {α : Type u_1} (a : Array α)
Goal: a.pop.size = a.size - 1
-- Array.reverse.termination
theorem reverse.termination {i j : Nat} (h : i < j) : j - 1 - (i + 1) < j - i 
Arguments: {i j : Nat} (h : i < j)
Goal: j - 1 - (i + 1) < j - i
-- Array.size_feraseIdx
theorem size_feraseIdx (a : Array α) (i : Fin a.size) : (a.feraseIdx i).size = a.size - 1 
Arguments: {α : Type u_1} (a : Array α) (i : Fin a.size)
Goal: (a.feraseIdx i).size = a.size - 1
-- Array.ext'
theorem ext' {as bs : Array α} (h : as.data = bs.data) : as = bs 
Arguments: {α : Type u_1} {as bs : Array α} (h : as.data = bs.data)
Goal: as = bs
-- Array.toArrayAux_eq
@[simp] theorem toArrayAux_eq (as : List α) (acc : Array α) : (as.toArrayAux acc).data = acc.data ++ as 
Arguments: {α : Type u_1} (as : List α) (acc : Array α)
Goal: (as.toArrayAux acc).data = acc.data ++ as
-- Array.data_toArray
theorem data_toArray (as : List α) : as.toArray.data = as 
Arguments: {α : Type u_1} (as : List α)
Goal: (List.toArray as).data = as
-- Array.toArrayLit_eq.go
theorem toArrayLit_eq (as : Array α) (n : Nat) (hsz : as.size = n) : as = toArrayLit as n hsz 
Arguments: {α : Type u_1} (as : Array α) (n : Nat) (hsz : as.size = n) (i : Nat) (hi : i ≤ as.size)
Goal: as.toListLitAux n hsz i hi (List.drop i as.data) = as.data
-- Array.toArrayLit_eq.getLit_eq
theorem toArrayLit_eq (as : Array α) (n : Nat) (hsz : as.size = n) : as = toArrayLit as n hsz 
Arguments: {α : Type u_1} (n : Nat) (as : Array α) (i : Nat) (h₁ : as.size = n) (h₂ : i < n)
Goal: as.getLit i h₁ h₂ = getElem as.data i ⋯
-- Array.toArrayLit_eq
theorem toArrayLit_eq (as : Array α) (n : Nat) (hsz : as.size = n) : as = toArrayLit as n hsz 
Arguments: {α : Type u_1} (as : Array α) (n : Nat) (hsz : as.size = n)
Goal: as = as.toArrayLit n hsz
-- String.length_utf8EncodeChar
@[simp] theorem length_utf8EncodeChar (c : Char) : (utf8EncodeChar c).length = c.utf8Size 
Arguments: (c : Char)
Goal: (String.utf8EncodeChar c).length = c.utf8Size
-- String.size_toUTF8
@[simp] theorem size_toUTF8 (s : String) : s.toUTF8.size = s.utf8ByteSize 
Arguments: (s : String)
Goal: s.toUTF8.size = s.utf8ByteSize
-- String.Iterator.sizeOf_next_lt_of_hasNext
theorem Iterator.sizeOf_next_lt_of_hasNext (i : String.Iterator) (h : i.hasNext) : sizeOf i.next < sizeOf i 
Arguments: (i : String.Iterator) (h : i.hasNext = true)
Goal: sizeOf i.next < sizeOf i
-- String.Iterator.sizeOf_next_lt_of_atEnd
theorem Iterator.sizeOf_next_lt_of_atEnd (i : String.Iterator) (h : ¬ i.atEnd = true) : sizeOf i.next < sizeOf i 
Arguments: (i : String.Iterator) (h : ¬i.atEnd = true)
Goal: sizeOf i.next < sizeOf i
-- Bool.atLeastTwo_false_left
@[simp] theorem atLeastTwo_false_left  : atLeastTwo false b c = (b && c) 
Arguments: {b c : Bool}
Goal: false.atLeastTwo b c = (b && c)
-- Bool.atLeastTwo_false_mid
@[simp] theorem atLeastTwo_false_mid   : atLeastTwo a false c = (a && c) 
Arguments: {a c : Bool}
Goal: a.atLeastTwo false c = (a && c)
-- Bool.atLeastTwo_false_right
@[simp] theorem atLeastTwo_false_right : atLeastTwo a b false = (a && b) 
Arguments: {a b : Bool}
Goal: a.atLeastTwo b false = (a && b)
-- Bool.atLeastTwo_true_left
@[simp] theorem atLeastTwo_true_left   : atLeastTwo true b c  = (b || c) 
Arguments: {b c : Bool}
Goal: true.atLeastTwo b c = (b || c)
-- Bool.atLeastTwo_true_mid
@[simp] theorem atLeastTwo_true_mid    : atLeastTwo a true c  = (a || c) 
Arguments: {a c : Bool}
Goal: a.atLeastTwo true c = (a || c)
-- Bool.atLeastTwo_true_right
@[simp] theorem atLeastTwo_true_right  : atLeastTwo a b true  = (a || b) 
Arguments: {a b : Bool}
Goal: a.atLeastTwo b true = (a || b)
-- _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Bitblast.0.BitVec.testBit_limit
private theorem testBit_limit {x i : Nat} (x_lt_succ : x < 2^(i+1)) :
    testBit x i = decide (x ≥ 2^i) 
Arguments: {x i : Nat} (x_lt_succ : x < 2 ^ (i + 1))
Goal: x.testBit i = decide (x ≥ 2 ^ i)
-- _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Bitblast.0.BitVec.mod_two_pow_succ
private theorem mod_two_pow_succ (x i : Nat) :
    x % 2^(i+1) = 2^i*(x.testBit i).toNat + x % (2 ^ i)
Arguments: (x i : Nat)
Goal: x % 2 ^ (i + 1) = 2 ^ i * (x.testBit i).toNat + x % 2 ^ i
-- _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Bitblast.0.BitVec.mod_two_pow_add_mod_two_pow_add_bool_lt_two_pow_succ
private theorem mod_two_pow_add_mod_two_pow_add_bool_lt_two_pow_succ
     (x y i : Nat) (c : Bool) : x % 2^i + (y % 2^i + c.toNat) < 2^(i+1) 
Arguments: (x y i : Nat) (c : Bool)
Goal: x % 2 ^ i + (y % 2 ^ i + c.toNat) < 2 ^ (i + 1)
-- BitVec.carry_zero
@[simp] theorem carry_zero : carry 0 x y c = c 
Goal: ∀ {w : Nat} {x y : BitVec w} {c : Bool}, BitVec.carry 0 x y c = c
-- BitVec.carry_succ
theorem carry_succ (i : Nat) (x y : BitVec w) (c : Bool) :
    carry (i+1) x y c = atLeastTwo (x.getLsb i) (y.getLsb i) (carry i x y c) 
Arguments: {w : Nat} (i : Nat) (x y : BitVec w) (c : Bool)
Goal: BitVec.carry (i + 1) x y c = (x.getLsb i).atLeastTwo (y.getLsb i) (BitVec.carry i x y c)
-- BitVec.getLsb_add_add_bool
theorem getLsb_add_add_bool {i : Nat} (i_lt : i < w) (x y : BitVec w) (c : Bool) :
    getLsb (x + y + zeroExtend w (ofBool c)) i =
      Bool.xor (getLsb x i) (Bool.xor (getLsb y i) (carry i x y c)) 
Arguments: {w i : Nat} (i_lt : i < w) (x y : BitVec w) (c : Bool)
Goal: (x + y + BitVec.zeroExtend w (BitVec.ofBool c)).getLsb i = (x.getLsb i).xor ((y.getLsb i).xor (BitVec.carry i x y c))
-- BitVec.getLsb_add
theorem getLsb_add {i : Nat} (i_lt : i < w) (x y : BitVec w) :
    getLsb (x + y) i =
      Bool.xor (getLsb x i) (Bool.xor (getLsb y i) (carry i x y false)) 
Arguments: {w i : Nat} (i_lt : i < w) (x y : BitVec w)
Goal: (x + y).getLsb i = (x.getLsb i).xor ((y.getLsb i).xor (BitVec.carry i x y false))
-- BitVec.adc_spec
theorem adc_spec (x y : BitVec w) (c : Bool) :
    adc x y c = (carry w x y c, x + y + zeroExtend w (ofBool c)) 
Arguments: {w : Nat} (x y : BitVec w) (c : Bool)
Goal: x.adc y c = (BitVec.carry w x y c, x + y + BitVec.zeroExtend w (BitVec.ofBool c))
-- BitVec.add_eq_adc
theorem add_eq_adc (w : Nat) (x y : BitVec w) : x + y = (adc x y false).snd 
Arguments: (w : Nat) (x y : BitVec w)
Goal: x + y = (x.adc y false).snd
-- BitVec.add_not_self
@[simp] theorem add_not_self (x : BitVec w) : x + ~~~x = allOnes w 
Arguments: {w : Nat} (x : BitVec w)
Goal: x + ~~~x = BitVec.allOnes w