mathlib docs: core.init.data.nat.bitwise

source

def nat.bodd_div2 (a : ℕ) :

bool × ℕ

Equations

n.succ.bodd_div2 = nat.bodd_div2._match_1 n.bodd_div2
0.bodd_div2 = (ff, 0)
nat.bodd_div2._match_1 (tt, m) = (ff, m.succ)
nat.bodd_div2._match_1 (ff, m) = (tt, m)

source

def nat.div2 (n : ℕ) :

ℕ

Equations

n.div2 = n.bodd_div2.snd

source

def nat.bodd (n : ℕ) :

bool

Equations

n.bodd = n.bodd_div2.fst

source

@[simp]

theorem nat.bodd_zero :

0.bodd = ff

source

@[simp]

theorem nat.bodd_one :

1.bodd = tt

source

@[simp]

theorem nat.bodd_two :

2.bodd = ff

source

@[simp]

theorem nat.bodd_succ (n : ℕ) :

n.succ.bodd = !n.bodd

source

@[simp]

theorem nat.bodd_add (m n : ℕ) :

(m + n).bodd = bxor m.bodd n.bodd

source

@[simp]

theorem nat.bodd_mul (m n : ℕ) :

(m * n).bodd = m.bodd && n.bodd

source

theorem nat.mod_two_of_bodd (n : ℕ) :

n % 2 = cond n.bodd 1 0

source

@[simp]

theorem nat.div2_zero :

0.div2 = 0

source

@[simp]

theorem nat.div2_one :

1.div2 = 0

source

@[simp]

theorem nat.div2_two :

2.div2 = 1

source

@[simp]

theorem nat.div2_succ (n : ℕ) :

n.succ.div2 = cond n.bodd n.div2.succ n.div2

source

theorem nat.bodd_add_div2 (n : ℕ) :

cond n.bodd 1 0 + 2 * n.div2 = n

source

theorem nat.div2_val (n : ℕ) :

n.div2 = n / 2

source

def nat.bit (b : bool) (a : ℕ) :

ℕ

Equations

nat.bit b = cond b bit1 bit0

source

theorem nat.bit0_val (n : ℕ) :

bit0 n = 2 * n

source

theorem nat.bit1_val (n : ℕ) :

bit1 n = 2 * n + 1

source

theorem nat.bit_val (b : bool) (n : ℕ) :

nat.bit b n = 2 * n + cond b 1 0

source

theorem nat.bit_decomp (n : ℕ) :

nat.bit n.bodd n.div2 = n

source

def nat.bit_cases_on {C : ℕ → Sort u} (n : ℕ) (h : Π (b : bool) (n : ℕ), C (nat.bit b n)) :

C n

Equations

n.bit_cases_on h = _.mpr (h n.bodd n.div2)

source

@[simp]

theorem nat.bit_zero :

nat.bit ff 0 = 0

source

def nat.shiftl' (b : bool) (m a : ℕ) :

ℕ

Equations

nat.shiftl' b m (n + 1) = nat.bit b (nat.shiftl' b m n)
nat.shiftl' b m 0 = m

source

def nat.shiftl (a a_1 : ℕ) :

ℕ

Equations

nat.shiftl = nat.shiftl' ff

source

@[simp]

theorem nat.shiftl_zero (m : ℕ) :

m.shiftl 0 = m

source

@[simp]

theorem nat.shiftl_succ (m n : ℕ) :

m.shiftl (n + 1) = bit0 (m.shiftl n)

source

def nat.shiftr (a a_1 : ℕ) :

ℕ

Equations

m.shiftr (n + 1) = (m.shiftr n).div2
m.shiftr 0 = m

source

def nat.test_bit (m n : ℕ) :

bool

Equations

m.test_bit n = (m.shiftr n).bodd

source

def nat.binary_rec {C : ℕ → Sort u} (z : C 0) (f : Π (b : bool) (n : ℕ), C n → C (nat.bit b n)) (n : ℕ) :

C n

Equations

nat.binary_rec z f n = dite (n = 0) (λ (n0 : n = 0), _.mpr z) (λ (n0 : ¬n = 0), let n' : ℕ := n.div2 in _.mpr (f n.bodd n' (nat.binary_rec z f n')))

source

def nat.size (a : ℕ) :

ℕ

Equations

nat.size = nat.binary_rec 0 (λ (_x : bool) (_x : ℕ), nat.succ)

source

def nat.bits (a : ℕ) :

list bool

Equations

nat.bits = nat.binary_rec list.nil (λ (b : bool) (_x : ℕ) (IH : list bool), b :: IH)

source

def nat.bitwise (f : bool → bool → bool) (a a_1 : ℕ) :

ℕ

Equations

nat.bitwise f = nat.binary_rec (λ (n : ℕ), cond (f ff tt) n 0) (λ (a : bool) (m : ℕ) (Ia : ℕ → ℕ), nat.binary_rec (cond (f tt ff) (nat.bit a m) 0) (λ (b : bool) (n _x : ℕ), nat.bit (f a b) (Ia n)))

source

def nat.lor (a a_1 : ℕ) :

ℕ

Equations

nat.lor = nat.bitwise bor

source

def nat.land (a a_1 : ℕ) :

ℕ

Equations

nat.land = nat.bitwise band

source

def nat.ldiff (a a_1 : ℕ) :

ℕ

Equations

nat.ldiff = nat.bitwise (λ (a b : bool), a && !b)

source

def nat.lxor (a a_1 : ℕ) :

ℕ

Equations

nat.lxor = nat.bitwise bxor

source

@[simp]

theorem nat.binary_rec_zero {C : ℕ → Sort u} (z : C 0) (f : Π (b : bool) (n : ℕ), C n → C (nat.bit b n)) :

nat.binary_rec z f 0 = z

source

theorem nat.bodd_bit (b : bool) (n : ℕ) :

(nat.bit b n).bodd = b

source

theorem nat.div2_bit (b : bool) (n : ℕ) :

(nat.bit b n).div2 = n

source

theorem nat.shiftl'_add (b : bool) (m n k : ℕ) :

nat.shiftl' b m (n + k) = nat.shiftl' b (nat.shiftl' b m n) k

source

theorem nat.shiftl_add (m n k : ℕ) :

m.shiftl (n + k) = (m.shiftl n).shiftl k

source

theorem nat.shiftr_add (m n k : ℕ) :

m.shiftr (n + k) = (m.shiftr n).shiftr k

source

theorem nat.shiftl'_sub (b : bool) (m : ℕ) {n k : ℕ} (a : k ≤ n) :

nat.shiftl' b m (n - k) = (nat.shiftl' b m n).shiftr k

source

theorem nat.shiftl_sub (m : ℕ) {n k : ℕ} (a : k ≤ n) :

m.shiftl (n - k) = (m.shiftl n).shiftr k

source

@[simp]

theorem nat.test_bit_zero (b : bool) (n : ℕ) :

(nat.bit b n).test_bit 0 = b

source

theorem nat.test_bit_succ (m : ℕ) (b : bool) (n : ℕ) :

(nat.bit b n).test_bit m.succ = n.test_bit m

source

theorem nat.binary_rec_eq {C : ℕ → Sort u} {z : C 0} {f : Π (b : bool) (n : ℕ), C n → C (nat.bit b n)} (h : f ff 0 z = z) (b : bool) (n : ℕ) :

nat.binary_rec z f (nat.bit b n) = f b n (nat.binary_rec z f n)

source

theorem nat.bitwise_bit_aux {f : bool → bool → bool} (h : f ff ff = ff) :

nat.binary_rec (cond (f tt ff) (nat.bit ff 0) 0) (λ (b : bool) (n : ℕ) (_x : (λ (_x : ℕ), ℕ) n), nat.bit (f ff b) (cond (f ff tt) n 0)) = λ (n : ℕ), cond (f ff tt) n 0

source

@[simp]

theorem nat.bitwise_zero_left (f : bool → bool → bool) (n : ℕ) :

nat.bitwise f 0 n = cond (f ff tt) n 0

source

@[simp]

theorem nat.bitwise_zero_right (f : bool → bool → bool) (h : f ff ff = ff) (m : ℕ) :

nat.bitwise f m 0 = cond (f tt ff) m 0

source

@[simp]

theorem nat.bitwise_zero (f : bool → bool → bool) :

nat.bitwise f 0 0 = 0

source

@[simp]

theorem nat.bitwise_bit {f : bool → bool → bool} (h : f ff ff = ff) (a : bool) (m : ℕ) (b : bool) (n : ℕ) :

nat.bitwise f (nat.bit a m) (nat.bit b n) = nat.bit (f a b) (nat.bitwise f m n)

source

theorem nat.bitwise_swap {f : bool → bool → bool} (h : f ff ff = ff) :

nat.bitwise (function.swap f) = function.swap (nat.bitwise f)

source

@[simp]

theorem nat.lor_bit (a : bool) (m : ℕ) (b : bool) (n : ℕ) :

(nat.bit a m).lor (nat.bit b n) = nat.bit (a || b) (m.lor n)

source

@[simp]

theorem nat.land_bit (a : bool) (m : ℕ) (b : bool) (n : ℕ) :

(nat.bit a m).land (nat.bit b n) = nat.bit (a && b) (m.land n)

source

@[simp]

theorem nat.ldiff_bit (a : bool) (m : ℕ) (b : bool) (n : ℕ) :

(nat.bit a m).ldiff (nat.bit b n) = nat.bit (a && !b) (m.ldiff n)

source

@[simp]

theorem nat.lxor_bit (a : bool) (m : ℕ) (b : bool) (n : ℕ) :

(nat.bit a m).lxor (nat.bit b n) = nat.bit (bxor a b) (m.lxor n)

source

@[simp]

theorem nat.test_bit_bitwise {f : bool → bool → bool} (h : f ff ff = ff) (m n k : ℕ) :

(nat.bitwise f m n).test_bit k = f (m.test_bit k) (n.test_bit k)

source

@[simp]

theorem nat.test_bit_lor (m n k : ℕ) :

(m.lor n).test_bit k = m.test_bit k || n.test_bit k

source

@[simp]

theorem nat.test_bit_land (m n k : ℕ) :

(m.land n).test_bit k = m.test_bit k && n.test_bit k

source

@[simp]

theorem nat.test_bit_ldiff (m n k : ℕ) :

(m.ldiff n).test_bit k = m.test_bit k && !n.test_bit k

source

@[simp]

theorem nat.test_bit_lxor (m n k : ℕ) :

(m.lxor n).test_bit k = bxor (m.test_bit k) (n.test_bit k)