ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- BitVec.eq_of_toFin_eq
theorem eq_of_toFin_eq : ∀ {x y : BitVec w}, x.toFin = y.toFin → x = y
  
Arguments: {w : Nat} {x y : BitVec w}
Goal: x.toFin = y.toFin → x = y
-- BitVec.toNat_ofBool
@[simp] theorem toNat_ofBool (b : Bool) : (ofBool b).toNat = b.toNat 
Arguments: (b : Bool)
Goal: (BitVec.ofBool b).toNat = b.toNat
-- BitVec.msb_ofBool
@[simp] theorem msb_ofBool (b : Bool) : (ofBool b).msb = b 
Arguments: (b : Bool)
Goal: (BitVec.ofBool b).msb = b
-- BitVec.ofNat_one
theorem ofNat_one (n : Nat) : BitVec.ofNat 1 n = BitVec.ofBool (n % 2 = 1) 
Arguments: (n : Nat)
Goal: BitVec.ofNat 1 n = BitVec.ofBool (decide (n % 2 = 1))
-- BitVec.ofBool_eq_iff_eq
theorem ofBool_eq_iff_eq : ∀(b b' : Bool), BitVec.ofBool b = BitVec.ofBool b' ↔ b = b' 
Arguments: (b b' : Bool)
Goal: BitVec.ofBool b = BitVec.ofBool b' ↔ b = b'
-- BitVec.not_ofBool
@[simp] theorem not_ofBool : ~~~ (ofBool b) = ofBool (!b) 
Arguments: {b : Bool}
Goal: ~~~BitVec.ofBool b = BitVec.ofBool !b
-- BitVec.toNat_ofFin
@[simp, bv_toNat] theorem toNat_ofFin (x : Fin (2^n)) : (BitVec.ofFin x).toNat = x.val 
Arguments: {n : Nat} (x : Fin (2 ^ n))
Goal: { toFin := x }.toNat = ↑x
-- BitVec.toNat_ofNatLt
@[simp] theorem toNat_ofNatLt (x : Nat) (p : x < 2^w) : (x#'p).toNat = x 
Arguments: {w : Nat} (x : Nat) (p : x < 2 ^ w)
Goal: (x#'p).toNat = x
-- BitVec.getLsb_ofNatLt
@[simp] theorem getLsb_ofNatLt {n : Nat} (x : Nat) (lt : x < 2^n) (i : Nat) :
  getLsb (x#'lt) i = x.testBit i 
Arguments: {n : Nat} (x : Nat) (lt : x < 2 ^ n) (i : Nat)
Goal: (x#'lt).getLsb i = x.testBit i
-- BitVec.toNat_ofNat
@[simp, bv_toNat] theorem toNat_ofNat (x w : Nat) : (BitVec.ofNat w x).toNat = x % 2^w 
Arguments: (x w : Nat)
Goal: (BitVec.ofNat w x).toNat = x % 2 ^ w
-- BitVec.toFin_ofNat
@[simp] theorem toFin_ofNat (x : Nat) : toFin (BitVec.ofNat w x) = Fin.ofNat' x (Nat.two_pow_pos w) 
Arguments: {w : Nat} (x : Nat)
Goal: (BitVec.ofNat w x).toFin = Fin.ofNat' x ⋯
-- BitVec.getLsb_ofNat
theorem getLsb_ofNat (n : Nat) (x : Nat) (i : Nat) :
  getLsb (BitVec.ofNat n x) i = (i < n && x.testBit i) 
Arguments: (n x i : Nat)
Goal: (BitVec.ofNat n x).getLsb i = (decide (i < n) && x.testBit i)
-- BitVec.toNat_zero
@[simp, deprecated toNat_ofNat (since := "2024-02-22")]
theorem toNat_zero (n : Nat) : (0#n).toNat = 0 
Arguments: (n : Nat)
Goal: (0#n).toNat = 0
-- BitVec.getLsb_zero
@[simp] theorem getLsb_zero : (0#w).getLsb i = false 
Arguments: {w i : Nat}
Goal: (0#w).getLsb i = false
-- BitVec.getMsb_zero
@[simp] theorem getMsb_zero : (0#w).getMsb i = false 
Arguments: {w i : Nat}
Goal: (0#w).getMsb i = false
-- BitVec.toNat_mod_cancel
@[simp] theorem toNat_mod_cancel (x : BitVec n) : x.toNat % (2^n) = x.toNat 
Arguments: {n : Nat} (x : BitVec n)
Goal: x.toNat % 2 ^ n = x.toNat
-- _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Lemmas.0.BitVec.lt_two_pow_of_le
private theorem lt_two_pow_of_le {x m n : Nat} (lt : x < 2 ^ m) (le : m ≤ n) : x < 2 ^ n 
Arguments: {x m n : Nat} (lt : x < 2 ^ m) (le : m ≤ n)
Goal: x < 2 ^ n
-- BitVec.msb_zero
@[simp] theorem msb_zero : (0#w).msb = false 
Arguments: {w : Nat}
Goal: (0#w).msb = false
-- BitVec.msb_eq_getLsb_last
theorem msb_eq_getLsb_last (x : BitVec w) :
    x.msb = x.getLsb (w - 1) 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.msb = x.getLsb (w - 1)
-- BitVec.getLsb_last
@[bv_toNat] theorem getLsb_last (x : BitVec w) :
    x.getLsb (w-1) = decide (2 ^ (w-1) ≤ x.toNat) 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.getLsb (w - 1) = decide (2 ^ (w - 1) ≤ x.toNat)
-- BitVec.getLsb_succ_last
@[bv_toNat] theorem getLsb_succ_last (x : BitVec (w + 1)) :
    x.getLsb w = decide (2 ^ w ≤ x.toNat) 
Arguments: {w : Nat} (x : BitVec (w + 1))
Goal: x.getLsb w = decide (2 ^ w ≤ x.toNat)
-- BitVec.msb_eq_decide
@[bv_toNat] theorem msb_eq_decide (x : BitVec w) : BitVec.msb x = decide (2 ^ (w-1) ≤ x.toNat) 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.msb = decide (2 ^ (w - 1) ≤ x.toNat)
-- BitVec.toNat_ge_of_msb_true
theorem toNat_ge_of_msb_true {x : BitVec n} (p : BitVec.msb x = true) : x.toNat ≥ 2^(n-1) 
Arguments: {n : Nat} {x : BitVec n} (p : x.msb = true)
Goal: x.toNat ≥ 2 ^ (n - 1)
-- BitVec.toNat_cast
@[simp, bv_toNat] theorem toNat_cast (h : w = v) (x : BitVec w) : (cast h x).toNat = x.toNat 
Arguments: {w v : Nat} (h : w = v) (x : BitVec w)
Goal: (BitVec.cast h x).toNat = x.toNat
-- BitVec.toFin_cast
@[simp] theorem toFin_cast (h : w = v) (x : BitVec w) :
    (cast h x).toFin = x.toFin.cast (by rw [h]) 
Arguments: {w v : Nat} (h : w = v) (x : BitVec w)
Goal: (BitVec.cast h x).toFin = Fin.cast ⋯ x.toFin
-- BitVec.getLsb_cast
@[simp] theorem getLsb_cast (h : w = v) (x : BitVec w) : (cast h x).getLsb i = x.getLsb i 
Arguments: {w v i : Nat} (h : w = v) (x : BitVec w)
Goal: (BitVec.cast h x).getLsb i = x.getLsb i
-- BitVec.getMsb_cast
@[simp] theorem getMsb_cast (h : w = v) (x : BitVec w) : (cast h x).getMsb i = x.getMsb i 
Arguments: {w v i : Nat} (h : w = v) (x : BitVec w)
Goal: (BitVec.cast h x).getMsb i = x.getMsb i
-- BitVec.msb_cast
@[simp] theorem msb_cast (h : w = v) (x : BitVec w) : (cast h x).msb = x.msb 
Arguments: {w v : Nat} (h : w = v) (x : BitVec w)
Goal: (BitVec.cast h x).msb = x.msb
-- BitVec.toInt_eq_toNat_cond
theorem toInt_eq_toNat_cond (i : BitVec n) :
    i.toInt =
      if 2*i.toNat < 2^n then
        (i.toNat : Int)
      else
        (i.toNat : Int) - (2^n : Nat) 
Arguments: {n : Nat} (i : BitVec n)
Goal: i.toInt = if 2 * i.toNat < 2 ^ n then ↑i.toNat else ↑i.toNat - ↑(2 ^ n)
-- BitVec.msb_eq_false_iff_two_mul_lt
theorem msb_eq_false_iff_two_mul_lt (x : BitVec w) : x.msb = false ↔ 2 * x.toNat < 2^w 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.msb = false ↔ 2 * x.toNat < 2 ^ w
-- BitVec.msb_eq_true_iff_two_mul_ge
theorem msb_eq_true_iff_two_mul_ge (x : BitVec w) : x.msb = true ↔ 2 * x.toNat ≥ 2^w 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.msb = true ↔ 2 * x.toNat ≥ 2 ^ w
-- BitVec.toInt_eq_msb_cond
theorem toInt_eq_msb_cond (x : BitVec w) :
    x.toInt = if x.msb then (x.toNat : Int) - (2^w : Nat) else (x.toNat : Int) 
Arguments: {w : Nat} (x : BitVec w)
Goal: x.toInt = if x.msb = true then ↑x.toNat - ↑(2 ^ w) else ↑x.toNat
-- BitVec.toInt_eq_toNat_bmod
theorem toInt_eq_toNat_bmod (x : BitVec n) : x.toInt = Int.bmod x.toNat (2^n) 
Arguments: {n : Nat} (x : BitVec n)
Goal: x.toInt = (↑x.toNat).bmod (2 ^ n)
-- BitVec.eq_of_toInt_eq
theorem eq_of_toInt_eq {i j : BitVec n} : i.toInt = j.toInt → i = j 
Arguments: {n : Nat} {i j : BitVec n}
Goal: i.toInt = j.toInt → i = j
-- BitVec.toInt_inj
theorem toInt_inj (x y : BitVec n) : x.toInt = y.toInt ↔ x = y 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x.toInt = y.toInt ↔ x = y
-- BitVec.toInt_ne
theorem toInt_ne (x y : BitVec n) : x.toInt ≠ y.toInt ↔ x ≠ y  
Arguments: {n : Nat} (x y : BitVec n)
Goal: x.toInt ≠ y.toInt ↔ x ≠ y
-- BitVec.toNat_ofInt
@[simp] theorem toNat_ofInt {n : Nat} (i : Int) :
  (BitVec.ofInt n i).toNat = (i % (2^n : Nat)).toNat 
Arguments: {n : Nat} (i : Int)
Goal: (BitVec.ofInt n i).toNat = (i % ↑(2 ^ n)).toNat
-- BitVec.toInt_ofNat
theorem toInt_ofNat {n : Nat} (x : Nat) :
  (BitVec.ofNat n x).toInt = (x : Int).bmod (2^n) 
Arguments: {n : Nat} (x : Nat)
Goal: (BitVec.ofNat n x).toInt = (↑x).bmod (2 ^ n)
-- BitVec.toInt_ofInt
@[simp] theorem toInt_ofInt {n : Nat} (i : Int) :
  (BitVec.ofInt n i).toInt = i.bmod (2^n) 
Arguments: {n : Nat} (i : Int)
Goal: (BitVec.ofInt n i).toInt = i.bmod (2 ^ n)
-- BitVec.ofInt_natCast
@[simp] theorem ofInt_natCast (w n : Nat) :
  BitVec.ofInt w (n : Int) = BitVec.ofNat w n 
Arguments: (w n : Nat)
Goal: BitVec.ofInt w ↑n = BitVec.ofNat w n
-- BitVec.toNat_zeroExtend'
@[simp, bv_toNat] theorem toNat_zeroExtend' {m n : Nat} (p : m ≤ n) (x : BitVec m) :
    (zeroExtend' p x).toNat = x.toNat 
Arguments: {m n : Nat} (p : m ≤ n) (x : BitVec m)
Goal: (BitVec.zeroExtend' p x).toNat = x.toNat
-- BitVec.toNat_zeroExtend
@[bv_toNat] theorem toNat_zeroExtend (i : Nat) (x : BitVec n) :
    BitVec.toNat (zeroExtend i x) = x.toNat % 2^i 
Arguments: {n : Nat} (i : Nat) (x : BitVec n)
Goal: (BitVec.zeroExtend i x).toNat = x.toNat % 2 ^ i
-- BitVec.zeroExtend'_eq
theorem zeroExtend'_eq {x : BitVec w} (h : w ≤ v) : x.zeroExtend' h = x.zeroExtend v 
Arguments: {w v : Nat} {x : BitVec w} (h : w ≤ v)
Goal: BitVec.zeroExtend' h x = BitVec.zeroExtend v x
-- BitVec.toNat_truncate
@[simp, bv_toNat] theorem toNat_truncate (x : BitVec n) : (truncate i x).toNat = x.toNat % 2^i 
Arguments: {n i : Nat} (x : BitVec n)
Goal: (BitVec.truncate i x).toNat = x.toNat % 2 ^ i
-- BitVec.zeroExtend_eq
@[simp] theorem zeroExtend_eq (x : BitVec n) : zeroExtend n x = x 
Arguments: {n : Nat} (x : BitVec n)
Goal: BitVec.zeroExtend n x = x
-- BitVec.zeroExtend_zero
@[simp] theorem zeroExtend_zero (m n : Nat) : zeroExtend m 0#n = 0#m 
Arguments: (m n : Nat)
Goal: BitVec.zeroExtend m 0#n = 0#m
-- BitVec.truncate_eq
@[simp] theorem truncate_eq (x : BitVec n) : truncate n x = x 
Arguments: {n : Nat} (x : BitVec n)
Goal: BitVec.truncate n x = x
-- BitVec.ofNat_toNat
@[simp] theorem ofNat_toNat (m : Nat) (x : BitVec n) : BitVec.ofNat m x.toNat = truncate m x 
Arguments: {n : Nat} (m : Nat) (x : BitVec n)
Goal: BitVec.ofNat m x.toNat = BitVec.truncate m x
-- BitVec.toNat_eq_nat
theorem toNat_eq_nat (x : BitVec w) (y : Nat)
  : (x.toNat = y) ↔ (y < 2^w ∧ (x = BitVec.ofNat w y)) 
Arguments: {w : Nat} (x : BitVec w) (y : Nat)
Goal: x.toNat = y ↔ y < 2 ^ w ∧ x = BitVec.ofNat w y
-- BitVec.nat_eq_toNat
theorem nat_eq_toNat (x : BitVec w) (y : Nat)
  : (y = x.toNat) ↔ (y < 2^w ∧ (x = BitVec.ofNat w y)) 
Arguments: {w : Nat} (x : BitVec w) (y : Nat)
Goal: y = x.toNat ↔ y < 2 ^ w ∧ x = BitVec.ofNat w y
-- BitVec.getLsb_zeroExtend'
@[simp] theorem getLsb_zeroExtend' (ge : m ≥ n) (x : BitVec n) (i : Nat) :
    getLsb (zeroExtend' ge x) i = getLsb x i 
Arguments: {m n : Nat} (ge : m ≥ n) (x : BitVec n) (i : Nat)
Goal: (BitVec.zeroExtend' ge x).getLsb i = x.getLsb i
-- BitVec.getMsb_zeroExtend'
@[simp] theorem getMsb_zeroExtend' (ge : m ≥ n) (x : BitVec n) (i : Nat) :
    getMsb (zeroExtend' ge x) i = (decide (i ≥ m - n) && getMsb x (i - (m - n))) 
Arguments: {m n : Nat} (ge : m ≥ n) (x : BitVec n) (i : Nat)
Goal: (BitVec.zeroExtend' ge x).getMsb i = (decide (i ≥ m - n) && x.getMsb (i - (m - n)))
-- BitVec.getLsb_zeroExtend
@[simp] theorem getLsb_zeroExtend (m : Nat) (x : BitVec n) (i : Nat) :
    getLsb (zeroExtend m x) i = (decide (i < m) && getLsb x i) 
Arguments: {n : Nat} (m : Nat) (x : BitVec n) (i : Nat)
Goal: (BitVec.zeroExtend m x).getLsb i = (decide (i < m) && x.getLsb i)
-- BitVec.getMsb_zeroExtend_add
@[simp] theorem getMsb_zeroExtend_add {x : BitVec w} (h : k ≤ i) :
    (x.zeroExtend (w + k)).getMsb i = x.getMsb (i - k) 
Arguments: {w k i : Nat} {x : BitVec w} (h : k ≤ i)
Goal: (BitVec.zeroExtend (w + k) x).getMsb i = x.getMsb (i - k)
-- BitVec.getLsb_truncate
@[simp] theorem getLsb_truncate (m : Nat) (x : BitVec n) (i : Nat) :
    getLsb (truncate m x) i = (decide (i < m) && getLsb x i) 
Arguments: {n : Nat} (m : Nat) (x : BitVec n) (i : Nat)
Goal: (BitVec.truncate m x).getLsb i = (decide (i < m) && x.getLsb i)
-- BitVec.msb_truncate
theorem msb_truncate (x : BitVec w) : (x.truncate (k + 1)).msb = x.getLsb k 
Arguments: {w k : Nat} (x : BitVec w)
Goal: (BitVec.truncate (k + 1) x).msb = x.getLsb k
-- BitVec.zeroExtend_zeroExtend_of_le
@[simp] theorem zeroExtend_zeroExtend_of_le (x : BitVec w) (h : k ≤ l) :
    (x.zeroExtend l).zeroExtend k = x.zeroExtend k 
Arguments: {w k l : Nat} (x : BitVec w) (h : k ≤ l)
Goal: BitVec.zeroExtend k (BitVec.zeroExtend l x) = BitVec.zeroExtend k x
-- BitVec.truncate_truncate_of_le
@[simp] theorem truncate_truncate_of_le (x : BitVec w) (h : k ≤ l) :
    (x.truncate l).truncate k = x.truncate k 
Arguments: {w k l : Nat} (x : BitVec w) (h : k ≤ l)
Goal: BitVec.truncate k (BitVec.truncate l x) = BitVec.truncate k x
-- BitVec.truncate_cast
@[simp] theorem truncate_cast {h : w = v} : (cast h x).truncate k = x.truncate k 
Arguments: {w v : Nat} {x : BitVec w} {k : Nat} {h : w = v}
Goal: BitVec.truncate k (BitVec.cast h x) = BitVec.truncate k x
-- BitVec.msb_zeroExtend
theorem msb_zeroExtend (x : BitVec w) : (x.zeroExtend v).msb = (decide (0 < v) && x.getLsb (v - 1)) 
Arguments: {w v : Nat} (x : BitVec w)
Goal: (BitVec.zeroExtend v x).msb = (decide (0 < v) && x.getLsb (v - 1))
-- BitVec.msb_zeroExtend'
theorem msb_zeroExtend' (x : BitVec w) (h : w ≤ v) : (x.zeroExtend' h).msb = (decide (0 < v) && x.getLsb (v - 1)) 
Arguments: {w v : Nat} (x : BitVec w) (h : w ≤ v)
Goal: (BitVec.zeroExtend' h x).msb = (decide (0 < v) && x.getLsb (v - 1))
-- BitVec.extractLsb_ofFin
@[simp]
protected theorem extractLsb_ofFin {n} (x : Fin (2^n)) (hi lo : Nat) :
  extractLsb hi lo (@BitVec.ofFin n x) = .ofNat (hi-lo+1) (x.val >>> lo) 
Arguments: {n : Nat} (x : Fin (2 ^ n)) (hi lo : Nat)
Goal: BitVec.extractLsb hi lo { toFin := x } = BitVec.ofNat (hi - lo + 1) (↑x >>> lo)
-- BitVec.extractLsb_ofNat
@[simp]
protected theorem extractLsb_ofNat (x n : Nat) (hi lo : Nat) :
  extractLsb hi lo (BitVec.ofNat n x) = .ofNat (hi - lo + 1) ((x % 2^n) >>> lo) 
Arguments: (x n hi lo : Nat)
Goal: BitVec.extractLsb hi lo (BitVec.ofNat n x) = BitVec.ofNat (hi - lo + 1) ((x % 2 ^ n) >>> lo)
-- BitVec.extractLsb'_toNat
@[simp] theorem extractLsb'_toNat (s m : Nat) (x : BitVec n) :
  (extractLsb' s m x).toNat = (x.toNat >>> s) % 2^m 
Arguments: {n : Nat} (s m : Nat) (x : BitVec n)
Goal: (BitVec.extractLsb' s m x).toNat = x.toNat >>> s % 2 ^ m
-- BitVec.extractLsb_toNat
@[simp] theorem extractLsb_toNat (hi lo : Nat) (x : BitVec n) :
  (extractLsb hi lo x).toNat = (x.toNat >>> lo) % 2^(hi-lo+1) 
Arguments: {n : Nat} (hi lo : Nat) (x : BitVec n)
Goal: (BitVec.extractLsb hi lo x).toNat = x.toNat >>> lo % 2 ^ (hi - lo + 1)
-- BitVec.getLsb_extract
@[simp] theorem getLsb_extract (hi lo : Nat) (x : BitVec n) (i : Nat) :
    getLsb (extractLsb hi lo x) i = (i ≤ (hi-lo) && getLsb x (lo+i)) 
Arguments: {n : Nat} (hi lo : Nat) (x : BitVec n) (i : Nat)
Goal: (BitVec.extractLsb hi lo x).getLsb i = (decide (i ≤ hi - lo) && x.getLsb (lo + i))
-- BitVec.toNat_allOnes
@[simp] theorem toNat_allOnes : (allOnes v).toNat = 2^v - 1 
Arguments: {v : Nat}
Goal: (BitVec.allOnes v).toNat = 2 ^ v - 1
-- BitVec.getLsb_allOnes
@[simp] theorem getLsb_allOnes : (allOnes v).getLsb i = decide (i < v) 
Arguments: {v i : Nat}
Goal: (BitVec.allOnes v).getLsb i = decide (i < v)
-- BitVec.toNat_or
@[simp] theorem toNat_or (x y : BitVec v) :
    BitVec.toNat (x ||| y) = BitVec.toNat x ||| BitVec.toNat y 
Arguments: {v : Nat} (x y : BitVec v)
Goal: (x ||| y).toNat = x.toNat ||| y.toNat
-- BitVec.toFin_or
@[simp] theorem toFin_or (x y : BitVec v) :
    BitVec.toFin (x ||| y) = BitVec.toFin x ||| BitVec.toFin y 
Arguments: {v : Nat} (x y : BitVec v)
Goal: (x ||| y).toFin = x.toFin ||| y.toFin
-- BitVec.getLsb_or
@[simp] theorem getLsb_or {x y : BitVec v} : (x ||| y).getLsb i = (x.getLsb i || y.getLsb i) 
Arguments: {v i : Nat} {x y : BitVec v}
Goal: (x ||| y).getLsb i = (x.getLsb i || y.getLsb i)
-- BitVec.getMsb_or
@[simp] theorem getMsb_or {x y : BitVec w} : (x ||| y).getMsb i = (x.getMsb i || y.getMsb i) 
Arguments: {w i : Nat} {x y : BitVec w}
Goal: (x ||| y).getMsb i = (x.getMsb i || y.getMsb i)
-- BitVec.msb_or
@[simp] theorem msb_or {x y : BitVec w} : (x ||| y).msb = (x.msb || y.msb) 
Arguments: {w : Nat} {x y : BitVec w}
Goal: (x ||| y).msb = (x.msb || y.msb)
-- BitVec.truncate_or
@[simp] theorem truncate_or {x y : BitVec w} :
    (x ||| y).truncate k = x.truncate k ||| y.truncate k 
Arguments: {w k : Nat} {x y : BitVec w}
Goal: BitVec.truncate k (x ||| y) = BitVec.truncate k x ||| BitVec.truncate k y
-- BitVec.or_assoc
theorem or_assoc (x y z : BitVec w) :
    x ||| y ||| z = x ||| (y ||| z) 
Arguments: {w : Nat} (x y z : BitVec w)
Goal: x ||| y ||| z = x ||| (y ||| z)
-- BitVec.toNat_and
@[simp] theorem toNat_and (x y : BitVec v) :
    BitVec.toNat (x &&& y) = BitVec.toNat x &&& BitVec.toNat y 
Arguments: {v : Nat} (x y : BitVec v)
Goal: (x &&& y).toNat = x.toNat &&& y.toNat
-- BitVec.toFin_and
@[simp] theorem toFin_and (x y : BitVec v) :
    BitVec.toFin (x &&& y) = BitVec.toFin x &&& BitVec.toFin y 
Arguments: {v : Nat} (x y : BitVec v)
Goal: (x &&& y).toFin = x.toFin &&& y.toFin
-- BitVec.getLsb_and
@[simp] theorem getLsb_and {x y : BitVec v} : (x &&& y).getLsb i = (x.getLsb i && y.getLsb i) 
Arguments: {v i : Nat} {x y : BitVec v}
Goal: (x &&& y).getLsb i = (x.getLsb i && y.getLsb i)
-- BitVec.getMsb_and
@[simp] theorem getMsb_and {x y : BitVec w} : (x &&& y).getMsb i = (x.getMsb i && y.getMsb i) 
Arguments: {w i : Nat} {x y : BitVec w}
Goal: (x &&& y).getMsb i = (x.getMsb i && y.getMsb i)
-- BitVec.msb_and
@[simp] theorem msb_and {x y : BitVec w} : (x &&& y).msb = (x.msb && y.msb) 
Arguments: {w : Nat} {x y : BitVec w}
Goal: (x &&& y).msb = (x.msb && y.msb)
-- BitVec.truncate_and
@[simp] theorem truncate_and {x y : BitVec w} :
    (x &&& y).truncate k = x.truncate k &&& y.truncate k 
Arguments: {w k : Nat} {x y : BitVec w}
Goal: BitVec.truncate k (x &&& y) = BitVec.truncate k x &&& BitVec.truncate k y
-- BitVec.and_assoc
theorem and_assoc (x y z : BitVec w) :
    x &&& y &&& z = x &&& (y &&& z) 
Arguments: {w : Nat} (x y z : BitVec w)
Goal: x &&& y &&& z = x &&& (y &&& z)
-- BitVec.toNat_xor
@[simp] theorem toNat_xor (x y : BitVec v) :
    BitVec.toNat (x ^^^ y) = BitVec.toNat x ^^^ BitVec.toNat y 
Arguments: {v : Nat} (x y : BitVec v)
Goal: (x ^^^ y).toNat = x.toNat ^^^ y.toNat
-- BitVec.toFin_xor
@[simp] theorem toFin_xor (x y : BitVec v) :
    BitVec.toFin (x ^^^ y) = BitVec.toFin x ^^^ BitVec.toFin y 
Arguments: {v : Nat} (x y : BitVec v)
Goal: (x ^^^ y).toFin = x.toFin ^^^ y.toFin
-- BitVec.getLsb_xor
@[simp] theorem getLsb_xor {x y : BitVec v} :
    (x ^^^ y).getLsb i = (xor (x.getLsb i) (y.getLsb i)) 
Arguments: {v i : Nat} {x y : BitVec v}
Goal: (x ^^^ y).getLsb i = xor (x.getLsb i) (y.getLsb i)
-- BitVec.truncate_xor
@[simp] theorem truncate_xor {x y : BitVec w} :
    (x ^^^ y).truncate k = x.truncate k ^^^ y.truncate k 
Arguments: {w k : Nat} {x y : BitVec w}
Goal: BitVec.truncate k (x ^^^ y) = BitVec.truncate k x ^^^ BitVec.truncate k y
-- BitVec.xor_assoc
theorem xor_assoc (x y z : BitVec w) :
    x ^^^ y ^^^ z = x ^^^ (y ^^^ z) 
Arguments: {w : Nat} (x y z : BitVec w)
Goal: x ^^^ y ^^^ z = x ^^^ (y ^^^ z)
-- BitVec.not_def
theorem not_def {x : BitVec v} : ~~~x = allOnes v ^^^ x 
Arguments: {v : Nat} {x : BitVec v}
Goal: ~~~x = BitVec.allOnes v ^^^ x
-- BitVec.toNat_not
@[simp, bv_toNat] theorem toNat_not {x : BitVec v} : (~~~x).toNat = 2^v - 1 - x.toNat 
Arguments: {v : Nat} {x : BitVec v}
Goal: (~~~x).toNat = 2 ^ v - 1 - x.toNat
-- BitVec.toFin_not
@[simp] theorem toFin_not (x : BitVec w) :
    (~~~x).toFin = x.toFin.rev 
Arguments: {w : Nat} (x : BitVec w)
Goal: (~~~x).toFin = x.toFin.rev
-- BitVec.getLsb_not
@[simp] theorem getLsb_not {x : BitVec v} : (~~~x).getLsb i = (decide (i < v) && ! x.getLsb i) 
Arguments: {v i : Nat} {x : BitVec v}
Goal: (~~~x).getLsb i = (decide (i < v) && !x.getLsb i)
-- BitVec.truncate_not
@[simp] theorem truncate_not {x : BitVec w} (h : k ≤ w) :
    (~~~x).truncate k = ~~~(x.truncate k) 
Arguments: {w k : Nat} {x : BitVec w} (h : k ≤ w)
Goal: BitVec.truncate k (~~~x) = ~~~BitVec.truncate k x
-- BitVec.not_cast
@[simp] theorem not_cast {x : BitVec w} (h : w = w') : ~~~(cast h x) = cast h (~~~x) 
Arguments: {w w' : Nat} {x : BitVec w} (h : w = w')
Goal: ~~~BitVec.cast h x = BitVec.cast h (~~~x)
-- BitVec.and_cast
@[simp] theorem and_cast {x y : BitVec w} (h : w = w') : cast h x &&& cast h y = cast h (x &&& y) 
Arguments: {w w' : Nat} {x y : BitVec w} (h : w = w')
Goal: BitVec.cast h x &&& BitVec.cast h y = BitVec.cast h (x &&& y)
-- BitVec.or_cast
@[simp] theorem or_cast {x y : BitVec w} (h : w = w') : cast h x ||| cast h y = cast h (x ||| y) 
Arguments: {w w' : Nat} {x y : BitVec w} (h : w = w')
Goal: BitVec.cast h x ||| BitVec.cast h y = BitVec.cast h (x ||| y)
-- BitVec.xor_cast
@[simp] theorem xor_cast {x y : BitVec w} (h : w = w') : cast h x &&& cast h y = cast h (x &&& y) 
Arguments: {w w' : Nat} {x y : BitVec w} (h : w = w')
Goal: BitVec.cast h x &&& BitVec.cast h y = BitVec.cast h (x &&& y)
-- BitVec.toNat_shiftLeft
@[simp, bv_toNat] theorem toNat_shiftLeft {x : BitVec v} :
    BitVec.toNat (x <<< n) = BitVec.toNat x <<< n % 2^v 
Arguments: {v n : Nat} {x : BitVec v}
Goal: (x <<< n).toNat = x.toNat <<< n % 2 ^ v
-- BitVec.toFin_shiftLeft
@[simp] theorem toFin_shiftLeft {n : Nat} (x : BitVec w) :
    BitVec.toFin (x <<< n) = Fin.ofNat' (x.toNat <<< n) (Nat.two_pow_pos w) 
Arguments: {w n : Nat} (x : BitVec w)
Goal: (x <<< n).toFin = Fin.ofNat' (x.toNat <<< n) ⋯
-- BitVec.getLsb_shiftLeft
@[simp] theorem getLsb_shiftLeft (x : BitVec m) (n) :
    getLsb (x <<< n) i = (decide (i < m) && !decide (i < n) && getLsb x (i - n)) 
Arguments: {m i : Nat} (x : BitVec m) (n : Nat)
Goal: (x <<< n).getLsb i = (decide (i < m) && !decide (i < n) && x.getLsb (i - n))
-- BitVec.getMsb_shiftLeft
@[simp] theorem getMsb_shiftLeft (x : BitVec w) (i) :
    (x <<< i).getMsb k = x.getMsb (k + i) 
Arguments: {w k : Nat} (x : BitVec w) (i : Nat)
Goal: (x <<< i).getMsb k = x.getMsb (k + i)
-- BitVec.shiftLeftZeroExtend_eq
theorem shiftLeftZeroExtend_eq {x : BitVec w} :
    shiftLeftZeroExtend x n = zeroExtend (w+n) x <<< n 
Arguments: {w n : Nat} {x : BitVec w}
Goal: x.shiftLeftZeroExtend n = BitVec.zeroExtend (w + n) x <<< n
-- BitVec.getLsb_shiftLeftZeroExtend
@[simp] theorem getLsb_shiftLeftZeroExtend (x : BitVec m) (n : Nat) :
    getLsb (shiftLeftZeroExtend x n) i = ((! decide (i < n)) && getLsb x (i - n)) 
Arguments: {m i : Nat} (x : BitVec m) (n : Nat)
Goal: (x.shiftLeftZeroExtend n).getLsb i = (!decide (i < n) && x.getLsb (i - n))
-- BitVec.getMsb_shiftLeftZeroExtend
@[simp] theorem getMsb_shiftLeftZeroExtend (x : BitVec m) (n : Nat) :
    getMsb (shiftLeftZeroExtend x n) i = getMsb x i 
Arguments: {m i : Nat} (x : BitVec m) (n : Nat)
Goal: (x.shiftLeftZeroExtend n).getMsb i = x.getMsb i
-- BitVec.msb_shiftLeftZeroExtend
@[simp] theorem msb_shiftLeftZeroExtend (x : BitVec w) (i : Nat) :
    (shiftLeftZeroExtend x i).msb = x.msb 
Arguments: {w : Nat} (x : BitVec w) (i : Nat)
Goal: (x.shiftLeftZeroExtend i).msb = x.msb
-- BitVec.shiftLeft_add
theorem shiftLeft_add {w : Nat} (x : BitVec w) (n m : Nat) :
    x <<< (n + m) = (x <<< n) <<< m 
Arguments: {w : Nat} (x : BitVec w) (n m : Nat)
Goal: x <<< (n + m) = x <<< n <<< m
-- BitVec.shiftLeft_shiftLeft
@[deprecated shiftLeft_add (since := "2024-06-02")]
theorem shiftLeft_shiftLeft {w : Nat} (x : BitVec w) (n m : Nat) :
    (x <<< n) <<< m = x <<< (n + m) 
Arguments: {w : Nat} (x : BitVec w) (n m : Nat)
Goal: x <<< n <<< m = x <<< (n + m)
-- BitVec.toNat_ushiftRight
@[simp, bv_toNat] theorem toNat_ushiftRight (x : BitVec n) (i : Nat) :
    (x >>> i).toNat = x.toNat >>> i 
Arguments: {n : Nat} (x : BitVec n) (i : Nat)
Goal: (x >>> i).toNat = x.toNat >>> i
-- BitVec.getLsb_ushiftRight
@[simp] theorem getLsb_ushiftRight (x : BitVec n) (i j : Nat) :
    getLsb (x >>> i) j = getLsb x (i+j) 
Arguments: {n : Nat} (x : BitVec n) (i j : Nat)
Goal: (x >>> i).getLsb j = x.getLsb (i + j)
-- BitVec.sshiftRight_eq
theorem sshiftRight_eq {x : BitVec n} {i : Nat} :
    x.sshiftRight i = BitVec.ofInt n (x.toInt >>> i) 
Arguments: {n : Nat} {x : BitVec n} {i : Nat}
Goal: x.sshiftRight i = BitVec.ofInt n (x.toInt >>> i)
-- BitVec.sshiftRight_eq_of_msb_false
theorem sshiftRight_eq_of_msb_false {x : BitVec w} {s : Nat} (h : x.msb = false) :
    (x.sshiftRight s) = x >>> s 
Arguments: {w : Nat} {x : BitVec w} {s : Nat} (h : x.msb = false)
Goal: x.sshiftRight s = x >>> s
-- BitVec.sshiftRight_eq_of_msb_true
theorem sshiftRight_eq_of_msb_true {x : BitVec w} {s : Nat} (h : x.msb = true) :
    (x.sshiftRight s) = ~~~((~~~x) >>> s) 
Arguments: {w : Nat} {x : BitVec w} {s : Nat} (h : x.msb = true)
Goal: x.sshiftRight s = ~~~(~~~x >>> s)
-- BitVec.getLsb_sshiftRight
theorem getLsb_sshiftRight (x : BitVec w) (s i : Nat) :
    getLsb (x.sshiftRight s) i =
      (!decide (w ≤ i) && if s + i < w then x.getLsb (s + i) else x.msb) 
Arguments: {w : Nat} (x : BitVec w) (s i : Nat)
Goal: (x.sshiftRight s).getLsb i = (!decide (w ≤ i) && if s + i < w then x.getLsb (s + i) else x.msb)