Theory WordBitwise

Up to index of Isabelle/HOL/HOL-Word

theory WordBitwise
imports WordArith
begin

(* 
    ID:         $Id: WordBitwise.thy,v 1.10 2007/11/08 19:08:01 wenzelm Exp $
    Author:     Jeremy Dawson and Gerwin Klein, NICTA

  contains theorems to do with bit-wise (logical) operations on words
*)

header {* Bitwise Operations on Words *}

theory WordBitwise imports WordArith begin

lemmas bin_log_bintrs = bin_trunc_not bin_trunc_xor bin_trunc_and bin_trunc_or
  
(* following definitions require both arithmetic and bit-wise word operations *)

(* to get word_no_log_defs from word_log_defs, using bin_log_bintrs *)
lemmas wils1 = bin_log_bintrs [THEN word_ubin.norm_eq_iff [THEN iffD1],
  folded word_ubin.eq_norm, THEN eq_reflection, standard]

(* the binary operations only *)
lemmas word_log_binary_defs = 
  word_and_def word_or_def word_xor_def

lemmas word_no_log_defs [simp] = 
  word_not_def  [where a="number_of a", 
                 unfolded word_no_wi wils1, folded word_no_wi, standard]
  word_log_binary_defs [where a="number_of a" and b="number_of b",
                        unfolded word_no_wi wils1, folded word_no_wi, standard]

lemmas word_wi_log_defs = word_no_log_defs [unfolded word_no_wi]

lemma uint_or: "uint (x OR y) = (uint x) OR (uint y)"
  by (simp add: word_or_def word_no_wi [symmetric] number_of_is_id
                bin_trunc_ao(2) [symmetric])

lemma uint_and: "uint (x AND y) = (uint x) AND (uint y)"
  by (simp add: word_and_def number_of_is_id word_no_wi [symmetric]
                bin_trunc_ao(1) [symmetric]) 

lemma word_ops_nth_size:
  "n < size (x::'a::len0 word) ==> 
    (x OR y) !! n = (x !! n | y !! n) & 
    (x AND y) !! n = (x !! n & y !! n) & 
    (x XOR y) !! n = (x !! n ~= y !! n) & 
    (NOT x) !! n = (~ x !! n)"
  unfolding word_size word_no_wi word_test_bit_def word_log_defs
  by (clarsimp simp add : word_ubin.eq_norm nth_bintr bin_nth_ops)

lemma word_ao_nth:
  fixes x :: "'a::len0 word"
  shows "(x OR y) !! n = (x !! n | y !! n) & 
         (x AND y) !! n = (x !! n & y !! n)"
  apply (cases "n < size x")
   apply (drule_tac y = "y" in word_ops_nth_size)
   apply simp
  apply (simp add : test_bit_bin word_size)
  done

(* get from commutativity, associativity etc of int_and etc
  to same for word_and etc *)

lemmas bwsimps = 
  word_of_int_homs(2) 
  word_0_wi_Pls
  word_m1_wi_Min
  word_wi_log_defs

lemma word_bw_assocs:
  fixes x :: "'a::len0 word"
  shows
  "(x AND y) AND z = x AND y AND z"
  "(x OR y) OR z = x OR y OR z"
  "(x XOR y) XOR z = x XOR y XOR z"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
        word_of_int_Ex [where x=z]
  by (auto simp: bwsimps bbw_assocs)
  
lemma word_bw_comms:
  fixes x :: "'a::len0 word"
  shows
  "x AND y = y AND x"
  "x OR y = y OR x"
  "x XOR y = y XOR x"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
  by (auto simp: bwsimps bin_ops_comm)
  
lemma word_bw_lcs:
  fixes x :: "'a::len0 word"
  shows
  "y AND x AND z = x AND y AND z"
  "y OR x OR z = x OR y OR z"
  "y XOR x XOR z = x XOR y XOR z"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
        word_of_int_Ex [where x=z]
  by (auto simp: bwsimps)

lemma word_log_esimps [simp]:
  fixes x :: "'a::len0 word"
  shows
  "x AND 0 = 0"
  "x AND -1 = x"
  "x OR 0 = x"
  "x OR -1 = -1"
  "x XOR 0 = x"
  "x XOR -1 = NOT x"
  "0 AND x = 0"
  "-1 AND x = x"
  "0 OR x = x"
  "-1 OR x = -1"
  "0 XOR x = x"
  "-1 XOR x = NOT x"
  using word_of_int_Ex [where x=x] 
  by (auto simp: bwsimps)

lemma word_not_dist:
  fixes x :: "'a::len0 word"
  shows
  "NOT (x OR y) = NOT x AND NOT y"
  "NOT (x AND y) = NOT x OR NOT y"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
  by (auto simp: bwsimps bbw_not_dist)

lemma word_bw_same:
  fixes x :: "'a::len0 word"
  shows
  "x AND x = x"
  "x OR x = x"
  "x XOR x = 0"
  using word_of_int_Ex [where x=x] 
  by (auto simp: bwsimps)

lemma word_ao_absorbs [simp]:
  fixes x :: "'a::len0 word"
  shows
  "x AND (y OR x) = x"
  "x OR y AND x = x"
  "x AND (x OR y) = x"
  "y AND x OR x = x"
  "(y OR x) AND x = x"
  "x OR x AND y = x"
  "(x OR y) AND x = x"
  "x AND y OR x = x"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
  by (auto simp: bwsimps)

lemma word_not_not [simp]:
  "NOT NOT (x::'a::len0 word) = x"
  using word_of_int_Ex [where x=x] 
  by (auto simp: bwsimps)

lemma word_ao_dist:
  fixes x :: "'a::len0 word"
  shows "(x OR y) AND z = x AND z OR y AND z"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
        word_of_int_Ex [where x=z]   
  by (auto simp: bwsimps bbw_ao_dist simp del: bin_ops_comm)

lemma word_oa_dist:
  fixes x :: "'a::len0 word"
  shows "x AND y OR z = (x OR z) AND (y OR z)"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
        word_of_int_Ex [where x=z]   
  by (auto simp: bwsimps bbw_oa_dist simp del: bin_ops_comm)

lemma word_add_not [simp]: 
  fixes x :: "'a::len0 word"
  shows "x + NOT x = -1"
  using word_of_int_Ex [where x=x] 
  by (auto simp: bwsimps bin_add_not)

lemma word_plus_and_or [simp]:
  fixes x :: "'a::len0 word"
  shows "(x AND y) + (x OR y) = x + y"
  using word_of_int_Ex [where x=x] 
        word_of_int_Ex [where x=y] 
  by (auto simp: bwsimps plus_and_or)

lemma leoa:   
  fixes x :: "'a::len0 word"
  shows "(w = (x OR y)) ==> (y = (w AND y))" by auto
lemma leao: 
  fixes x' :: "'a::len0 word"
  shows "(w' = (x' AND y')) ==> (x' = (x' OR w'))" by auto 

lemmas word_ao_equiv = leao [COMP leoa [COMP iffI]]

lemma le_word_or2: "x <= x OR (y::'a::len0 word)"
  unfolding word_le_def uint_or
  by (auto intro: le_int_or) 

lemmas le_word_or1 = xtr3 [OF word_bw_comms (2) le_word_or2, standard]
lemmas word_and_le1 =
  xtr3 [OF word_ao_absorbs (4) [symmetric] le_word_or2, standard]
lemmas word_and_le2 =
  xtr3 [OF word_ao_absorbs (8) [symmetric] le_word_or2, standard]

lemma bl_word_not: "to_bl (NOT w) = map Not (to_bl w)" 
  unfolding to_bl_def word_log_defs
  by (simp add: bl_not_bin number_of_is_id word_no_wi [symmetric])

lemma bl_word_xor: "to_bl (v XOR w) = app2 op ~= (to_bl v) (to_bl w)" 
  unfolding to_bl_def word_log_defs bl_xor_bin
  by (simp add: number_of_is_id word_no_wi [symmetric])

lemma bl_word_or: "to_bl (v OR w) = app2 op | (to_bl v) (to_bl w)" 
  unfolding to_bl_def word_log_defs
  by (simp add: bl_or_bin number_of_is_id word_no_wi [symmetric])

lemma bl_word_and: "to_bl (v AND w) = app2 op & (to_bl v) (to_bl w)" 
  unfolding to_bl_def word_log_defs
  by (simp add: bl_and_bin number_of_is_id word_no_wi [symmetric])

lemma word_lsb_alt: "lsb (w::'a::len0 word) = test_bit w 0"
  by (auto simp: word_test_bit_def word_lsb_def)

lemma word_lsb_1_0: "lsb (1::'a::len word) & ~ lsb (0::'b::len0 word)"
  unfolding word_lsb_def word_1_no word_0_no by auto

lemma word_lsb_last: "lsb (w::'a::len word) = last (to_bl w)"
  apply (unfold word_lsb_def uint_bl bin_to_bl_def) 
  apply (rule_tac bin="uint w" in bin_exhaust)
  apply (cases "size w")
   apply auto
   apply (auto simp add: bin_to_bl_aux_alt)
  done

lemma word_lsb_int: "lsb w = (uint w mod 2 = 1)"
  unfolding word_lsb_def bin_last_mod by auto

lemma word_msb_sint: "msb w = (sint w < 0)" 
  unfolding word_msb_def
  by (simp add : sign_Min_lt_0 number_of_is_id)
  
lemma word_msb_no': 
  "w = number_of bin ==> msb (w::'a::len word) = bin_nth bin (size w - 1)"
  unfolding word_msb_def word_number_of_def
  by (clarsimp simp add: word_sbin.eq_norm word_size bin_sign_lem)

lemmas word_msb_no = refl [THEN word_msb_no', unfolded word_size]

lemma word_msb_nth': "msb (w::'a::len word) = bin_nth (uint w) (size w - 1)"
  apply (unfold word_size)
  apply (rule trans [OF _ word_msb_no])
  apply (simp add : word_number_of_def)
  done

lemmas word_msb_nth = word_msb_nth' [unfolded word_size]

lemma word_msb_alt: "msb (w::'a::len word) = hd (to_bl w)"
  apply (unfold word_msb_nth uint_bl)
  apply (subst hd_conv_nth)
  apply (rule length_greater_0_conv [THEN iffD1])
   apply simp
  apply (simp add : nth_bin_to_bl word_size)
  done

lemma word_set_nth:
  "set_bit w n (test_bit w n) = (w::'a::len0 word)"
  unfolding word_test_bit_def word_set_bit_def by auto

lemma bin_nth_uint':
  "bin_nth (uint w) n = (rev (bin_to_bl (size w) (uint w)) ! n & n < size w)"
  apply (unfold word_size)
  apply (safe elim!: bin_nth_uint_imp)
   apply (frule bin_nth_uint_imp)
   apply (fast dest!: bin_nth_bl)+
  done

lemmas bin_nth_uint = bin_nth_uint' [unfolded word_size]

lemma test_bit_bl: "w !! n = (rev (to_bl w) ! n & n < size w)"
  unfolding to_bl_def word_test_bit_def word_size
  by (rule bin_nth_uint)

lemma to_bl_nth: "n < size w ==> to_bl w ! n = w !! (size w - Suc n)"
  apply (unfold test_bit_bl)
  apply clarsimp
  apply (rule trans)
   apply (rule nth_rev_alt)
   apply (auto simp add: word_size)
  done

lemma test_bit_set: 
  fixes w :: "'a::len0 word"
  shows "(set_bit w n x) !! n = (n < size w & x)"
  unfolding word_size word_test_bit_def word_set_bit_def
  by (clarsimp simp add : word_ubin.eq_norm nth_bintr)

lemma test_bit_set_gen: 
  fixes w :: "'a::len0 word"
  shows "test_bit (set_bit w n x) m = 
         (if m = n then n < size w & x else test_bit w m)"
  apply (unfold word_size word_test_bit_def word_set_bit_def)
  apply (clarsimp simp add: word_ubin.eq_norm nth_bintr bin_nth_sc_gen)
  apply (auto elim!: test_bit_size [unfolded word_size]
              simp add: word_test_bit_def [symmetric])
  done

lemma of_bl_rep_False: "of_bl (replicate n False @ bs) = of_bl bs"
  unfolding of_bl_def bl_to_bin_rep_F by auto
  
lemma msb_nth':
  fixes w :: "'a::len word"
  shows "msb w = w !! (size w - 1)"
  unfolding word_msb_nth' word_test_bit_def by simp

lemmas msb_nth = msb_nth' [unfolded word_size]

lemmas msb0 = len_gt_0 [THEN diff_Suc_less, THEN
  word_ops_nth_size [unfolded word_size], standard]
lemmas msb1 = msb0 [where i = 0]
lemmas word_ops_msb = msb1 [unfolded msb_nth [symmetric, unfolded One_nat_def]]

lemmas lsb0 = len_gt_0 [THEN word_ops_nth_size [unfolded word_size], standard]
lemmas word_ops_lsb = lsb0 [unfolded word_lsb_alt]

lemma td_ext_nth':
  "n = size (w::'a::len0 word) ==> ofn = set_bits ==> [w, ofn g] = l ==> 
    td_ext test_bit ofn {f. ALL i. f i --> i < n} (%h i. h i & i < n)"
  apply (unfold word_size td_ext_def')
  apply safe
     apply (rule_tac [3] ext)
     apply (rule_tac [4] ext)
     apply (unfold word_size of_nth_def test_bit_bl)
     apply safe
       defer
       apply (clarsimp simp: word_bl.Abs_inverse)+
  apply (rule word_bl.Rep_inverse')
  apply (rule sym [THEN trans])
  apply (rule bl_of_nth_nth)
  apply simp
  apply (rule bl_of_nth_inj)
  apply (clarsimp simp add : test_bit_bl word_size)
  done

lemmas td_ext_nth = td_ext_nth' [OF refl refl refl, unfolded word_size]

interpretation test_bit:
  td_ext ["op !! :: 'a::len0 word => nat => bool"
          set_bits
          "{f. ∀i. f i --> i < len_of TYPE('a::len0)}"
          "(λh i. h i ∧ i < len_of TYPE('a::len0))"]
  by (rule td_ext_nth)

declare test_bit.Rep' [simp del]
declare test_bit.Rep' [rule del]

lemmas td_nth = test_bit.td_thm

lemma word_set_set_same: 
  fixes w :: "'a::len0 word"
  shows "set_bit (set_bit w n x) n y = set_bit w n y" 
  by (rule word_eqI) (simp add : test_bit_set_gen word_size)
    
lemma word_set_set_diff: 
  fixes w :: "'a::len0 word"
  assumes "m ~= n"
  shows "set_bit (set_bit w m x) n y = set_bit (set_bit w n y) m x" 
  by (rule word_eqI) (clarsimp simp add : test_bit_set_gen word_size prems)
    
lemma test_bit_no': 
  fixes w :: "'a::len0 word"
  shows "w = number_of bin ==> test_bit w n = (n < size w & bin_nth bin n)"
  unfolding word_test_bit_def word_number_of_def word_size
  by (simp add : nth_bintr [symmetric] word_ubin.eq_norm)

lemmas test_bit_no = 
  refl [THEN test_bit_no', unfolded word_size, THEN eq_reflection, standard]

lemma nth_0: "~ (0::'a::len0 word) !! n"
  unfolding test_bit_no word_0_no by auto

lemma nth_sint: 
  fixes w :: "'a::len word"
  defines "l ≡ len_of TYPE ('a)"
  shows "bin_nth (sint w) n = (if n < l - 1 then w !! n else w !! (l - 1))"
  unfolding sint_uint l_def
  by (clarsimp simp add: nth_sbintr word_test_bit_def [symmetric])

lemma word_lsb_no: 
  "lsb (number_of bin :: 'a :: len word) = (bin_last bin = bit.B1)"
  unfolding word_lsb_alt test_bit_no by auto

lemma word_set_no: 
  "set_bit (number_of bin::'a::len0 word) n b = 
    number_of (bin_sc n (if b then bit.B1 else bit.B0) bin)"
  apply (unfold word_set_bit_def word_number_of_def [symmetric])
  apply (rule word_eqI)
  apply (clarsimp simp: word_size bin_nth_sc_gen number_of_is_id 
                        test_bit_no nth_bintr)
  done

lemmas setBit_no = setBit_def [THEN trans [OF meta_eq_to_obj_eq word_set_no],
  simplified if_simps, THEN eq_reflection, standard]
lemmas clearBit_no = clearBit_def [THEN trans [OF meta_eq_to_obj_eq word_set_no],
  simplified if_simps, THEN eq_reflection, standard]

lemma to_bl_n1: 
  "to_bl (-1::'a::len0 word) = replicate (len_of TYPE ('a)) True"
  apply (rule word_bl.Abs_inverse')
   apply simp
  apply (rule word_eqI)
  apply (clarsimp simp add: word_size test_bit_no)
  apply (auto simp add: word_bl.Abs_inverse test_bit_bl word_size)
  done

lemma word_msb_n1: "msb (-1::'a::len word)"
  unfolding word_msb_alt word_msb_alt to_bl_n1 by simp

declare word_set_set_same [simp] word_set_nth [simp]
  test_bit_no [simp] word_set_no [simp] nth_0 [simp]
  setBit_no [simp] clearBit_no [simp]
  word_lsb_no [simp] word_msb_no [simp] word_msb_n1 [simp] word_lsb_1_0 [simp]

lemma word_set_nth_iff: 
  "(set_bit w n b = w) = (w !! n = b | n >= size (w::'a::len0 word))"
  apply (rule iffI)
   apply (rule disjCI)
   apply (drule word_eqD)
   apply (erule sym [THEN trans])
   apply (simp add: test_bit_set)
  apply (erule disjE)
   apply clarsimp
  apply (rule word_eqI)
  apply (clarsimp simp add : test_bit_set_gen)
  apply (drule test_bit_size)
  apply force
  done

lemma test_bit_2p': 
  "w = word_of_int (2 ^ n) ==> 
    w !! m = (m = n & m < size (w :: 'a :: len word))"
  unfolding word_test_bit_def word_size
  by (auto simp add: word_ubin.eq_norm nth_bintr nth_2p_bin)

lemmas test_bit_2p = refl [THEN test_bit_2p', unfolded word_size]

lemmas nth_w2p = test_bit_2p [unfolded of_int_number_of_eq
  word_of_int [symmetric] of_int_power]

lemma uint_2p: 
  "(0::'a::len word) < 2 ^ n ==> uint (2 ^ n::'a::len word) = 2 ^ n"
  apply (unfold word_arith_power_alt)
  apply (case_tac "len_of TYPE ('a)")
   apply clarsimp
  apply (case_tac "nat")
   apply clarsimp
   apply (case_tac "n")
    apply (clarsimp simp add : word_1_wi [symmetric])
   apply (clarsimp simp add : word_0_wi [symmetric])
  apply (drule word_gt_0 [THEN iffD1])
  apply (safe intro!: word_eqI bin_nth_lem ext)
     apply (auto simp add: test_bit_2p nth_2p_bin word_test_bit_def [symmetric])
  done

lemma word_of_int_2p: "(word_of_int (2 ^ n) :: 'a :: len word) = 2 ^ n" 
  apply (unfold word_arith_power_alt)
  apply (case_tac "len_of TYPE ('a)")
   apply clarsimp
  apply (case_tac "nat")
   apply (rule word_ubin.norm_eq_iff [THEN iffD1]) 
   apply (rule box_equals) 
     apply (rule_tac [2] bintr_ariths (1))+ 
   apply (clarsimp simp add : number_of_is_id)
  apply simp 
  done

lemma bang_is_le: "x !! m ==> 2 ^ m <= (x :: 'a :: len word)" 
  apply (rule xtr3) 
  apply (rule_tac [2] y = "x" in le_word_or2)
  apply (rule word_eqI)
  apply (auto simp add: word_ao_nth nth_w2p word_size)
  done

lemma word_clr_le: 
  fixes w :: "'a::len0 word"
  shows "w >= set_bit w n False"
  apply (unfold word_set_bit_def word_le_def word_ubin.eq_norm)
  apply simp
  apply (rule order_trans)
   apply (rule bintr_bin_clr_le)
  apply simp
  done

lemma word_set_ge: 
  fixes w :: "'a::len word"
  shows "w <= set_bit w n True"
  apply (unfold word_set_bit_def word_le_def word_ubin.eq_norm)
  apply simp
  apply (rule order_trans [OF _ bintr_bin_set_ge])
  apply simp
  done

end


lemma bin_log_bintrs:

  bintrunc n (NOT bintrunc n x) = bintrunc n (NOT x)
  bintrunc n (bintrunc n x XOR bintrunc n y) = bintrunc n (x XOR y)
  bintrunc n (bintrunc n x AND bintrunc n y) = bintrunc n (x AND y)
  bintrunc n (bintrunc n x OR bintrunc n y) = bintrunc n (x OR y)

lemma wils1:

  word_of_int (NOT uint (word_of_int x)) == word_of_int (NOT x)
  word_of_int (uint (word_of_int x) XOR uint (word_of_int y)) ==
  word_of_int (x XOR y)
  word_of_int (uint (word_of_int x) AND uint (word_of_int y)) ==
  word_of_int (x AND y)
  word_of_int (uint (word_of_int x) OR uint (word_of_int y)) ==
  word_of_int (x OR y)

lemma word_log_binary_defs:

  a AND b == word_of_int (uint a AND uint b)
  a OR b == word_of_int (uint a OR uint b)
  a XOR b == word_of_int (uint a XOR uint b)

lemma word_no_log_defs:

  NOT number_of a == number_of (NOT a)
  number_of a AND number_of b == number_of (a AND b)
  number_of a OR number_of b == number_of (a OR b)
  number_of a XOR number_of b == number_of (a XOR b)

lemma word_wi_log_defs:

  NOT word_of_int a == word_of_int (NOT a)
  word_of_int a AND word_of_int b == word_of_int (a AND b)
  word_of_int a OR word_of_int b == word_of_int (a OR b)
  word_of_int a XOR word_of_int b == word_of_int (a XOR b)

lemma uint_or:

  uint (x OR y) = uint x OR uint y

lemma uint_and:

  uint (x AND y) = uint x AND uint y

lemma word_ops_nth_size:

  n < size x
  ==> (x OR y) !! n = (x !! ny !! n) ∧
      (x AND y) !! n = (x !! ny !! n) ∧
      (x XOR y) !! n = (x !! n  y !! n) ∧ (NOT x) !! n = (¬ x !! n)

lemma word_ao_nth:

  (x OR y) !! n = (x !! ny !! n) ∧ (x AND y) !! n = (x !! ny !! n)

lemma bwsimps:

  word_of_int a + word_of_int b = word_of_int (a + b)
  0 == word_of_int Numeral.Pls
  -1 = word_of_int Numeral.Min
  NOT word_of_int a == word_of_int (NOT a)
  word_of_int a AND word_of_int b == word_of_int (a AND b)
  word_of_int a OR word_of_int b == word_of_int (a OR b)
  word_of_int a XOR word_of_int b == word_of_int (a XOR b)

lemma word_bw_assocs:

  (x AND y) AND z = x AND y AND z
  (x OR y) OR z = x OR y OR z
  (x XOR y) XOR z = x XOR y XOR z

lemma word_bw_comms:

  x AND y = y AND x
  x OR y = y OR x
  x XOR y = y XOR x

lemma word_bw_lcs:

  y AND x AND z = x AND y AND z
  y OR x OR z = x OR y OR z
  y XOR x XOR z = x XOR y XOR z

lemma word_log_esimps:

  x AND 0 = 0
  x AND -1 = x
  x OR 0 = x
  x OR -1 = -1
  x XOR 0 = x
  x XOR -1 = NOT x
  0 AND x = 0
  -1 AND x = x
  0 OR x = x
  -1 OR x = -1
  0 XOR x = x
  -1 XOR x = NOT x

lemma word_not_dist:

  NOT (x OR y) = NOT x AND NOT y
  NOT (x AND y) = NOT x OR NOT y

lemma word_bw_same:

  x AND x = x
  x OR x = x
  x XOR x = 0

lemma word_ao_absorbs:

  x AND (y OR x) = x
  x OR y AND x = x
  x AND (x OR y) = x
  y AND x OR x = x
  (y OR x) AND x = x
  x OR x AND y = x
  (x OR y) AND x = x
  x AND y OR x = x

lemma word_not_not:

  NOT NOT x = x

lemma word_ao_dist:

  (x OR y) AND z = x AND z OR y AND z

lemma word_oa_dist:

  x AND y OR z = (x OR z) AND (y OR z)

lemma word_add_not:

  x + NOT x = -1

lemma word_plus_and_or:

  (x AND y) + (x OR y) = x + y

lemma leoa:

  w = x OR y ==> y = w AND y

lemma leao:

  w' = x' AND y' ==> x' = x' OR w'

lemma word_ao_equiv:

  (w = w OR w') = (w' = w AND w')

lemma le_word_or2:

  x  x OR y

lemma le_word_or1:

  c  y OR c

lemma word_and_le1:

  y AND a  a

lemma word_and_le2:

  a AND y  a

lemma bl_word_not:

  to_bl (NOT w) = map Not (to_bl w)

lemma bl_word_xor:

  to_bl (v XOR w) = app2 op  (to_bl v) (to_bl w)

lemma bl_word_or:

  to_bl (v OR w) = app2 op ∨ (to_bl v) (to_bl w)

lemma bl_word_and:

  to_bl (v AND w) = app2 op ∧ (to_bl v) (to_bl w)

lemma word_lsb_alt:

  lsb w = w !! 0

lemma word_lsb_1_0:

  lsb 1 ∧ ¬ lsb 0

lemma word_lsb_last:

  lsb w = last (to_bl w)

lemma word_lsb_int:

  lsb w = (uint w mod 2 = 1)

lemma word_msb_sint:

  msb w = (sint w < 0)

lemma word_msb_no':

  w = number_of bin ==> msb w = bin_nth bin (size w - 1)

lemma word_msb_no:

  msb (number_of bin) = bin_nth bin (len_of TYPE('a) - 1)

lemma word_msb_nth':

  msb w = bin_nth (uint w) (size w - 1)

lemma word_msb_nth:

  msb w = bin_nth (uint w) (len_of TYPE('a) - 1)

lemma word_msb_alt:

  msb w = hd (to_bl w)

lemma word_set_nth:

  set_bit w n (w !! n) = w

lemma bin_nth_uint':

  bin_nth (uint w) n = (rev (bin_to_bl (size w) (uint w)) ! nn < size w)

lemma bin_nth_uint:

  bin_nth (uint w) n =
  (rev (bin_to_bl (len_of TYPE('a)) (uint w)) ! nn < len_of TYPE('a))

lemma test_bit_bl:

  w !! n = (rev (to_bl w) ! nn < size w)

lemma to_bl_nth:

  n < size w ==> to_bl w ! n = w !! (size w - Suc n)

lemma test_bit_set:

  set_bit w n x !! n = (n < size wx)

lemma test_bit_set_gen:

  set_bit w n x !! m = (if m = n then n < size wx else w !! m)

lemma of_bl_rep_False:

  of_bl (replicate n False @ bs) = of_bl bs

lemma msb_nth':

  msb w = w !! (size w - 1)

lemma msb_nth:

  msb w = w !! (len_of TYPE('a) - 1)

lemma msb0:

  (x OR y) !! (len_of TYPE('a) - Suc i) =
  (x !! (len_of TYPE('a) - Suc i) ∨ y !! (len_of TYPE('a) - Suc i)) ∧
  (x AND y) !! (len_of TYPE('a) - Suc i) =
  (x !! (len_of TYPE('a) - Suc i) ∧ y !! (len_of TYPE('a) - Suc i)) ∧
  (x XOR y) !! (len_of TYPE('a) - Suc i) =
  (x !! (len_of TYPE('a) - Suc i)  y !! (len_of TYPE('a) - Suc i)) ∧
  (NOT x) !! (len_of TYPE('a) - Suc i) = (¬ x !! (len_of TYPE('a) - Suc i))

lemma msb1:

  (x OR y) !! (len_of TYPE('a) - Suc 0) =
  (x !! (len_of TYPE('a) - Suc 0) ∨ y !! (len_of TYPE('a) - Suc 0)) ∧
  (x AND y) !! (len_of TYPE('a) - Suc 0) =
  (x !! (len_of TYPE('a) - Suc 0) ∧ y !! (len_of TYPE('a) - Suc 0)) ∧
  (x XOR y) !! (len_of TYPE('a) - Suc 0) =
  (x !! (len_of TYPE('a) - Suc 0)  y !! (len_of TYPE('a) - Suc 0)) ∧
  (NOT x) !! (len_of TYPE('a) - Suc 0) = (¬ x !! (len_of TYPE('a) - Suc 0))

lemma word_ops_msb:

  msb (x OR y) = (msb x ∨ msb y) ∧
  msb (x AND y) = (msb x ∧ msb y) ∧
  msb (x XOR y) = (msb x  msb y) ∧ msb (NOT x) = (¬ msb x)

lemma lsb0:

  (x OR y) !! 0 = (x !! 0y !! 0) ∧
  (x AND y) !! 0 = (x !! 0y !! 0) ∧
  (x XOR y) !! 0 = (x !! 0  y !! 0) ∧ (NOT x) !! 0 = (¬ x !! 0)

lemma word_ops_lsb:

  (x OR y) !! 0 = (x !! 0y !! 0) ∧
  (x AND y) !! 0 = (x !! 0y !! 0) ∧
  (x XOR y) !! 0 = (x !! 0  y !! 0) ∧ (NOT x) !! 0 = (¬ x !! 0)

lemma td_ext_nth':

  [| n = size w; ofn = set_bits; [w, ofn g] = l |]
  ==> td_ext op !! ofn {f. ∀i. f i --> i < n} (λh i. h ii < n)

lemma td_ext_nth:

  td_ext op !! set_bits {f. ∀i. f i --> i < len_of TYPE('a)}
   (λh i. h ii < len_of TYPE('a))

lemma td_nth:

  type_definition op !! set_bits {f. ∀i. f i --> i < len_of TYPE('a)}

lemma word_set_set_same:

  set_bit (set_bit w n x) n y = set_bit w n y

lemma word_set_set_diff:

  m  n ==> set_bit (set_bit w m x) n y = set_bit (set_bit w n y) m x

lemma test_bit_no':

  w = number_of bin ==> w !! n = (n < size w ∧ bin_nth bin n)

lemma test_bit_no:

  number_of bin !! n == n < len_of TYPE('a) ∧ bin_nth bin n

lemma nth_0:

  ¬ 0 !! n

lemma nth_sint:

  bin_nth (sint w) n =
  (if n < len_of TYPE('a) - 1 then w !! n else w !! (len_of TYPE('a) - 1))

lemma word_lsb_no:

  lsb (number_of bin) = (bin_last bin = bit.B1)

lemma word_set_no:

  set_bit (number_of bin) n b =
  number_of (bin_sc n (if b then bit.B1 else bit.B0) bin)

lemma setBit_no:

  setBit (number_of bin) n == number_of (bin_sc n bit.B1 bin)

lemma clearBit_no:

  clearBit (number_of bin) n == number_of (bin_sc n bit.B0 bin)

lemma to_bl_n1:

  to_bl -1 = replicate (len_of TYPE('a)) True

lemma word_msb_n1:

  msb -1

lemma word_set_nth_iff:

  (set_bit w n b = w) = (w !! n = bsize w  n)

lemma test_bit_2p':

  w = word_of_int (2 ^ n) ==> w !! m = (m = nm < size w)

lemma test_bit_2p:

  word_of_int (2 ^ n) !! m = (m = nm < len_of TYPE('a))

lemma nth_w2p:

  (2 ^ n) !! m = (m = nm < len_of TYPE('a))

lemma uint_2p:

  0 < 2 ^ n ==> uint (2 ^ n) = 2 ^ n

lemma word_of_int_2p:

  word_of_int (2 ^ n) = 2 ^ n

lemma bang_is_le:

  x !! m ==> 2 ^ m  x

lemma word_clr_le:

  set_bit w n False  w

lemma word_set_ge:

  w  set_bit w n True