282 |
282 |
283 (*Maps #n to n for n = 0, 1, 2*) |
283 (*Maps #n to n for n = 0, 1, 2*) |
284 lemmas numerals = numeral_0_eq_0 numeral_1_eq_1 numeral_2_eq_2 |
284 lemmas numerals = numeral_0_eq_0 numeral_1_eq_1 numeral_2_eq_2 |
285 |
285 |
286 |
286 |
|
287 subsection{*General Theorems About Powers Involving Binary Numerals*} |
|
288 |
|
289 text{*We cannot refer to the number @{term 2} in @{text Ring_and_Field.thy}. |
|
290 We cannot prove general results about the numeral @{term "-1"}, so we have to |
|
291 use @{term "- 1"} instead.*} |
|
292 |
|
293 lemma power2_eq_square: "(a::'a::{semiring,ringpower})\<twosuperior> = a * a" |
|
294 by (simp add: numeral_2_eq_2 Power.power_Suc) |
|
295 |
|
296 lemma [simp]: "(0::'a::{semiring,ringpower})\<twosuperior> = 0" |
|
297 by (simp add: power2_eq_square) |
|
298 |
|
299 lemma [simp]: "(1::'a::{semiring,ringpower})\<twosuperior> = 1" |
|
300 by (simp add: power2_eq_square) |
|
301 |
|
302 text{*Squares of literal numerals will be evaluated.*} |
|
303 declare power2_eq_square [of "number_of w", standard, simp] |
|
304 |
|
305 lemma zero_le_power2 [simp]: "0 \<le> (a\<twosuperior>::'a::{ordered_ring,ringpower})" |
|
306 by (simp add: power2_eq_square zero_le_square) |
|
307 |
|
308 lemma zero_less_power2 [simp]: |
|
309 "(0 < a\<twosuperior>) = (a \<noteq> (0::'a::{ordered_ring,ringpower}))" |
|
310 by (force simp add: power2_eq_square zero_less_mult_iff linorder_neq_iff) |
|
311 |
|
312 lemma zero_eq_power2 [simp]: |
|
313 "(a\<twosuperior> = 0) = (a = (0::'a::{ordered_ring,ringpower}))" |
|
314 by (force simp add: power2_eq_square mult_eq_0_iff) |
|
315 |
|
316 lemma abs_power2 [simp]: |
|
317 "abs(a\<twosuperior>) = (a\<twosuperior>::'a::{ordered_ring,ringpower})" |
|
318 by (simp add: power2_eq_square abs_mult abs_mult_self) |
|
319 |
|
320 lemma power2_abs [simp]: |
|
321 "(abs a)\<twosuperior> = (a\<twosuperior>::'a::{ordered_ring,ringpower})" |
|
322 by (simp add: power2_eq_square abs_mult_self) |
|
323 |
|
324 lemma power2_minus [simp]: |
|
325 "(- a)\<twosuperior> = (a\<twosuperior>::'a::{ring,ringpower})" |
|
326 by (simp add: power2_eq_square) |
|
327 |
|
328 lemma power_minus1_even: "(- 1) ^ (2*n) = (1::'a::{ring,ringpower})" |
|
329 apply (induct_tac "n") |
|
330 apply (auto simp add: power_Suc power_add) |
|
331 done |
|
332 |
|
333 lemma power_minus_even [simp]: |
|
334 "(-a) ^ (2*n) = (a::'a::{ring,ringpower}) ^ (2*n)" |
|
335 by (simp add: power_minus1_even power_minus [of a]) |
|
336 |
|
337 lemma zero_le_even_power: |
|
338 "0 \<le> (a::'a::{ordered_ring,ringpower}) ^ (2*n)" |
|
339 proof (induct "n") |
|
340 case 0 |
|
341 show ?case by (simp add: zero_le_one) |
|
342 next |
|
343 case (Suc n) |
|
344 have "a ^ (2 * Suc n) = (a*a) * a ^ (2*n)" |
|
345 by (simp add: mult_ac power_add power2_eq_square) |
|
346 thus ?case |
|
347 by (simp add: prems zero_le_square zero_le_mult_iff) |
|
348 qed |
|
349 |
|
350 lemma odd_power_less_zero: |
|
351 "(a::'a::{ordered_ring,ringpower}) < 0 ==> a ^ Suc(2*n) < 0" |
|
352 proof (induct "n") |
|
353 case 0 |
|
354 show ?case by (simp add: Power.power_Suc) |
|
355 next |
|
356 case (Suc n) |
|
357 have "a ^ Suc (2 * Suc n) = (a*a) * a ^ Suc(2*n)" |
|
358 by (simp add: mult_ac power_add power2_eq_square Power.power_Suc) |
|
359 thus ?case |
|
360 by (simp add: prems mult_less_0_iff mult_neg) |
|
361 qed |
|
362 |
|
363 lemma odd_0_le_power_imp_0_le: |
|
364 "0 \<le> a ^ Suc(2*n) ==> 0 \<le> (a::'a::{ordered_ring,ringpower})" |
|
365 apply (insert odd_power_less_zero [of a n]) |
|
366 apply (force simp add: linorder_not_less [symmetric]) |
|
367 done |
|
368 |
|
369 |
287 (** Nat **) |
370 (** Nat **) |
288 |
371 |
289 lemma Suc_pred': "0 < n ==> n = Suc(n - 1)" |
372 lemma Suc_pred': "0 < n ==> n = Suc(n - 1)" |
290 by (simp add: numerals) |
373 by (simp add: numerals) |
291 |
374 |
475 (*** Literal arithmetic involving powers, type int ***) |
553 (*** Literal arithmetic involving powers, type int ***) |
476 |
554 |
477 lemma zpower_even: "(z::int) ^ (2*a) = (z^a)^2" |
555 lemma zpower_even: "(z::int) ^ (2*a) = (z^a)^2" |
478 by (simp add: zpower_zpower mult_commute) |
556 by (simp add: zpower_zpower mult_commute) |
479 |
557 |
480 lemma zpower_two: "(p::int) ^ 2 = p*p" |
|
481 by (simp add: numerals) |
|
482 |
|
483 lemma zpower_odd: "(z::int) ^ (2*a + 1) = z * (z^a)^2" |
558 lemma zpower_odd: "(z::int) ^ (2*a + 1) = z * (z^a)^2" |
484 by (simp add: zpower_even zpower_zadd_distrib) |
559 by (simp add: zpower_even zpower_zadd_distrib) |
485 |
560 |
486 lemma zpower_number_of_even: |
561 lemma zpower_number_of_even: |
487 "(z::int) ^ number_of (w BIT False) = |
562 "(z::int) ^ number_of (w BIT False) = |
488 (let w = z ^ (number_of w) in w*w)" |
563 (let w = z ^ (number_of w) in w*w)" |
489 apply (simp del: nat_number_of add: nat_number_of_def number_of_BIT Let_def) |
564 apply (simp del: nat_number_of add: nat_number_of_def number_of_BIT Let_def) |
490 apply (simp only: number_of_add) |
565 apply (simp only: number_of_add) |
491 apply (rule_tac x = "number_of w" in spec, clarify) |
566 apply (rule_tac x = "number_of w" in spec, clarify) |
492 apply (case_tac " (0::int) <= x") |
567 apply (case_tac " (0::int) <= x") |
493 apply (auto simp add: nat_mult_distrib zpower_even zpower_two) |
568 apply (auto simp add: nat_mult_distrib zpower_even power2_eq_square) |
494 done |
569 done |
495 |
570 |
496 lemma zpower_number_of_odd: |
571 lemma zpower_number_of_odd: |
497 "(z::int) ^ number_of (w BIT True) = |
572 "(z::int) ^ number_of (w BIT True) = |
498 (if (0::int) <= number_of w |
573 (if (0::int) <= number_of w |
499 then (let w = z ^ (number_of w) in z*w*w) |
574 then (let w = z ^ (number_of w) in z*w*w) |
500 else 1)" |
575 else 1)" |
501 apply (simp del: nat_number_of add: nat_number_of_def number_of_BIT Let_def) |
576 apply (simp del: nat_number_of add: nat_number_of_def number_of_BIT Let_def) |
502 apply (simp only: number_of_add int_numeral_1_eq_1 not_neg_eq_ge_0 neg_eq_less_0) |
577 apply (simp only: number_of_add int_numeral_1_eq_1 not_neg_eq_ge_0 neg_eq_less_0) |
503 apply (rule_tac x = "number_of w" in spec, clarify) |
578 apply (rule_tac x = "number_of w" in spec, clarify) |
504 apply (auto simp add: nat_add_distrib nat_mult_distrib zpower_even zpower_two neg_nat) |
579 apply (auto simp add: nat_add_distrib nat_mult_distrib zpower_even power2_eq_square neg_nat) |
505 done |
580 done |
506 |
581 |
507 declare zpower_number_of_even [of "number_of v", standard, simp] |
582 declare zpower_number_of_even [of "number_of v", standard, simp] |
508 declare zpower_number_of_odd [of "number_of v", standard, simp] |
583 declare zpower_number_of_odd [of "number_of v", standard, simp] |
509 |
584 |
567 |
642 |
568 lemma Let_Suc [simp]: "Let (Suc n) f == f (Suc n)" |
643 lemma Let_Suc [simp]: "Let (Suc n) f == f (Suc n)" |
569 by (simp add: Let_def) |
644 by (simp add: Let_def) |
570 |
645 |
571 |
646 |
572 subsection {*More ML Bindings*} |
647 subsection {*Lemmas for the Combination and Cancellation Simprocs*} |
|
648 |
|
649 lemma nat_number_of_add_left: |
|
650 "number_of v + (number_of v' + (k::nat)) = |
|
651 (if neg (number_of v) then number_of v' + k |
|
652 else if neg (number_of v') then number_of v + k |
|
653 else number_of (bin_add v v') + k)" |
|
654 apply simp |
|
655 done |
|
656 |
|
657 |
|
658 (** For combine_numerals **) |
|
659 |
|
660 lemma left_add_mult_distrib: "i*u + (j*u + k) = (i+j)*u + (k::nat)" |
|
661 by (simp add: add_mult_distrib) |
|
662 |
|
663 |
|
664 (** For cancel_numerals **) |
|
665 |
|
666 lemma nat_diff_add_eq1: |
|
667 "j <= (i::nat) ==> ((i*u + m) - (j*u + n)) = (((i-j)*u + m) - n)" |
|
668 by (simp split add: nat_diff_split add: add_mult_distrib) |
|
669 |
|
670 lemma nat_diff_add_eq2: |
|
671 "i <= (j::nat) ==> ((i*u + m) - (j*u + n)) = (m - ((j-i)*u + n))" |
|
672 by (simp split add: nat_diff_split add: add_mult_distrib) |
|
673 |
|
674 lemma nat_eq_add_iff1: |
|
675 "j <= (i::nat) ==> (i*u + m = j*u + n) = ((i-j)*u + m = n)" |
|
676 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
677 |
|
678 lemma nat_eq_add_iff2: |
|
679 "i <= (j::nat) ==> (i*u + m = j*u + n) = (m = (j-i)*u + n)" |
|
680 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
681 |
|
682 lemma nat_less_add_iff1: |
|
683 "j <= (i::nat) ==> (i*u + m < j*u + n) = ((i-j)*u + m < n)" |
|
684 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
685 |
|
686 lemma nat_less_add_iff2: |
|
687 "i <= (j::nat) ==> (i*u + m < j*u + n) = (m < (j-i)*u + n)" |
|
688 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
689 |
|
690 lemma nat_le_add_iff1: |
|
691 "j <= (i::nat) ==> (i*u + m <= j*u + n) = ((i-j)*u + m <= n)" |
|
692 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
693 |
|
694 lemma nat_le_add_iff2: |
|
695 "i <= (j::nat) ==> (i*u + m <= j*u + n) = (m <= (j-i)*u + n)" |
|
696 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
697 |
|
698 |
|
699 (** For cancel_numeral_factors **) |
|
700 |
|
701 lemma nat_mult_le_cancel1: "(0::nat) < k ==> (k*m <= k*n) = (m<=n)" |
|
702 by auto |
|
703 |
|
704 lemma nat_mult_less_cancel1: "(0::nat) < k ==> (k*m < k*n) = (m<n)" |
|
705 by auto |
|
706 |
|
707 lemma nat_mult_eq_cancel1: "(0::nat) < k ==> (k*m = k*n) = (m=n)" |
|
708 by auto |
|
709 |
|
710 lemma nat_mult_div_cancel1: "(0::nat) < k ==> (k*m) div (k*n) = (m div n)" |
|
711 by auto |
|
712 |
|
713 |
|
714 (** For cancel_factor **) |
|
715 |
|
716 lemma nat_mult_le_cancel_disj: "(k*m <= k*n) = ((0::nat) < k --> m<=n)" |
|
717 by auto |
|
718 |
|
719 lemma nat_mult_less_cancel_disj: "(k*m < k*n) = ((0::nat) < k & m<n)" |
|
720 by auto |
|
721 |
|
722 lemma nat_mult_eq_cancel_disj: "(k*m = k*n) = (k = (0::nat) | m=n)" |
|
723 by auto |
|
724 |
|
725 lemma nat_mult_div_cancel_disj: |
|
726 "(k*m) div (k*n) = (if k = (0::nat) then 0 else m div n)" |
|
727 by (simp add: nat_mult_div_cancel1) |
|
728 |
573 |
729 |
574 ML |
730 ML |
575 {* |
731 {* |
576 val eq_nat_nat_iff = thm"eq_nat_nat_iff"; |
732 val eq_nat_nat_iff = thm"eq_nat_nat_iff"; |
577 val eq_nat_number_of = thm"eq_nat_number_of"; |
733 val eq_nat_number_of = thm"eq_nat_number_of"; |
578 val less_nat_number_of = thm"less_nat_number_of"; |
734 val less_nat_number_of = thm"less_nat_number_of"; |
579 val le_nat_number_of_eq_not_less = thm"le_nat_number_of_eq_not_less"; |
735 val le_nat_number_of_eq_not_less = thm"le_nat_number_of_eq_not_less"; |
|
736 val power2_eq_square = thm "power2_eq_square"; |
|
737 val zero_le_power2 = thm "zero_le_power2"; |
|
738 val zero_less_power2 = thm "zero_less_power2"; |
|
739 val zero_eq_power2 = thm "zero_eq_power2"; |
|
740 val abs_power2 = thm "abs_power2"; |
|
741 val power2_abs = thm "power2_abs"; |
|
742 val power2_minus = thm "power2_minus"; |
|
743 val power_minus1_even = thm "power_minus1_even"; |
|
744 val power_minus_even = thm "power_minus_even"; |
|
745 val zero_le_even_power = thm "zero_le_even_power"; |
|
746 val odd_power_less_zero = thm "odd_power_less_zero"; |
|
747 val odd_0_le_power_imp_0_le = thm "odd_0_le_power_imp_0_le"; |
|
748 |
580 val Suc_pred' = thm"Suc_pred'"; |
749 val Suc_pred' = thm"Suc_pred'"; |
581 val expand_Suc = thm"expand_Suc"; |
750 val expand_Suc = thm"expand_Suc"; |
582 val Suc_eq_add_numeral_1 = thm"Suc_eq_add_numeral_1"; |
751 val Suc_eq_add_numeral_1 = thm"Suc_eq_add_numeral_1"; |
583 val add_eq_if = thm"add_eq_if"; |
752 val add_eq_if = thm"add_eq_if"; |
584 val mult_eq_if = thm"mult_eq_if"; |
753 val mult_eq_if = thm"mult_eq_if"; |
585 val power_eq_if = thm"power_eq_if"; |
754 val power_eq_if = thm"power_eq_if"; |
586 val diff_less' = thm"diff_less'"; |
755 val diff_less' = thm"diff_less'"; |
587 val power_two = thm"power_two"; |
|
588 val eq_number_of_0 = thm"eq_number_of_0"; |
756 val eq_number_of_0 = thm"eq_number_of_0"; |
589 val eq_0_number_of = thm"eq_0_number_of"; |
757 val eq_0_number_of = thm"eq_0_number_of"; |
590 val less_0_number_of = thm"less_0_number_of"; |
758 val less_0_number_of = thm"less_0_number_of"; |
591 val neg_imp_number_of_eq_0 = thm"neg_imp_number_of_eq_0"; |
759 val neg_imp_number_of_eq_0 = thm"neg_imp_number_of_eq_0"; |
592 val eq_number_of_Suc = thm"eq_number_of_Suc"; |
760 val eq_number_of_Suc = thm"eq_number_of_Suc"; |
600 val eq_number_of_BIT_Min = thm"eq_number_of_BIT_Min"; |
768 val eq_number_of_BIT_Min = thm"eq_number_of_BIT_Min"; |
601 val eq_number_of_Pls_Min = thm"eq_number_of_Pls_Min"; |
769 val eq_number_of_Pls_Min = thm"eq_number_of_Pls_Min"; |
602 val nat_power_eq = thm"nat_power_eq"; |
770 val nat_power_eq = thm"nat_power_eq"; |
603 val power_nat_number_of = thm"power_nat_number_of"; |
771 val power_nat_number_of = thm"power_nat_number_of"; |
604 val zpower_even = thm"zpower_even"; |
772 val zpower_even = thm"zpower_even"; |
605 val zpower_two = thm"zpower_two"; |
|
606 val zpower_odd = thm"zpower_odd"; |
773 val zpower_odd = thm"zpower_odd"; |
607 val zpower_number_of_even = thm"zpower_number_of_even"; |
774 val zpower_number_of_even = thm"zpower_number_of_even"; |
608 val zpower_number_of_odd = thm"zpower_number_of_odd"; |
775 val zpower_number_of_odd = thm"zpower_number_of_odd"; |
609 val nat_number_of_Pls = thm"nat_number_of_Pls"; |
776 val nat_number_of_Pls = thm"nat_number_of_Pls"; |
610 val nat_number_of_Min = thm"nat_number_of_Min"; |
777 val nat_number_of_Min = thm"nat_number_of_Min"; |
611 val nat_number_of_BIT_True = thm"nat_number_of_BIT_True"; |
778 val nat_number_of_BIT_True = thm"nat_number_of_BIT_True"; |
612 val nat_number_of_BIT_False = thm"nat_number_of_BIT_False"; |
779 val nat_number_of_BIT_False = thm"nat_number_of_BIT_False"; |
613 val Let_Suc = thm"Let_Suc"; |
780 val Let_Suc = thm"Let_Suc"; |
614 |
781 |
615 val nat_number = thms"nat_number"; |
782 val nat_number = thms"nat_number"; |
616 *} |
783 |
617 |
|
618 subsection {*Lemmas for the Combination and Cancellation Simprocs*} |
|
619 |
|
620 lemma nat_number_of_add_left: |
|
621 "number_of v + (number_of v' + (k::nat)) = |
|
622 (if neg (number_of v) then number_of v' + k |
|
623 else if neg (number_of v') then number_of v + k |
|
624 else number_of (bin_add v v') + k)" |
|
625 apply simp |
|
626 done |
|
627 |
|
628 |
|
629 (** For combine_numerals **) |
|
630 |
|
631 lemma left_add_mult_distrib: "i*u + (j*u + k) = (i+j)*u + (k::nat)" |
|
632 by (simp add: add_mult_distrib) |
|
633 |
|
634 |
|
635 (** For cancel_numerals **) |
|
636 |
|
637 lemma nat_diff_add_eq1: |
|
638 "j <= (i::nat) ==> ((i*u + m) - (j*u + n)) = (((i-j)*u + m) - n)" |
|
639 by (simp split add: nat_diff_split add: add_mult_distrib) |
|
640 |
|
641 lemma nat_diff_add_eq2: |
|
642 "i <= (j::nat) ==> ((i*u + m) - (j*u + n)) = (m - ((j-i)*u + n))" |
|
643 by (simp split add: nat_diff_split add: add_mult_distrib) |
|
644 |
|
645 lemma nat_eq_add_iff1: |
|
646 "j <= (i::nat) ==> (i*u + m = j*u + n) = ((i-j)*u + m = n)" |
|
647 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
648 |
|
649 lemma nat_eq_add_iff2: |
|
650 "i <= (j::nat) ==> (i*u + m = j*u + n) = (m = (j-i)*u + n)" |
|
651 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
652 |
|
653 lemma nat_less_add_iff1: |
|
654 "j <= (i::nat) ==> (i*u + m < j*u + n) = ((i-j)*u + m < n)" |
|
655 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
656 |
|
657 lemma nat_less_add_iff2: |
|
658 "i <= (j::nat) ==> (i*u + m < j*u + n) = (m < (j-i)*u + n)" |
|
659 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
660 |
|
661 lemma nat_le_add_iff1: |
|
662 "j <= (i::nat) ==> (i*u + m <= j*u + n) = ((i-j)*u + m <= n)" |
|
663 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
664 |
|
665 lemma nat_le_add_iff2: |
|
666 "i <= (j::nat) ==> (i*u + m <= j*u + n) = (m <= (j-i)*u + n)" |
|
667 by (auto split add: nat_diff_split simp add: add_mult_distrib) |
|
668 |
|
669 |
|
670 (** For cancel_numeral_factors **) |
|
671 |
|
672 lemma nat_mult_le_cancel1: "(0::nat) < k ==> (k*m <= k*n) = (m<=n)" |
|
673 by auto |
|
674 |
|
675 lemma nat_mult_less_cancel1: "(0::nat) < k ==> (k*m < k*n) = (m<n)" |
|
676 by auto |
|
677 |
|
678 lemma nat_mult_eq_cancel1: "(0::nat) < k ==> (k*m = k*n) = (m=n)" |
|
679 by auto |
|
680 |
|
681 lemma nat_mult_div_cancel1: "(0::nat) < k ==> (k*m) div (k*n) = (m div n)" |
|
682 by auto |
|
683 |
|
684 |
|
685 (** For cancel_factor **) |
|
686 |
|
687 lemma nat_mult_le_cancel_disj: "(k*m <= k*n) = ((0::nat) < k --> m<=n)" |
|
688 by auto |
|
689 |
|
690 lemma nat_mult_less_cancel_disj: "(k*m < k*n) = ((0::nat) < k & m<n)" |
|
691 by auto |
|
692 |
|
693 lemma nat_mult_eq_cancel_disj: "(k*m = k*n) = (k = (0::nat) | m=n)" |
|
694 by auto |
|
695 |
|
696 lemma nat_mult_div_cancel_disj: |
|
697 "(k*m) div (k*n) = (if k = (0::nat) then 0 else m div n)" |
|
698 by (simp add: nat_mult_div_cancel1) |
|
699 |
|
700 ML |
|
701 {* |
|
702 val nat_number_of_add_left = thm"nat_number_of_add_left"; |
784 val nat_number_of_add_left = thm"nat_number_of_add_left"; |
703 val left_add_mult_distrib = thm"left_add_mult_distrib"; |
785 val left_add_mult_distrib = thm"left_add_mult_distrib"; |
704 val nat_diff_add_eq1 = thm"nat_diff_add_eq1"; |
786 val nat_diff_add_eq1 = thm"nat_diff_add_eq1"; |
705 val nat_diff_add_eq2 = thm"nat_diff_add_eq2"; |
787 val nat_diff_add_eq2 = thm"nat_diff_add_eq2"; |
706 val nat_eq_add_iff1 = thm"nat_eq_add_iff1"; |
788 val nat_eq_add_iff1 = thm"nat_eq_add_iff1"; |