ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Lemmas.0.BitVec.Int.ofNat_sub_ofNat_of_lt
private theorem Int.ofNat_sub_ofNat_of_lt {n m : Nat} (hlt : n < m) :
    (n : Int) - (m : Int) = -(↑(m - 1 - n) + 1) 
Arguments: {n m : Nat} (hlt : n < m)
Goal: ↑n - ↑m = -(↑(m - 1 - n) + 1)
-- _private.«.lake».packages.lean4.src.lean.Init.Data.BitVec.Lemmas.0.BitVec.Int.negSucc_emod
private theorem Int.negSucc_emod (m : Nat) (n : Int) :
    -(m + 1) % n = Int.subNatNat (Int.natAbs n) ((m % Int.natAbs n) + 1) 
Arguments: (m : Nat) (n : Int)
Goal: -(↑m + 1) % n = Int.subNatNat n.natAbs (m % n.natAbs + 1)
-- BitVec.signExtend_eq_not_zeroExtend_not_of_msb_false
theorem signExtend_eq_not_zeroExtend_not_of_msb_false {x : BitVec w} {v : Nat} (hmsb : x.msb = false) :
    x.signExtend v = x.zeroExtend v 
Arguments: {w : Nat} {x : BitVec w} {v : Nat} (hmsb : x.msb = false)
Goal: BitVec.signExtend v x = BitVec.zeroExtend v x
-- BitVec.signExtend_eq_not_zeroExtend_not_of_msb_true
theorem signExtend_eq_not_zeroExtend_not_of_msb_true {x : BitVec w} {v : Nat} (hmsb : x.msb = true) :
    x.signExtend v = ~~~((~~~x).zeroExtend v) 
Arguments: {w : Nat} {x : BitVec w} {v : Nat} (hmsb : x.msb = true)
Goal: BitVec.signExtend v x = ~~~BitVec.zeroExtend v (~~~x)
-- BitVec.getLsb_signExtend
@[simp] theorem getLsb_signExtend (x  : BitVec w) {v i : Nat} :
    (x.signExtend v).getLsb i = (decide (i < v) && if i < w then x.getLsb i else x.msb) 
Arguments: {w : Nat} (x : BitVec w) {v i : Nat}
Goal: (BitVec.signExtend v x).getLsb i = (decide (i < v) && if i < w then x.getLsb i else x.msb)
-- BitVec.append_def
theorem append_def (x : BitVec v) (y : BitVec w) :
    x ++ y = (shiftLeftZeroExtend x w ||| zeroExtend' (Nat.le_add_left w v) y) 
Arguments: {v w : Nat} (x : BitVec v) (y : BitVec w)
Goal: x ++ y = x.shiftLeftZeroExtend w ||| BitVec.zeroExtend' ⋯ y
-- BitVec.toNat_append
@[simp] theorem toNat_append (x : BitVec m) (y : BitVec n) :
    (x ++ y).toNat = x.toNat <<< n ||| y.toNat 
Arguments: {m n : Nat} (x : BitVec m) (y : BitVec n)
Goal: (x ++ y).toNat = x.toNat <<< n ||| y.toNat
-- BitVec.getLsb_append
@[simp] theorem getLsb_append {v : BitVec n} {w : BitVec m} :
    getLsb (v ++ w) i = bif i < m then getLsb w i else getLsb v (i - m) 
Arguments: {n m i : Nat} {v : BitVec n} {w : BitVec m}
Goal: (v ++ w).getLsb i = bif decide (i < m) then w.getLsb i else v.getLsb (i - m)
-- BitVec.getMsb_append
@[simp] theorem getMsb_append {v : BitVec n} {w : BitVec m} :
    getMsb (v ++ w) i = bif n ≤ i then getMsb w (i - n) else getMsb v i 
Arguments: {n m i : Nat} {v : BitVec n} {w : BitVec m}
Goal: (v ++ w).getMsb i = bif decide (n ≤ i) then w.getMsb (i - n) else v.getMsb i
-- BitVec.msb_append
theorem msb_append {x : BitVec w} {y : BitVec v} :
    (x ++ y).msb = bif (w == 0) then (y.msb) else (x.msb) 
Arguments: {w v : Nat} {x : BitVec w} {y : BitVec v}
Goal: (x ++ y).msb = bif w == 0 then y.msb else x.msb
-- BitVec.truncate_append
@[simp] theorem truncate_append {x : BitVec w} {y : BitVec v} :
    (x ++ y).truncate k = if h : k ≤ v then y.truncate k else (x.truncate (k - v) ++ y).cast (by omega) 
Arguments: {w v k : Nat} {x : BitVec w} {y : BitVec v}
Goal: BitVec.truncate k (x ++ y) = if h : k ≤ v then BitVec.truncate k y else BitVec.cast ⋯ (BitVec.truncate (k - v) x ++ y)
-- BitVec.truncate_cons
@[simp] theorem truncate_cons {x : BitVec w} : (cons a x).truncate w = x 
Arguments: {w : Nat} {a : Bool} {x : BitVec w}
Goal: BitVec.truncate w (BitVec.cons a x) = x
-- BitVec.not_append
@[simp] theorem not_append {x : BitVec w} {y : BitVec v} : ~~~ (x ++ y) = (~~~ x) ++ (~~~ y) 
Arguments: {w v : Nat} {x : BitVec w} {y : BitVec v}
Goal: ~~~(x ++ y) = ~~~x ++ ~~~y
-- BitVec.and_append
@[simp] theorem and_append {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v} :
    (x₁ ++ y₁) &&& (x₂ ++ y₂) = (x₁ &&& x₂) ++ (y₁ &&& y₂) 
Arguments: {w v : Nat} {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v}
Goal: x₁ ++ y₁ &&& x₂ ++ y₂ = (x₁ &&& x₂) ++ (y₁ &&& y₂)
-- BitVec.or_append
@[simp] theorem or_append {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v} :
    (x₁ ++ y₁) ||| (x₂ ++ y₂) = (x₁ ||| x₂) ++ (y₁ ||| y₂) 
Arguments: {w v : Nat} {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v}
Goal: x₁ ++ y₁ ||| x₂ ++ y₂ = (x₁ ||| x₂) ++ (y₁ ||| y₂)
-- BitVec.xor_append
@[simp] theorem xor_append {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v} :
    (x₁ ++ y₁) ^^^ (x₂ ++ y₂) = (x₁ ^^^ x₂) ++ (y₁ ^^^ y₂) 
Arguments: {w v : Nat} {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v}
Goal: x₁ ++ y₁ ^^^ x₂ ++ y₂ = (x₁ ^^^ x₂) ++ (y₁ ^^^ y₂)
-- BitVec.shiftRight_add
theorem shiftRight_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.shiftRight_shiftRight
@[deprecated shiftRight_add (since := "2024-06-02")]
theorem shiftRight_shiftRight {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.getLsb_rev
theorem getLsb_rev (x : BitVec w) (i : Fin w) :
    x.getLsb i.rev = x.getMsb i 
Arguments: {w : Nat} (x : BitVec w) (i : Fin w)
Goal: x.getLsb ↑i.rev = x.getMsb ↑i
-- BitVec.getMsb_rev
theorem getMsb_rev (x : BitVec w) (i : Fin w) :
    x.getMsb i.rev = x.getLsb i 
Arguments: {w : Nat} (x : BitVec w) (i : Fin w)
Goal: x.getMsb ↑i.rev = x.getLsb ↑i
-- BitVec.toNat_cons
@[simp] theorem toNat_cons (b : Bool) (x : BitVec w) :
    (cons b x).toNat = (b.toNat <<< w) ||| x.toNat 
Arguments: {w : Nat} (b : Bool) (x : BitVec w)
Goal: (BitVec.cons b x).toNat = b.toNat <<< w ||| x.toNat
-- BitVec.toNat_cons'
theorem toNat_cons' {x : BitVec w} :
    (cons a x).toNat = (a.toNat <<< w) + x.toNat 
Arguments: {w : Nat} {a : Bool} {x : BitVec w}
Goal: (BitVec.cons a x).toNat = a.toNat <<< w + x.toNat
-- BitVec.getLsb_cons
@[simp] theorem getLsb_cons (b : Bool) {n} (x : BitVec n) (i : Nat) :
    getLsb (cons b x) i = if i = n then b else getLsb x i 
Arguments: (b : Bool) {n : Nat} (x : BitVec n) (i : Nat)
Goal: (BitVec.cons b x).getLsb i = if i = n then b else x.getLsb i
-- BitVec.msb_cons
@[simp] theorem msb_cons : (cons a x).msb = a 
Arguments: {a : Bool}
Goal: ∀ {w : Nat} {x : BitVec w}, (BitVec.cons a x).msb = a
-- BitVec.getMsb_cons_zero
@[simp] theorem getMsb_cons_zero : (cons a x).getMsb 0 = a 
Arguments: {a : Bool}
Goal: ∀ {w : Nat} {x : BitVec w}, (BitVec.cons a x).getMsb 0 = a
-- BitVec.getMsb_cons_succ
@[simp] theorem getMsb_cons_succ : (cons a x).getMsb (i + 1) = x.getMsb i 
Arguments: {a : Bool}
Goal: ∀ {w : Nat} {x : BitVec w} {i : Nat}, (BitVec.cons a x).getMsb (i + 1) = x.getMsb i
-- BitVec.truncate_succ
theorem truncate_succ (x : BitVec w) :
    truncate (i+1) x = cons (getLsb x i) (truncate i x) 
Arguments: {w i : Nat} (x : BitVec w)
Goal: BitVec.truncate (i + 1) x = BitVec.cons (x.getLsb i) (BitVec.truncate i x)
-- BitVec.eq_msb_cons_truncate
theorem eq_msb_cons_truncate (x : BitVec (w+1)) : x = (cons x.msb (x.truncate w)) 
Arguments: {w : Nat} (x : BitVec (w + 1))
Goal: x = BitVec.cons x.msb (BitVec.truncate w x)
-- BitVec.not_cons
@[simp] theorem not_cons (x : BitVec w) (b : Bool) : ~~~(cons b x) = cons (!b) (~~~x) 
Arguments: {w : Nat} (x : BitVec w) (b : Bool)
Goal: ~~~BitVec.cons b x = BitVec.cons (!b) (~~~x)
-- BitVec.cons_or_cons
@[simp] theorem cons_or_cons (x y : BitVec w) (a b : Bool) :
    (cons a x) ||| (cons b y) = cons (a || b) (x ||| y) 
Arguments: {w : Nat} (x y : BitVec w) (a b : Bool)
Goal: BitVec.cons a x ||| BitVec.cons b y = BitVec.cons (a || b) (x ||| y)
-- BitVec.cons_and_cons
@[simp] theorem cons_and_cons (x y : BitVec w) (a b : Bool) :
    (cons a x) &&& (cons b y) = cons (a && b) (x &&& y) 
Arguments: {w : Nat} (x y : BitVec w) (a b : Bool)
Goal: BitVec.cons a x &&& BitVec.cons b y = BitVec.cons (a && b) (x &&& y)
-- BitVec.cons_xor_cons
@[simp] theorem cons_xor_cons (x y : BitVec w) (a b : Bool) :
    (cons a x) ^^^ (cons b y) = cons (xor a b) (x ^^^ y) 
Arguments: {w : Nat} (x y : BitVec w) (a b : Bool)
Goal: BitVec.cons a x ^^^ BitVec.cons b y = BitVec.cons (xor a b) (x ^^^ y)
-- BitVec.toNat_concat
@[simp] theorem toNat_concat (x : BitVec w) (b : Bool) :
    (concat x b).toNat = x.toNat * 2 + b.toNat 
Arguments: {w : Nat} (x : BitVec w) (b : Bool)
Goal: (x.concat b).toNat = x.toNat * 2 + b.toNat
-- BitVec.getLsb_concat
theorem getLsb_concat (x : BitVec w) (b : Bool) (i : Nat) :
    (concat x b).getLsb i = if i = 0 then b else x.getLsb (i - 1) 
Arguments: {w : Nat} (x : BitVec w) (b : Bool) (i : Nat)
Goal: (x.concat b).getLsb i = if i = 0 then b else x.getLsb (i - 1)
-- BitVec.getLsb_concat_zero
@[simp] theorem getLsb_concat_zero : (concat x b).getLsb 0 = b 
Goal: ∀ {w : Nat} {x : BitVec w} {b : Bool}, (x.concat b).getLsb 0 = b
-- BitVec.getLsb_concat_succ
@[simp] theorem getLsb_concat_succ : (concat x b).getLsb (i + 1) = x.getLsb i 
Goal: ∀ {w : Nat} {x : BitVec w} {b : Bool} {i : Nat}, (x.concat b).getLsb (i + 1) = x.getLsb i
-- BitVec.not_concat
@[simp] theorem not_concat (x : BitVec w) (b : Bool) : ~~~(concat x b) = concat (~~~x) !b 
Arguments: {w : Nat} (x : BitVec w) (b : Bool)
Goal: ~~~x.concat b = (~~~x).concat !b
-- BitVec.concat_or_concat
@[simp] theorem concat_or_concat (x y : BitVec w) (a b : Bool) :
    (concat x a) ||| (concat y b) = concat (x ||| y) (a || b) 
Arguments: {w : Nat} (x y : BitVec w) (a b : Bool)
Goal: x.concat a ||| y.concat b = (x ||| y).concat (a || b)
-- BitVec.concat_and_concat
@[simp] theorem concat_and_concat (x y : BitVec w) (a b : Bool) :
    (concat x a) &&& (concat y b) = concat (x &&& y) (a && b) 
Arguments: {w : Nat} (x y : BitVec w) (a b : Bool)
Goal: x.concat a &&& y.concat b = (x &&& y).concat (a && b)
-- BitVec.concat_xor_concat
@[simp] theorem concat_xor_concat (x y : BitVec w) (a b : Bool) :
    (concat x a) ^^^ (concat y b) = concat (x ^^^ y) (xor a b) 
Arguments: {w : Nat} (x y : BitVec w) (a b : Bool)
Goal: x.concat a ^^^ y.concat b = (x ^^^ y).concat (xor a b)
-- BitVec.add_def
theorem add_def {n} (x y : BitVec n) : x + y = .ofNat n (x.toNat + y.toNat) 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x + y = BitVec.ofNat n (x.toNat + y.toNat)
-- BitVec.toNat_add
@[simp, bv_toNat] theorem toNat_add (x y : BitVec w) : (x + y).toNat = (x.toNat + y.toNat) % 2^w 
Arguments: {w : Nat} (x y : BitVec w)
Goal: (x + y).toNat = (x.toNat + y.toNat) % 2 ^ w
-- BitVec.toFin_add
@[simp] theorem toFin_add (x y : BitVec w) : (x + y).toFin = toFin x + toFin y 
Arguments: {w : Nat} (x y : BitVec w)
Goal: (x + y).toFin = x.toFin + y.toFin
-- BitVec.ofFin_add
@[simp] theorem ofFin_add (x : Fin (2^n)) (y : BitVec n) :
  .ofFin x + y = .ofFin (x + y.toFin) 
Arguments: {n : Nat} (x : Fin (2 ^ n)) (y : BitVec n)
Goal: { toFin := x } + y = { toFin := x + y.toFin }
-- BitVec.add_ofFin
@[simp] theorem add_ofFin (x : BitVec n) (y : Fin (2^n)) :
  x + .ofFin y = .ofFin (x.toFin + y) 
Arguments: {n : Nat} (x : BitVec n) (y : Fin (2 ^ n))
Goal: x + { toFin := y } = { toFin := x.toFin + y }
-- BitVec.ofNat_add
theorem ofNat_add {n} (x y : Nat) : BitVec.ofNat n (x + y) = BitVec.ofNat n x + BitVec.ofNat n y 
Arguments: {n : Nat} (x y : Nat)
Goal: BitVec.ofNat n (x + y) = BitVec.ofNat n x + BitVec.ofNat n y
-- BitVec.ofNat_add_ofNat
theorem ofNat_add_ofNat {n} (x y : Nat) : BitVec.ofNat n x + BitVec.ofNat n y = BitVec.ofNat n (x + y) 
Arguments: {n : Nat} (x y : Nat)
Goal: BitVec.ofNat n x + BitVec.ofNat n y = BitVec.ofNat n (x + y)
-- BitVec.add_assoc
protected theorem add_assoc (x y z : BitVec n) : x + y + z = x + (y + z) 
Arguments: {n : Nat} (x y z : BitVec n)
Goal: x + y + z = x + (y + z)
-- BitVec.add_comm
protected theorem add_comm (x y : BitVec n) : x + y = y + x 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x + y = y + x
-- BitVec.add_zero
@[simp] protected theorem add_zero (x : BitVec n) : x + 0#n = x 
Arguments: {n : Nat} (x : BitVec n)
Goal: x + 0#n = x
-- BitVec.zero_add
@[simp] protected theorem zero_add (x : BitVec n) : 0#n + x = x 
Arguments: {n : Nat} (x : BitVec n)
Goal: 0#n + x = x
-- BitVec.truncate_add
theorem truncate_add (x y : BitVec w) (h : i ≤ w) :
    (x + y).truncate i = x.truncate i + y.truncate i 
Arguments: {w i : Nat} (x y : BitVec w) (h : i ≤ w)
Goal: BitVec.truncate i (x + y) = BitVec.truncate i x + BitVec.truncate i y
-- BitVec.toInt_add
@[simp, bv_toNat] theorem toInt_add (x y : BitVec w) :
  (x + y).toInt = (x.toInt + y.toInt).bmod (2^w) 
Arguments: {w : Nat} (x y : BitVec w)
Goal: (x + y).toInt = (x.toInt + y.toInt).bmod (2 ^ w)
-- BitVec.ofInt_add
theorem ofInt_add {n} (x y : Int) : BitVec.ofInt n (x + y) =
    BitVec.ofInt n x + BitVec.ofInt n y 
Arguments: {n : Nat} (x y : Int)
Goal: BitVec.ofInt n (x + y) = BitVec.ofInt n x + BitVec.ofInt n y
-- BitVec.sub_def
theorem sub_def {n} (x y : BitVec n) : x - y = .ofNat n ((2^n - y.toNat) + x.toNat) 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x - y = BitVec.ofNat n (2 ^ n - y.toNat + x.toNat)
-- BitVec.toNat_sub
@[simp] theorem toNat_sub {n} (x y : BitVec n) :
    (x - y).toNat = (((2^n - y.toNat) + x.toNat) % 2^n) 
Arguments: {n : Nat} (x y : BitVec n)
Goal: (x - y).toNat = (2 ^ n - y.toNat + x.toNat) % 2 ^ n
-- BitVec.toNat_sub'
@[bv_toNat] theorem toNat_sub' {n} (x y : BitVec n) :
    (x - y).toNat = ((x.toNat + (2^n - y.toNat)) % 2^n) 
Arguments: {n : Nat} (x y : BitVec n)
Goal: (x - y).toNat = (x.toNat + (2 ^ n - y.toNat)) % 2 ^ n
-- BitVec.toFin_sub
@[simp] theorem toFin_sub (x y : BitVec n) : (x - y).toFin = toFin x - toFin y 
Arguments: {n : Nat} (x y : BitVec n)
Goal: (x - y).toFin = x.toFin - y.toFin
-- BitVec.ofFin_sub
@[simp] theorem ofFin_sub (x : Fin (2^n)) (y : BitVec n) : .ofFin x - y = .ofFin (x - y.toFin) 
Arguments: {n : Nat} (x : Fin (2 ^ n)) (y : BitVec n)
Goal: { toFin := x } - y = { toFin := x - y.toFin }
-- BitVec.sub_ofFin
@[simp] theorem sub_ofFin (x : BitVec n) (y : Fin (2^n)) : x - .ofFin y = .ofFin (x.toFin - y) 
Arguments: {n : Nat} (x : BitVec n) (y : Fin (2 ^ n))
Goal: x - { toFin := y } = { toFin := x.toFin - y }
-- BitVec.ofNat_sub_ofNat
theorem ofNat_sub_ofNat {n} (x y : Nat) : BitVec.ofNat n x - BitVec.ofNat n y = .ofNat n ((2^n - y % 2^n) + x) 
Arguments: {n : Nat} (x y : Nat)
Goal: BitVec.ofNat n x - BitVec.ofNat n y = BitVec.ofNat n (2 ^ n - y % 2 ^ n + x)
-- BitVec.sub_zero
@[simp] protected theorem sub_zero (x : BitVec n) : x - 0#n = x 
Arguments: {n : Nat} (x : BitVec n)
Goal: x - 0#n = x
-- BitVec.sub_self
@[simp] protected theorem sub_self (x : BitVec n) : x - x = 0#n 
Arguments: {n : Nat} (x : BitVec n)
Goal: x - x = 0#n
-- BitVec.toNat_neg
@[simp, bv_toNat] theorem toNat_neg (x : BitVec n) : (- x).toNat = (2^n - x.toNat) % 2^n 
Arguments: {n : Nat} (x : BitVec n)
Goal: (-x).toNat = (2 ^ n - x.toNat) % 2 ^ n
-- BitVec.toFin_neg
@[simp] theorem toFin_neg (x : BitVec n) :
    (-x).toFin = Fin.ofNat' (2^n - x.toNat) (Nat.two_pow_pos _) 
Arguments: {n : Nat} (x : BitVec n)
Goal: (-x).toFin = Fin.ofNat' (2 ^ n - x.toNat) ⋯
-- BitVec.sub_toAdd
theorem sub_toAdd {n} (x y : BitVec n) : x - y = x + - y 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x - y = x + -y
-- BitVec.neg_zero
@[simp] theorem neg_zero (n:Nat) : -BitVec.ofNat n 0 = BitVec.ofNat n 0 
Arguments: (n : Nat)
Goal: -0#n = 0#n
-- BitVec.add_sub_cancel
theorem add_sub_cancel (x y : BitVec w) : x + y - y = x 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x + y - y = x
-- BitVec.sub_add_cancel
theorem sub_add_cancel (x y : BitVec w) : x - y + y = x 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x - y + y = x
-- BitVec.eq_sub_iff_add_eq
theorem eq_sub_iff_add_eq {x y z : BitVec w} : x = z - y ↔ x + y = z 
Arguments: {w : Nat} {x y z : BitVec w}
Goal: x = z - y ↔ x + y = z
-- BitVec.negOne_eq_allOnes
theorem negOne_eq_allOnes : -1#w = allOnes w 
Arguments: {w : Nat}
Goal: -1#w = BitVec.allOnes w
-- BitVec.neg_eq_not_add
theorem neg_eq_not_add (x : BitVec w) : -x = ~~~x + 1 
Arguments: {w : Nat} (x : BitVec w)
Goal: -x = ~~~x + 1
-- BitVec.mul_def
theorem mul_def {n} {x y : BitVec n} : x * y = (ofFin <| x.toFin * y.toFin) 
Arguments: {n : Nat} {x y : BitVec n}
Goal: x * y = { toFin := x.toFin * y.toFin }
-- BitVec.toNat_mul
@[simp, bv_toNat] theorem toNat_mul (x y : BitVec n) : (x * y).toNat = (x.toNat * y.toNat) % 2 ^ n 
Arguments: {n : Nat} (x y : BitVec n)
Goal: (x * y).toNat = x.toNat * y.toNat % 2 ^ n
-- BitVec.toFin_mul
@[simp] theorem toFin_mul (x y : BitVec n) : (x * y).toFin = (x.toFin * y.toFin) 
Arguments: {n : Nat} (x y : BitVec n)
Goal: (x * y).toFin = x.toFin * y.toFin
-- BitVec.mul_comm
protected theorem mul_comm (x y : BitVec w) : x * y = y * x 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x * y = y * x
-- BitVec.mul_assoc
protected theorem mul_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.mul_one
@[simp] protected theorem mul_one (x : BitVec w) : x * 1#w = x 
Arguments: {w : Nat} (x : BitVec w)
Goal: x * 1#w = x
-- BitVec.one_mul
@[simp] protected theorem one_mul (x : BitVec w) : 1#w * x = x 
Arguments: {w : Nat} (x : BitVec w)
Goal: 1#w * x = x
-- BitVec.toInt_mul
@[simp, bv_toNat] theorem toInt_mul (x y : BitVec w) :
  (x * y).toInt = (x.toInt * y.toInt).bmod (2^w) 
Arguments: {w : Nat} (x y : BitVec w)
Goal: (x * y).toInt = (x.toInt * y.toInt).bmod (2 ^ w)
-- BitVec.ofInt_mul
theorem ofInt_mul {n} (x y : Int) : BitVec.ofInt n (x * y) =
    BitVec.ofInt n x * BitVec.ofInt n y 
Arguments: {n : Nat} (x y : Int)
Goal: BitVec.ofInt n (x * y) = BitVec.ofInt n x * BitVec.ofInt n y
-- BitVec.le_def
@[bv_toNat] theorem le_def (x y : BitVec n) :
  x ≤ y ↔ x.toNat ≤ y.toNat 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x ≤ y ↔ x.toNat ≤ y.toNat
-- BitVec.le_ofFin
@[simp] theorem le_ofFin (x : BitVec n) (y : Fin (2^n)) :
  x ≤ BitVec.ofFin y ↔ x.toFin ≤ y 
Arguments: {n : Nat} (x : BitVec n) (y : Fin (2 ^ n))
Goal: x ≤ { toFin := y } ↔ x.toFin ≤ y
-- BitVec.ofFin_le
@[simp] theorem ofFin_le (x : Fin (2^n)) (y : BitVec n) :
  BitVec.ofFin x ≤ y ↔ x ≤ y.toFin 
Arguments: {n : Nat} (x : Fin (2 ^ n)) (y : BitVec n)
Goal: { toFin := x } ≤ y ↔ x ≤ y.toFin
-- BitVec.ofNat_le_ofNat
@[simp] theorem ofNat_le_ofNat {n} (x y : Nat) : (BitVec.ofNat n x) ≤ (BitVec.ofNat n y) ↔ x % 2^n ≤ y % 2^n 
Arguments: {n : Nat} (x y : Nat)
Goal: BitVec.ofNat n x ≤ BitVec.ofNat n y ↔ x % 2 ^ n ≤ y % 2 ^ n
-- BitVec.lt_def
@[bv_toNat] theorem lt_def (x y : BitVec n) :
  x < y ↔ x.toNat < y.toNat 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x < y ↔ x.toNat < y.toNat
-- BitVec.lt_ofFin
@[simp] theorem lt_ofFin (x : BitVec n) (y : Fin (2^n)) :
  x < BitVec.ofFin y ↔ x.toFin < y 
Arguments: {n : Nat} (x : BitVec n) (y : Fin (2 ^ n))
Goal: x < { toFin := y } ↔ x.toFin < y
-- BitVec.ofFin_lt
@[simp] theorem ofFin_lt (x : Fin (2^n)) (y : BitVec n) :
  BitVec.ofFin x < y ↔ x < y.toFin 
Arguments: {n : Nat} (x : Fin (2 ^ n)) (y : BitVec n)
Goal: { toFin := x } < y ↔ x < y.toFin
-- BitVec.ofNat_lt_ofNat
@[simp] theorem ofNat_lt_ofNat {n} (x y : Nat) : BitVec.ofNat n x < BitVec.ofNat n y ↔ x % 2^n < y % 2^n 
Arguments: {n : Nat} (x y : Nat)
Goal: BitVec.ofNat n x < BitVec.ofNat n y ↔ x % 2 ^ n < y % 2 ^ n
-- BitVec.lt_of_le_ne
protected theorem lt_of_le_ne (x y : BitVec n) (h1 : x <= y) (h2 : ¬ x = y) : x < y 
Arguments: {n : Nat} (x y : BitVec n) (h1 : x ≤ y) (h2 : ¬x = y)
Goal: x < y
-- BitVec.getLsb_intMax_eq
theorem getLsb_intMax_eq (w : Nat) : (intMax w).getLsb i = decide (i < w) 
Arguments: {i : Nat} (w : Nat)
Goal: (BitVec.intMax w).getLsb i = decide (i < w)
-- BitVec.toNat_intMax_eq
theorem toNat_intMax_eq : (intMax w).toNat = 2^w - 1 
Arguments: {w : Nat}
Goal: (BitVec.intMax w).toNat = 2 ^ w - 1
-- BitVec.getMsb_ofBoolListBE
@[simp] theorem getMsb_ofBoolListBE : (ofBoolListBE bs).getMsb i = bs.getD i false 
Arguments: {bs : List Bool} {i : Nat}
Goal: (BitVec.ofBoolListBE bs).getMsb i = bs.getD i false
-- BitVec.getLsb_ofBoolListBE
@[simp] theorem getLsb_ofBoolListBE :
    (ofBoolListBE bs).getLsb i = (decide (i < bs.length) && bs.getD (bs.length - 1 - i) false) 
Arguments: {bs : List Bool} {i : Nat}
Goal: (BitVec.ofBoolListBE bs).getLsb i = (decide (i < bs.length) && bs.getD (bs.length - 1 - i) false)
-- BitVec.getLsb_ofBoolListLE
@[simp] theorem getLsb_ofBoolListLE : (ofBoolListLE bs).getLsb i = bs.getD i false 
Arguments: {bs : List Bool} {i : Nat}
Goal: (BitVec.ofBoolListLE bs).getLsb i = bs.getD i false
-- BitVec.getMsb_ofBoolListLE
@[simp] theorem getMsb_ofBoolListLE :
    (ofBoolListLE bs).getMsb i = (decide (i < bs.length) && bs.getD (bs.length - 1 - i) false) 
Arguments: {bs : List Bool} {i : Nat}
Goal: (BitVec.ofBoolListLE bs).getMsb i = (decide (i < bs.length) && bs.getD (bs.length - 1 - i) false)
-- BitVec.rotateLeft_mod_eq_rotateLeft
@[simp]
theorem rotateLeft_mod_eq_rotateLeft {x : BitVec w} {r : Nat} :
    x.rotateLeft (r % w) = x.rotateLeft r 
Arguments: {w : Nat} {x : BitVec w} {r : Nat}
Goal: x.rotateLeft (r % w) = x.rotateLeft r
-- BitVec.rotateLeft_eq_rotateLeftAux_of_lt
theorem rotateLeft_eq_rotateLeftAux_of_lt {x : BitVec w} {r : Nat} (hr : r < w) :
    x.rotateLeft r = x.rotateLeftAux r 
Arguments: {w : Nat} {x : BitVec w} {r : Nat} (hr : r < w)
Goal: x.rotateLeft r = x.rotateLeftAux r
-- BitVec.getLsb_rotateLeftAux_of_le
theorem getLsb_rotateLeftAux_of_le {x : BitVec w} {r : Nat} {i : Nat} (hi : i < r) :
    (x.rotateLeftAux r).getLsb i = x.getLsb (w - r + i) 
Arguments: {w : Nat} {x : BitVec w} {r i : Nat} (hi : i < r)
Goal: (x.rotateLeftAux r).getLsb i = x.getLsb (w - r + i)
-- BitVec.getLsb_rotateLeftAux_of_geq
theorem getLsb_rotateLeftAux_of_geq {x : BitVec w} {r : Nat} {i : Nat} (hi : i ≥ r) :
    (x.rotateLeftAux r).getLsb i = (decide (i < w) && x.getLsb (i - r)) 
Arguments: {w : Nat} {x : BitVec w} {r i : Nat} (hi : i ≥ r)
Goal: (x.rotateLeftAux r).getLsb i = (decide (i < w) && x.getLsb (i - r))
-- BitVec.getLsb_rotateLeft_of_le
theorem getLsb_rotateLeft_of_le {x : BitVec w} {r i : Nat} (hr: r < w) :
    (x.rotateLeft r).getLsb i =
      cond (i < r)
      (x.getLsb (w - r + i))
      (decide (i < w) && x.getLsb (i - r)) 
Arguments: {w : Nat} {x : BitVec w} {r i : Nat} (hr : r < w)
Goal: (x.rotateLeft r).getLsb i = bif decide (i < r) then x.getLsb (w - r + i) else decide (i < w) && x.getLsb (i - r)
-- BitVec.getLsb_rotateLeft
@[simp]
theorem getLsb_rotateLeft {x : BitVec w} {r i : Nat}  :
    (x.rotateLeft r).getLsb i =
      cond (i < r % w)
      (x.getLsb (w - (r % w) + i))
      (decide (i < w) && x.getLsb (i - (r % w))) 
Arguments: {w : Nat} {x : BitVec w} {r i : Nat}
Goal: (x.rotateLeft r).getLsb i =
  bif decide (i < r % w) then x.getLsb (w - r % w + i) else decide (i < w) && x.getLsb (i - r % w)
-- BitVec.getLsb_rotateRightAux_of_le
theorem getLsb_rotateRightAux_of_le {x : BitVec w} {r : Nat} {i : Nat} (hi : i < w - r) :
    (x.rotateRightAux r).getLsb i = x.getLsb (r + i) 
Arguments: {w : Nat} {x : BitVec w} {r i : Nat} (hi : i < w - r)
Goal: (x.rotateRightAux r).getLsb i = x.getLsb (r + i)
-- BitVec.getLsb_rotateRightAux_of_geq
theorem getLsb_rotateRightAux_of_geq {x : BitVec w} {r : Nat} {i : Nat} (hi : i ≥ w - r) :
    (x.rotateRightAux r).getLsb i = (decide (i < w) && x.getLsb (i - (w - r))) 
Arguments: {w : Nat} {x : BitVec w} {r i : Nat} (hi : i ≥ w - r)
Goal: (x.rotateRightAux r).getLsb i = (decide (i < w) && x.getLsb (i - (w - r)))
-- BitVec.rotateRight_eq_rotateRightAux_of_lt
theorem rotateRight_eq_rotateRightAux_of_lt {x : BitVec w} {r : Nat} (hr : r < w) :
    x.rotateRight r = x.rotateRightAux r 
Arguments: {w : Nat} {x : BitVec w} {r : Nat} (hr : r < w)
Goal: x.rotateRight r = x.rotateRightAux r
-- BitVec.rotateRight_mod_eq_rotateRight
@[simp]
theorem rotateRight_mod_eq_rotateRight {x : BitVec w} {r : Nat} :
    x.rotateRight (r % w) = x.rotateRight r 
Arguments: {w : Nat} {x : BitVec w} {r : Nat}
Goal: x.rotateRight (r % w) = x.rotateRight r
-- BitVec.getLsb_rotateRight_of_le
theorem getLsb_rotateRight_of_le {x : BitVec w} {r i : Nat} (hr: r < w) :
    (x.rotateRight r).getLsb i =
      cond (i < w - r)
      (x.getLsb (r + i))
      (decide (i < w) && x.getLsb (i - (w - r))) 
Arguments: {w : Nat} {x : BitVec w} {r i : Nat} (hr : r < w)
Goal: (x.rotateRight r).getLsb i = bif decide (i < w - r) then x.getLsb (r + i) else decide (i < w) && x.getLsb (i - (w - r))