# HG changeset patch
# User huffman
# Date 1187888033 -7200
# Node ID 87ef9b486068acb64a411d3587b6142a0e574eac
# Parent  5073729e5c12a479750168004cb93e17580f4b38
remove unused lemmas

diff -r 5073729e5c12 -r 87ef9b486068 src/HOL/Word/Num_Lemmas.thy
--- a/src/HOL/Word/Num_Lemmas.thy	Thu Aug 23 18:52:44 2007 +0200
+++ b/src/HOL/Word/Num_Lemmas.thy	Thu Aug 23 18:53:53 2007 +0200
@@ -7,26 +7,12 @@
 
 theory Num_Lemmas imports Parity begin
 
-lemma contentsI: "y = {x} ==> contents y = x" 
-  unfolding contents_def by auto
-
-lemmas "split.splits" = split_split split_split_asm 
-
-lemmas funpow_0 = funpow.simps(1)
+(* lemmas funpow_0 = funpow.simps(1) *)
 lemmas funpow_Suc = funpow.simps(2)
-
-lemma nonemptyE: "S ~= {} ==> (!!x. x : S ==> R) ==> R"
-  apply (erule contrapos_np)
-  apply (rule equals0I)
-  apply auto
-  done
+(* used by BinGeneral.funpow_minus_simp *)
 
 lemma gt_or_eq_0: "0 < y \<or> 0 = (y::nat)" by auto
 
-constdefs
-  mod_alt :: "'a => 'a => 'a :: Divides.div"
-  "mod_alt n m == n mod m" 
-
 lemmas xtr1 = xtrans(1)
 lemmas xtr2 = xtrans(2)
 lemmas xtr3 = xtrans(3)
@@ -36,13 +22,7 @@
 lemmas xtr7 = xtrans(7)
 lemmas xtr8 = xtrans(8)
 
-lemma Min_ne_Pls [iff]:  
-  "Numeral.Min ~= Numeral.Pls"
-  unfolding Min_def Pls_def by auto
-
-lemmas Pls_ne_Min [iff] = Min_ne_Pls [symmetric]
-
-lemmas PlsMin_defs [intro!] = 
+lemmas PlsMin_defs (*[intro!]*) = 
   Pls_def Min_def Pls_def [symmetric] Min_def [symmetric]
 
 lemmas PlsMin_simps [simp] = PlsMin_defs [THEN Eq_TrueI]
@@ -51,34 +31,20 @@
   "False ==> number_of x = number_of y" 
   by auto
 
-lemmas nat_simps = diff_add_inverse2 diff_add_inverse
-lemmas nat_iffs = le_add1 le_add2
-
-lemma sum_imp_diff: "j = k + i ==> j - i = (k :: nat)"
-  by (clarsimp simp add: nat_simps)
-
 lemma nobm1:
   "0 < (number_of w :: nat) ==> 
    number_of w - (1 :: nat) = number_of (Numeral.pred w)"
   apply (unfold nat_number_of_def One_nat_def nat_1 [symmetric] pred_def)
   apply (simp add: number_of_eq nat_diff_distrib [symmetric])
   done
+(* used in BinGeneral, BinOperations, BinBoolList *)
 
 lemma zless2: "0 < (2 :: int)" 
   by auto
 
-lemmas zless2p [simp] = zless2 [THEN zero_less_power]
-lemmas zle2p [simp] = zless2p [THEN order_less_imp_le]
-
-lemmas pos_mod_sign2 = zless2 [THEN pos_mod_sign [where b = "2::int"]]
-lemmas pos_mod_bound2 = zless2 [THEN pos_mod_bound [where b = "2::int"]]
+lemmas zless2p [simp] = zless2 [THEN zero_less_power] (* keep *)
+lemmas zle2p [simp] = zless2p [THEN order_less_imp_le] (* keep *)
 
--- "the inverse(s) of @{text number_of}"
-lemma nmod2: "n mod (2::int) = 0 | n mod 2 = 1"
-  using pos_mod_sign2 [of n] pos_mod_bound2 [of n]
-  unfolding mod_alt_def [symmetric] by auto
-
-  
 lemma emep1:
   "even n ==> even d ==> 0 <= d ==> (n + 1) mod (d :: int) = (n mod d) + 1"
   apply (simp add: add_commute)
@@ -90,109 +56,53 @@
 
 lemmas eme1p = emep1 [simplified add_commute]
 
-lemma le_diff_eq': "(a \<le> c - b) = (b + a \<le> (c::int))"
-  by (simp add: le_diff_eq add_commute)
-
-lemma less_diff_eq': "(a < c - b) = (b + a < (c::int))"
-  by (simp add: less_diff_eq add_commute)
-
 lemma diff_le_eq': "(a - b \<le> c) = (a \<le> b + (c::int))"
   by (simp add: diff_le_eq add_commute)
-
-lemma diff_less_eq': "(a - b < c) = (a < b + (c::int))"
-  by (simp add: diff_less_eq add_commute)
-
+(* used by BinGeneral.sb_dec_lem' *)
 
 lemmas m1mod2k = zless2p [THEN zmod_minus1]
-lemmas m1mod22k = mult_pos_pos [OF zless2 zless2p, THEN zmod_minus1]
+(* used in WordArith *)
+
 lemmas p1mod22k' = zless2p [THEN order_less_imp_le, THEN pos_zmod_mult_2]
-lemmas z1pmod2' = zero_le_one [THEN pos_zmod_mult_2, simplified]
-lemmas z1pdiv2' = zero_le_one [THEN pos_zdiv_mult_2, simplified]
 
 lemma p1mod22k:
   "(2 * b + 1) mod (2 * 2 ^ n) = 2 * (b mod 2 ^ n) + (1::int)"
   by (simp add: p1mod22k' add_commute)
-
-lemma z1pmod2:
-  "(2 * b + 1) mod 2 = (1::int)"
-  by (simp add: z1pmod2' add_commute)
-  
-lemma z1pdiv2:
-  "(2 * b + 1) div 2 = (b::int)"
-  by (simp add: z1pdiv2' add_commute)
+(* used in BinOperations *)
 
 lemmas zdiv_le_dividend = xtr3 [OF zdiv_1 [symmetric] zdiv_mono2,
   simplified int_one_le_iff_zero_less, simplified, standard]
-
-lemma no_no [simp]: "number_of (number_of i) = i"
-  unfolding number_of_eq by simp
+(* used in WordShift *)
 
 lemma Bit_B0:
   "k BIT bit.B0 = k + k"
    by (unfold Bit_def) simp
 
-lemma Bit_B1:
-  "k BIT bit.B1 = k + k + 1"
-   by (unfold Bit_def) simp
-  
 lemma Bit_B0_2t: "k BIT bit.B0 = 2 * k"
   by (rule trans, rule Bit_B0) simp
-
-lemma Bit_B1_2t: "k BIT bit.B1 = 2 * k + 1"
-  by (rule trans, rule Bit_B1) simp
-
-lemma B_mod_2': 
-  "X = 2 ==> (w BIT bit.B1) mod X = 1 & (w BIT bit.B0) mod X = 0"
-  apply (simp (no_asm) only: Bit_B0 Bit_B1)
-  apply (simp add: z1pmod2)
-  done
-    
-lemmas B1_mod_2 [simp] = B_mod_2' [OF refl, THEN conjunct1, standard]
-lemmas B0_mod_2 [simp] = B_mod_2' [OF refl, THEN conjunct2, standard]
-
-lemma axxbyy:
-  "a + m + m = b + n + n ==> (a = 0 | a = 1) ==> (b = 0 | b = 1) ==>  
-   a = b & m = (n :: int)"
-  apply auto
-   apply (drule_tac f="%n. n mod 2" in arg_cong)
-   apply (clarsimp simp: z1pmod2)
-  apply (drule_tac f="%n. n mod 2" in arg_cong)
-  apply (clarsimp simp: z1pmod2)
-  done
-
-lemma axxmod2:
-  "(1 + x + x) mod 2 = (1 :: int) & (0 + x + x) mod 2 = (0 :: int)" 
-  by simp (rule z1pmod2)
-
-lemma axxdiv2:
-  "(1 + x + x) div 2 = (x :: int) & (0 + x + x) div 2 = (x :: int)" 
-  by simp (rule z1pdiv2)
-
-lemmas iszero_minus = trans [THEN trans,
-  OF iszero_def neg_equal_0_iff_equal iszero_def [symmetric], standard]
+(* used in BinOperations *)
 
 lemmas zadd_diff_inverse = trans [OF diff_add_cancel [symmetric] add_commute,
   standard]
+(* used in WordArith *)
 
 lemmas add_diff_cancel2 = add_commute [THEN diff_eq_eq [THEN iffD2], standard]
+(* used in WordShift *)
 
 lemma zmod_uminus: "- ((a :: int) mod b) mod b = -a mod b"
   by (simp add : zmod_zminus1_eq_if)
-
-lemma zmod_zsub_distrib: "((a::int) - b) mod c = (a mod c - b mod c) mod c"
-  apply (unfold diff_int_def)
-  apply (rule trans [OF _ zmod_zadd1_eq [symmetric]])
-  apply (simp add: zmod_uminus zmod_zadd1_eq [symmetric])
-  done
+(* used in BinGeneral *)
 
 lemma zmod_zsub_right_eq: "((a::int) - b) mod c = (a - b mod c) mod c"
   apply (unfold diff_int_def)
   apply (rule trans [OF _ zmod_zadd_right_eq [symmetric]])
   apply (simp add : zmod_uminus zmod_zadd_right_eq [symmetric])
   done
+(* used in BinGeneral, WordGenLib *)
 
 lemmas zmod_zsub_left_eq = 
   zmod_zadd_left_eq [where b = "- ?b", simplified diff_int_def [symmetric]]
+(* used in BinGeneral, WordGenLib *)
   
 lemma zmod_zsub_self [simp]: 
   "((b :: int) - a) mod a = b mod a"
@@ -204,10 +114,12 @@
   apply (subst zmod_zmult1_eq)
   apply simp
   done
+(* used in BinGeneral *)
 
 lemmas rdmods [symmetric] = zmod_uminus [symmetric]
   zmod_zsub_left_eq zmod_zsub_right_eq zmod_zadd_left_eq
   zmod_zadd_right_eq zmod_zmult1_eq zmod_zmult1_eq_rev
+(* used in WordArith, WordShift *)
 
 lemma mod_plus_right:
   "((a + x) mod m = (b + x) mod m) = (a mod m = b mod (m :: nat))"
@@ -216,27 +128,12 @@
   apply arith
   done
 
-lemma nat_minus_mod: "(n - n mod m) mod m = (0 :: nat)"
-  by (induct n) (simp_all add : mod_Suc)
-
-lemmas nat_minus_mod_plus_right = trans [OF nat_minus_mod mod_0 [symmetric],
-  THEN mod_plus_right [THEN iffD2], standard, simplified]
-
-lemmas push_mods' = zmod_zadd1_eq [standard]
-  zmod_zmult_distrib [standard] zmod_zsub_distrib [standard]
-  zmod_uminus [symmetric, standard]
-
-lemmas push_mods = push_mods' [THEN eq_reflection, standard]
-lemmas pull_mods = push_mods [symmetric] rdmods [THEN eq_reflection, standard]
-lemmas mod_simps = 
-  zmod_zmult_self1 [THEN eq_reflection] zmod_zmult_self2 [THEN eq_reflection]
-  mod_mod_trivial [THEN eq_reflection]
-
 lemma nat_mod_eq:
   "!!b. b < n ==> a mod n = b mod n ==> a mod n = (b :: nat)" 
   by (induct a) auto
 
 lemmas nat_mod_eq' = refl [THEN [2] nat_mod_eq]
+(* used in WordArith, WordGenLib *)
 
 lemma nat_mod_lem: 
   "(0 :: nat) < n ==> b < n = (b mod n = b)"
@@ -245,6 +142,7 @@
   apply (erule subst)
   apply (erule mod_less_divisor)
   done
+(* used in WordArith *)
 
 lemma mod_nat_add: 
   "(x :: nat) < z ==> y < z ==> 
@@ -257,10 +155,7 @@
   apply (rule nat_mod_eq')
   apply arith
   done
-
-lemma mod_nat_sub: 
-  "(x :: nat) < z ==> (x - y) mod z = x - y"
-  by (rule nat_mod_eq') arith
+(* used in WordArith, WordGenLib *)
 
 lemma int_mod_lem: 
   "(0 :: int) < n ==> (0 <= b & b < n) = (b mod n = b)"
@@ -269,12 +164,14 @@
    apply (erule_tac [!] subst)
    apply auto
   done
+(* used in WordDefinition, WordArith, WordShift *)
 
 lemma int_mod_eq:
   "(0 :: int) <= b ==> b < n ==> a mod n = b mod n ==> a mod n = b"
   by clarsimp (rule mod_pos_pos_trivial)
 
 lemmas int_mod_eq' = refl [THEN [3] int_mod_eq]
+(* used in WordDefinition, WordArith, WordShift, WordGenLib *)
 
 lemma int_mod_le: "0 <= a ==> 0 < (n :: int) ==> a mod n <= a"
   apply (cases "a < n")
@@ -298,88 +195,15 @@
   "(x :: int) < z ==> y < z ==> 0 <= y ==> 0 <= x ==> 0 <= z ==> 
    (x + y) mod z = (if x + y < z then x + y else x + y - z)"
   by (auto intro: int_mod_eq)
+(* used in WordArith, WordGenLib *)
 
 lemma mod_sub_if_z:
   "(x :: int) < z ==> y < z ==> 0 <= y ==> 0 <= x ==> 0 <= z ==> 
    (x - y) mod z = (if y <= x then x - y else x - y + z)"
   by (auto intro: int_mod_eq)
-
-lemmas zmde = zmod_zdiv_equality [THEN diff_eq_eq [THEN iffD2], symmetric]
-lemmas mcl = mult_cancel_left [THEN iffD1, THEN make_pos_rule]
-
-(* already have this for naturals, div_mult_self1/2, but not for ints *)
-lemma zdiv_mult_self: "m ~= (0 :: int) ==> (a + m * n) div m = a div m + n"
-  apply (rule mcl)
-   prefer 2
-   apply (erule asm_rl)
-  apply (simp add: zmde ring_distribs)
-  apply (simp add: push_mods)
-  done
-
-(** Rep_Integ **)
-lemma eqne: "equiv A r ==> X : A // r ==> X ~= {}"
-  unfolding equiv_def refl_def quotient_def Image_def by auto
-
-lemmas Rep_Integ_ne = Integ.Rep_Integ 
-  [THEN equiv_intrel [THEN eqne, simplified Integ_def [symmetric]], standard]
-
-lemmas riq = Integ.Rep_Integ [simplified Integ_def]
-lemmas intrel_refl = refl [THEN equiv_intrel_iff [THEN iffD1], standard]
-lemmas Rep_Integ_equiv = quotient_eq_iff
-  [OF equiv_intrel riq riq, simplified Integ.Rep_Integ_inject, standard]
-lemmas Rep_Integ_same = 
-  Rep_Integ_equiv [THEN intrel_refl [THEN rev_iffD2], standard]
-
-lemma RI_int: "(a, 0) : Rep_Integ (int a)"
-  unfolding int_def by auto
-
-lemmas RI_intrel [simp] = UNIV_I [THEN quotientI,
-  THEN Integ.Abs_Integ_inverse [simplified Integ_def], standard]
-
-lemma RI_minus: "(a, b) : Rep_Integ x ==> (b, a) : Rep_Integ (- x)"
-  apply (rule_tac z=x in eq_Abs_Integ)
-  apply (clarsimp simp: minus)
-  done
+(* used in WordArith, WordGenLib *)
 
-lemma RI_add: 
-  "(a, b) : Rep_Integ x ==> (c, d) : Rep_Integ y ==> 
-   (a + c, b + d) : Rep_Integ (x + y)"
-  apply (rule_tac z=x in eq_Abs_Integ)
-  apply (rule_tac z=y in eq_Abs_Integ) 
-  apply (clarsimp simp: add)
-  done
-
-lemma mem_same: "a : S ==> a = b ==> b : S"
-  by fast
-
-(* two alternative proofs of this *)
-lemma RI_eq_diff': "(a, b) : Rep_Integ (int a - int b)"
-  apply (unfold diff_def)
-  apply (rule mem_same)
-   apply (rule RI_minus RI_add RI_int)+
-  apply simp
-  done
-
-lemma RI_eq_diff: "((a, b) : Rep_Integ x) = (int a - int b = x)"
-  apply safe
-   apply (rule Rep_Integ_same)
-    prefer 2
-    apply (erule asm_rl)
-   apply (rule RI_eq_diff')+
-  done
-
-lemma mod_power_lem:
-  "a > 1 ==> a ^ n mod a ^ m = (if m <= n then 0 else (a :: int) ^ n)"
-  apply clarsimp
-  apply safe
-   apply (simp add: zdvd_iff_zmod_eq_0 [symmetric])
-   apply (drule le_iff_add [THEN iffD1])
-   apply (force simp: zpower_zadd_distrib)
-  apply (rule mod_pos_pos_trivial)
-   apply (simp add: zero_le_power)
-  apply (rule power_strict_increasing)
-   apply auto
-  done
+lemmas mcl = mult_cancel_left [THEN iffD1, THEN make_pos_rule]
 
 lemma min_pm [simp]: "min a b + (a - b) = (a :: nat)"
   by arith
@@ -391,40 +215,14 @@
 
 lemmas rev_min_pm1 [simp] = trans [OF add_commute rev_min_pm]
 
-lemma pl_pl_rels: 
-  "a + b = c + d ==> 
-   a >= c & b <= d | a <= c & b >= (d :: nat)"
-  apply (cut_tac n=a and m=c in nat_le_linear)
-  apply (safe dest!: le_iff_add [THEN iffD1])
-         apply arith+
-  done
-
-lemmas pl_pl_rels' = add_commute [THEN [2] trans, THEN pl_pl_rels]
-
-lemma minus_eq: "(m - k = m) = (k = 0 | m = (0 :: nat))"
-  by arith
-
-lemma pl_pl_mm: "(a :: nat) + b = c + d ==> a - c = d - b"
-  by arith
-
-lemmas pl_pl_mm' = add_commute [THEN [2] trans, THEN pl_pl_mm]
- 
 lemma min_minus [simp] : "min m (m - k) = (m - k :: nat)"
   by arith
   
 lemmas min_minus' [simp] = trans [OF min_max.inf_commute min_minus]
 
-lemma nat_no_eq_iff: 
-  "(number_of b :: int) >= 0 ==> (number_of c :: int) >= 0 ==> 
-   (number_of b = (number_of c :: nat)) = (b = c)"
-  apply (unfold nat_number_of_def)
-  apply safe
-  apply (drule (2) eq_nat_nat_iff [THEN iffD1])
-  apply (simp add: number_of_eq)
-  done
-
 lemmas dme = box_equals [OF div_mod_equality add_0_right add_0_right]
 lemmas dtle = xtr3 [OF dme [symmetric] le_add1]
+(* used in WordShift *)
 lemmas th2 = order_trans [OF order_refl [THEN [2] mult_le_mono] dtle]
 
 lemma td_gal: 
@@ -435,6 +233,7 @@
   done
   
 lemmas td_gal_lt = td_gal [simplified le_def, simplified]
+(* used in WordShift *)
 
 lemma div_mult_le: "(a :: nat) div b * b <= a"
   apply (cases b)
@@ -442,6 +241,7 @@
    apply (rule order_refl [THEN th2])
   apply auto
   done
+(* used in WordArith *)
 
 lemmas sdl = split_div_lemma [THEN iffD1, symmetric]
 
@@ -456,22 +256,8 @@
   apply (rule_tac f="%n. n div f" in arg_cong)
   apply (simp add : mult_ac)
   done
+(* used in WordShift *)
     
-lemma diff_mod_le: "(a::nat) < d ==> b dvd d ==> a - a mod b <= d - b"
-  apply (unfold dvd_def)
-  apply clarify
-  apply (case_tac k)
-   apply clarsimp
-  apply clarify
-  apply (cases "b > 0")
-   apply (drule mult_commute [THEN xtr1])
-   apply (frule (1) td_gal_lt [THEN iffD1])
-   apply (clarsimp simp: le_simps)
-   apply (rule mult_div_cancel [THEN [2] xtr4])
-   apply (rule mult_mono)
-      apply auto
-  done
-
 lemma less_le_mult':
   "w * c < b * c ==> 0 \<le> c ==> (w + 1) * c \<le> b * (c::int)"
   apply (rule mult_right_mono)
@@ -481,9 +267,7 @@
   done
 
 lemmas less_le_mult = less_le_mult' [simplified left_distrib, simplified]
-
-lemmas less_le_mult_minus = iffD2 [OF le_diff_eq less_le_mult, 
-  simplified left_diff_distrib, standard]
+(* used in WordArith *)
 
 lemma lrlem':
   assumes d: "(i::nat) \<le> j \<or> m < j'"
@@ -506,21 +290,18 @@
    apply arith
   apply simp
   done
+(* used in BinBoolList *)
 
 lemma gen_minus: "0 < n ==> f n = f (Suc (n - 1))"
   by auto
+(* used in BinGeneral *)
 
 lemma mpl_lem: "j <= (i :: nat) ==> k < j ==> i - j + k < i"
   apply (induct i, clarsimp)
   apply (cases j, clarsimp)
   apply arith
   done
-
-lemma nonneg_mod_div:
-  "0 <= a ==> 0 <= b ==> 0 <= (a mod b :: int) & 0 <= a div b"
-  apply (cases "b = 0", clarsimp)
-  apply (auto intro: pos_imp_zdiv_nonneg_iff [THEN iffD2])
-  done
+(* used in WordShift *)
 
 subsection "if simps"
 
@@ -536,5 +317,6 @@
   by auto
 
 lemmas if_simps = if_x_Not if_Not_x if_cancel if_True if_False if_bool_simps
+(* used in WordBitwise *)
 
 end