src/HOL/Hyperreal/EvenOdd.thy

 (*  Title       : EvenOdd.thy
+    ID:         $Id$
     Author      : Jacques D. Fleuriot  
     Copyright   : 1999  University of Edinburgh
-    Description : Even and odd numbers defined 
 *)
 
-header{*Compatibility file from Parity*}
+header{*Even and Odd Numbers: Compatibility file for Parity*}
 
 theory EvenOdd = NthRoot:
 
 subsection{*General Lemmas About Division*}
 
-lemma div_add_self_two_is_m: "(m + m) div 2 = (m::nat)"
+lemma Suc_times_mod_eq: "1<k ==> Suc (k * m) mod k = 1" 
+apply (induct_tac "m")
+apply (simp_all add: mod_Suc)
+done
+
+declare Suc_times_mod_eq [of "number_of w", standard, simp]
+
+lemma [simp]: "n div k \<le> (Suc n) div k"
+by (simp add: div_le_mono) 
+
+lemma Suc_n_div_2_gt_zero [simp]: "(0::nat) < n ==> 0 < (n + 1) div 2"
 by arith
-declare div_add_self_two_is_m [simp]
 
-lemma div_mult_self_Suc_Suc: "Suc(Suc(m*2)) div 2 = Suc m"
+lemma div_2_gt_zero [simp]: "(1::nat) < n ==> 0 < n div 2" 
 by arith
-declare div_mult_self_Suc_Suc [simp]
 
-lemma div_mult_self_Suc_Suc2: "Suc(Suc(2*m)) div 2 = Suc m"
-by arith
-declare div_mult_self_Suc_Suc2 [simp]
+lemma mod_mult_self3 [simp]: "(k*n + m) mod n = m mod (n::nat)"
+by (simp add: mult_ac add_ac)
 
-lemma div_add_self_Suc_Suc: "Suc(Suc(m + m)) div 2 = Suc m"
-by arith
-declare div_add_self_Suc_Suc [simp]
-
-lemma mod_two_Suc_2m: "Suc (2 * m) mod 2 = 1" 
-apply (induct_tac "m")
-apply (auto simp add: mod_Suc)
-done
-declare mod_two_Suc_2m [simp]
-
-lemma Suc_n_le_Suc_Suc_n_div_2: "Suc n div 2 \<le> Suc (Suc n) div 2"
-by arith
-declare Suc_n_le_Suc_Suc_n_div_2 [simp]
-
-lemma Suc_n_div_2_gt_zero: "(0::nat) < n ==> 0 < (n + 1) div 2"
-by arith
-declare Suc_n_div_2_gt_zero [simp]
-
-lemma le_Suc_n_div_2: "n div 2 \<le> (Suc n) div 2"
-by arith
-declare le_Suc_n_div_2 [simp]
-
-lemma div_2_gt_zero: "(1::nat) < n ==> 0 < n div 2" 
-by arith
-declare div_2_gt_zero [simp]
-
-lemma mod_mult_self3: "(k*n + m) mod n = m mod (n::nat)"
-by (simp add: mult_ac add_ac)
-declare mod_mult_self3 [simp]
-
-lemma mod_mult_self4: "Suc (k*n + m) mod n = Suc m mod n"
+lemma mod_mult_self4 [simp]: "Suc (k*n + m) mod n = Suc m mod n"
 proof -
   have "Suc (k * n + m) mod n = (k * n + Suc m) mod n" by simp
   also have "... = Suc m mod n" by (rule mod_mult_self3) 
   finally show ?thesis .
 qed
-declare mod_mult_self4 [simp]
-
-lemma nat_mod_idem [simp]: "m mod n mod n = (m mod n :: nat)"
-by (case_tac "n=0", auto)
 
 lemma mod_Suc_eq_Suc_mod: "Suc m mod n = Suc (m mod n) mod n"
 apply (subst mod_Suc [of m]) 
 apply (subst mod_Suc [of "m mod n"], simp) 
 done
 
-lemma lemma_4n_add_2_div_2_eq: "((4 * n) + 2) div 2 = (2::nat) * n + 1"
-by arith
-declare lemma_4n_add_2_div_2_eq [simp]
-
-lemma lemma_Suc_Suc_4n_div_2_eq: "(Suc(Suc(4 * n))) div 2 = (2::nat) * n + 1"
-by arith
-declare lemma_Suc_Suc_4n_div_2_eq [simp]
-
-lemma lemma_Suc_Suc_4n_div_2_eq2: "(Suc(Suc(n * 4))) div 2 = (2::nat) * n + 1"
-by arith
-declare lemma_Suc_Suc_4n_div_2_eq2 [simp]
-
 
 subsection{*More Even/Odd Results*}
  
-lemma even_mult_two_ex: "even(n) = (EX m::nat. n = 2*m)"
+lemma even_mult_two_ex: "even(n) = (\<exists>m::nat. n = 2*m)"
 by (simp add: even_nat_equiv_def2 numeral_2_eq_2)
 
-lemma odd_Suc_mult_two_ex: "odd(n) = (EX m. n = Suc (2*m))"
+lemma odd_Suc_mult_two_ex: "odd(n) = (\<exists>m. n = Suc (2*m))"
 by (simp add: odd_nat_equiv_def2 numeral_2_eq_2)
 
-lemma even_add: "even(m + n::nat) = (even m = even n)"
+lemma even_add [simp]: "even(m + n::nat) = (even m = even n)" 
 by auto
-declare even_add [iff]
 
-lemma odd_add: "odd(m + n::nat) = (odd m ~= odd n)"
+lemma odd_add [simp]: "odd(m + n::nat) = (odd m \<noteq> odd n)"
 by auto
-declare odd_add [iff]
 
-lemma lemma_even_div2: "even (n::nat) ==> (n + 1) div 2 = n div 2"
+lemma lemma_even_div2 [simp]: "even (n::nat) ==> (n + 1) div 2 = n div 2"
 apply (simp add: numeral_2_eq_2) 
 apply (subst div_Suc)  
 apply (simp add: even_nat_mod_two_eq_zero) 
 done
-declare lemma_even_div2 [simp]
 
-lemma lemma_not_even_div2: "~even n ==> (n + 1) div 2 = Suc (n div 2)"
+lemma lemma_not_even_div2 [simp]: "~even n ==> (n + 1) div 2 = Suc (n div 2)"
 apply (simp add: numeral_2_eq_2) 
 apply (subst div_Suc)  
 apply (simp add: odd_nat_mod_two_eq_one) 
 done
-declare lemma_not_even_div2 [simp]
 
 lemma even_num_iff: "0 < n ==> even n = (~ even(n - 1 :: nat))" 
 by (case_tac "n", auto)
 
 lemma even_even_mod_4_iff: "even (n::nat) = even (n mod 4)"
 apply (induct n, simp)
 apply (subst mod_Suc, simp) 
 done
-
-declare neg_one_odd_power [simp]
-declare neg_one_even_power [simp]
 
 lemma lemma_odd_mod_4_div_2: "n mod 4 = (3::nat) ==> odd((n - 1) div 2)"
 apply (rule_tac t = n and n1 = 4 in mod_div_equality [THEN subst])
 apply (simp add: even_num_iff)
 done

 lemma lemma_even_mod_4_div_2: "n mod 4 = (1::nat) ==> even ((n - 1) div 2)"
 by (rule_tac t = n and n1 = 4 in mod_div_equality [THEN subst], simp)
 
 ML
 {*
-val even_Suc = thm"Parity.even_nat_suc";
+val even_nat_Suc = thm"Parity.even_nat_Suc";
 
 val even_mult_two_ex = thm "even_mult_two_ex";
 val odd_Suc_mult_two_ex = thm "odd_Suc_mult_two_ex";
-val div_add_self_two_is_m = thm "div_add_self_two_is_m";
-val div_mult_self_Suc_Suc = thm "div_mult_self_Suc_Suc";
-val div_mult_self_Suc_Suc2 = thm "div_mult_self_Suc_Suc2";
-val div_add_self_Suc_Suc = thm "div_add_self_Suc_Suc";
 val even_add = thm "even_add";
 val odd_add = thm "odd_add";
-val mod_two_Suc_2m = thm "mod_two_Suc_2m";
-val Suc_n_le_Suc_Suc_n_div_2 = thm "Suc_n_le_Suc_Suc_n_div_2";
 val Suc_n_div_2_gt_zero = thm "Suc_n_div_2_gt_zero";
-val le_Suc_n_div_2 = thm "le_Suc_n_div_2";
 val div_2_gt_zero = thm "div_2_gt_zero";
-val lemma_even_div2 = thm "lemma_even_div2";
-val lemma_not_even_div2 = thm "lemma_not_even_div2";
 val even_num_iff = thm "even_num_iff";
-val mod_mult_self3 = thm "mod_mult_self3";
-val mod_mult_self4 = thm "mod_mult_self4";
-val nat_mod_idem = thm "nat_mod_idem";
+val nat_mod_div_trivial = thm "nat_mod_div_trivial";
+val nat_mod_mod_trivial = thm "nat_mod_mod_trivial";
 val mod_Suc_eq_Suc_mod = thm "mod_Suc_eq_Suc_mod";
 val even_even_mod_4_iff = thm "even_even_mod_4_iff";
-val lemma_4n_add_2_div_2_eq = thm "lemma_4n_add_2_div_2_eq";
-val lemma_Suc_Suc_4n_div_2_eq = thm "lemma_Suc_Suc_4n_div_2_eq";
-val lemma_Suc_Suc_4n_div_2_eq2 = thm "lemma_Suc_Suc_4n_div_2_eq2";
 val lemma_odd_mod_4_div_2 = thm "lemma_odd_mod_4_div_2";
 val lemma_even_mod_4_div_2 = thm "lemma_even_mod_4_div_2";
 *}
 
 end