#| Copyright (C) 1990-1994 Computational Logic, Inc. All Rights Reserved. FM9001 PUBLIC SOFTWARE LICENSE Computational Logic, Inc. 1717 West Sixth, Suite 290 Austin, Texas 78703-4776 Please read this license carefully before using the FM9001 Software. By using the FM9001 Software, you are agreeing to be bound by the terms of this license. If you do not agree to the terms of this license, promptly return the FM9001 Software to the place where you obtained it. The FM9001 Software was developed by Computational Logic, Inc.(CLI). You own the disk or other medium on which the FM9001 Software is recorded, but CLI retains title to the FM9001 Software. The purposes of this license are to identify the FM9001 Software and to make the FM9001 Software, including its source code, freely available. This license allows you to use, copy, distribute and modify the FM9001 Software, on the condition that you comply with all the Copying Policies set out below. COPYING POLICIES 1. You may copy and distribute verbatim copies of the FM9001 Software as you receive it, in any medium, including embedding it verbatim in derivative works, provided that you a) conspicuously and appropriately publish on each copy a valid copyright notice "Copyright (C) 1990-1994 by Computational Logic, Inc. All Rights Reserved.", b) keep intact on all files the notices that refer to this License Agreement and to the absence of any warranty, and c) give all recipients of the FM9001 Software a copy of this License Agreement along with the program. 2. You may modify your copy or copies of the FM9001 Software or any portion of it, and copy and distribute such modifications provided you tell recipients that what they have is a modification by your organization of the CLI version of the FM9001 Software. 3. You may incorporate parts of the FM9001 Software into other programs provided that you acknowledge Computational Logic Inc. in the program documentation. CLI also requests, but does not require, that any improvements or extensions to the FM9001 Software be returned to one of the addresses below, so that they may be shared with other FM9001 users. The FM9001 Software, including its source, can be obtained by contacting one of these addresses. Software-Request or Software-Request@CLI.COM Computational Logic Inc. 1717 West Sixth, Suite 290 Austin, TX 78703-4776 NO WARRANTY BECAUSE THE FM9001 SOFTWARE IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO WARRANTY. THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, ANY IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE FM9001 SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. IN NO EVENT WILL COMPUTATIONAL LOGIC INC. BE LIABLE TO YOU FOR ANY DAMAGES, ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE FM9001 SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES), EVEN IF YOU HAVE ADVISED US OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. |# (BOOT-STRAP NQTHM) (SETQ REDUCE-TERM-CLOCK 2000) (DEFN DELETE (X L) (IF (LISTP L) (IF (EQUAL X (CAR L)) (CDR L) (CONS (CAR L) (DELETE X (CDR L)))) L)) (DEFN BAGDIFF (X Y) (IF (LISTP Y) (IF (MEMBER (CAR Y) X) (BAGDIFF (DELETE (CAR Y) X) (CDR Y)) (BAGDIFF X (CDR Y))) X)) (DEFN BAGINT (X Y) (IF (LISTP X) (IF (MEMBER (CAR X) Y) (CONS (CAR X) (BAGINT (CDR X) (DELETE (CAR X) Y))) (BAGINT (CDR X) Y)) NIL)) (DEFN OCCURRENCES (X L) (IF (LISTP L) (IF (EQUAL X (CAR L)) (ADD1 (OCCURRENCES X (CDR L))) (OCCURRENCES X (CDR L))) 0)) (DEFN SUBBAGP (X Y) (IF (LISTP X) (IF (MEMBER (CAR X) Y) (SUBBAGP (CDR X) (DELETE (CAR X) Y)) F) T)) (PROVE-LEMMA LISTP-DELETE (REWRITE) (EQUAL (LISTP (DELETE X L)) (IF (LISTP L) (OR (NOT (EQUAL X (CAR L))) (LISTP (CDR L))) F)) ((ENABLE DELETE) (INDUCT (DELETE X L)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE LISTP-DELETE-OFF LISTP-DELETE T) (PROVE-LEMMA DELETE-NON-MEMBER (REWRITE) (IMPLIES (NOT (MEMBER X Y)) (EQUAL (DELETE X Y) Y)) ((ENABLE DELETE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DELETE-DELETE (REWRITE) (EQUAL (DELETE Y (DELETE X Z)) (DELETE X (DELETE Y Z))) ((ENABLE DELETE DELETE-NON-MEMBER) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-OCCURRENCES-ZERO (REWRITE) (EQUAL (EQUAL (OCCURRENCES X L) 0) (NOT (MEMBER X L))) ((ENABLE OCCURRENCES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA MEMBER-NON-LIST (REWRITE) (IMPLIES (NOT (LISTP L)) (NOT (MEMBER X L))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA MEMBER-DELETE (REWRITE) (EQUAL (MEMBER X (DELETE Y L)) (IF (MEMBER X L) (IF (EQUAL X Y) (LESSP 1 (OCCURRENCES X L)) T) F)) ((ENABLE DELETE OCCURRENCES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA MEMBER-DELETE-IMPLIES-MEMBERSHIP (REWRITE) (IMPLIES (MEMBER X (DELETE Y L)) (MEMBER X L)) ((ENABLE DELETE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA OCCURRENCES-DELETE (REWRITE) (EQUAL (OCCURRENCES X (DELETE Y L)) (IF (EQUAL X Y) (IF (MEMBER X L) (SUB1 (OCCURRENCES X L)) 0) (OCCURRENCES X L))) ((ENABLE OCCURRENCES DELETE EQUAL-OCCURRENCES-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA MEMBER-BAGDIFF (REWRITE) (EQUAL (MEMBER X (BAGDIFF A B)) (LESSP (OCCURRENCES X B) (OCCURRENCES X A))) ((ENABLE BAGDIFF OCCURRENCES EQUAL-OCCURRENCES-ZERO OCCURRENCES-DELETE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA BAGDIFF-DELETE (REWRITE) (EQUAL (BAGDIFF (DELETE E X) Y) (DELETE E (BAGDIFF X Y))) ((ENABLE BAGDIFF DELETE DELETE-DELETE DELETE-NON-MEMBER MEMBER-BAGDIFF MEMBER-DELETE OCCURRENCES-DELETE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA SUBBAGP-DELETE (REWRITE) (IMPLIES (SUBBAGP X (DELETE U Y)) (SUBBAGP X Y)) ((ENABLE DELETE SUBBAGP DELETE-DELETE MEMBER-DELETE-IMPLIES-MEMBERSHIP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA SUBBAGP-CDR1 (REWRITE) (IMPLIES (SUBBAGP X Y) (SUBBAGP (CDR X) Y)) ((ENABLE SUBBAGP SUBBAGP-DELETE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA SUBBAGP-CDR2 (REWRITE) (IMPLIES (SUBBAGP X (CDR Y)) (SUBBAGP X Y)) ((ENABLE DELETE SUBBAGP DELETE-NON-MEMBER SUBBAGP-CDR1) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA SUBBAGP-BAGINT1 (REWRITE) (SUBBAGP (BAGINT X Y) X) ((ENABLE DELETE SUBBAGP BAGINT SUBBAGP-CDR2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA SUBBAGP-BAGINT2 (REWRITE) (SUBBAGP (BAGINT X Y) Y) ((ENABLE SUBBAGP BAGINT SUBBAGP-CDR2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA OCCURRENCES-BAGINT (REWRITE) (EQUAL (OCCURRENCES X (BAGINT A B)) (IF (LESSP (OCCURRENCES X A) (OCCURRENCES X B)) (OCCURRENCES X A) (OCCURRENCES X B))) ((ENABLE OCCURRENCES BAGINT EQUAL-OCCURRENCES-ZERO OCCURRENCES-DELETE))) (PROVE-LEMMA OCCURRENCES-BAGDIFF (REWRITE) (EQUAL (OCCURRENCES X (BAGDIFF A B)) (DIFFERENCE (OCCURRENCES X A) (OCCURRENCES X B))) ((ENABLE OCCURRENCES BAGDIFF EQUAL-OCCURRENCES-ZERO OCCURRENCES-DELETE))) (PROVE-LEMMA MEMBER-BAGINT (REWRITE) (EQUAL (MEMBER X (BAGINT A B)) (AND (MEMBER X A) (MEMBER X B))) ((ENABLE BAGINT MEMBER-DELETE))) (DEFTHEORY BAGS (OCCURRENCES-BAGINT BAGDIFF-DELETE OCCURRENCES-BAGDIFF MEMBER-BAGINT MEMBER-BAGDIFF SUBBAGP-BAGINT2 SUBBAGP-BAGINT1 SUBBAGP-CDR2 SUBBAGP-CDR1 SUBBAGP-DELETE)) (PROVE-LEMMA EQUAL-PLUS-0 (REWRITE) (EQUAL (EQUAL (PLUS A B) 0) (AND (ZEROP A) (ZEROP B))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA PLUS-CANCELLATION (REWRITE) (EQUAL (EQUAL (PLUS A B) (PLUS A C)) (EQUAL (FIX B) (FIX C))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE PLUS-CANCELLATION-OFF PLUS-CANCELLATION T) (PROVE-LEMMA EQUAL-DIFFERENCE-0 (REWRITE) (AND (EQUAL (EQUAL (DIFFERENCE X Y) 0) (NOT (LESSP Y X))) (EQUAL (EQUAL 0 (DIFFERENCE X Y)) (NOT (LESSP Y X)))) ((INDUCT (DIFFERENCE X Y)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-CANCELLATION (REWRITE) (EQUAL (EQUAL (DIFFERENCE X Y) (DIFFERENCE Z Y)) (COND ((LESSP X Y) (NOT (LESSP Y Z))) ((LESSP Z Y) (NOT (LESSP Y X))) (T (EQUAL (FIX X) (FIX Z))))) ((ENABLE EQUAL-DIFFERENCE-0) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE DIFFERENCE-CANCELLATION-OFF DIFFERENCE-CANCELLATION T) (PROVE-LEMMA COMMUTATIVITY-OF-PLUS (REWRITE) (EQUAL (PLUS X Y) (PLUS Y X)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY2-OF-PLUS (REWRITE) (EQUAL (PLUS X Y Z) (PLUS Y X Z)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA PLUS-ZERO-ARG2 (REWRITE) (IMPLIES (ZEROP Y) (EQUAL (PLUS X Y) (FIX X))) ((INDUCT (PLUS X Y)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA PLUS-ADD1-ARG1 (REWRITE) (EQUAL (PLUS (ADD1 A) B) (ADD1 (PLUS A B))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA PLUS-ADD1-ARG2 (REWRITE) (EQUAL (PLUS X (ADD1 Y)) (IF (NUMBERP Y) (ADD1 (PLUS X Y)) (ADD1 X))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ASSOCIATIVITY-OF-PLUS (REWRITE) (EQUAL (PLUS (PLUS X Y) Z) (PLUS X Y Z)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA PLUS-DIFFERENCE-ARG1 (REWRITE) (EQUAL (PLUS (DIFFERENCE A B) C) (IF (LESSP B A) (DIFFERENCE (PLUS A C) B) (PLUS 0 C))) ((INDUCT (DIFFERENCE A B)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA PLUS-DIFFERENCE-ARG2 (REWRITE) (EQUAL (PLUS A (DIFFERENCE B C)) (IF (LESSP C B) (DIFFERENCE (PLUS A B) C) (PLUS A 0))) ((INDUCT (PLUS A B)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-PLUS-CANCELLATION-PROOF NIL (EQUAL (DIFFERENCE (PLUS X Y) X) (FIX Y)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-PLUS-CANCELLATION (REWRITE) (AND (EQUAL (DIFFERENCE (PLUS X Y) X) (FIX Y)) (EQUAL (DIFFERENCE (PLUS Y X) X) (FIX Y))) ((USE (DIFFERENCE-PLUS-CANCELLATION-PROOF (X X) (Y Y))) (ENABLE COMMUTATIVITY-OF-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE DIFFERENCE-PLUS-CANCELLATION-OFF DIFFERENCE-PLUS-CANCELLATION T) (PROVE-LEMMA DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF NIL (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z)) (DIFFERENCE Y Z)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-PLUS-PLUS-CANCELLATION (REWRITE) (AND (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z)) (DIFFERENCE Y Z)) (EQUAL (DIFFERENCE (PLUS Y X) (PLUS X Z)) (DIFFERENCE Y Z)) (EQUAL (DIFFERENCE (PLUS X Y) (PLUS Z X)) (DIFFERENCE Y Z)) (EQUAL (DIFFERENCE (PLUS Y X) (PLUS Z X)) (DIFFERENCE Y Z))) ((USE (DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF (X X) (Y Y) (Z Z))) (ENABLE COMMUTATIVITY-OF-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE DIFFERENCE-PLUS-PLUS-CANCELLATION-OFF DIFFERENCE-PLUS-PLUS-CANCELLATION T) (PROVE-LEMMA DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK (REWRITE) (EQUAL (DIFFERENCE (PLUS W X A) (PLUS Y Z A)) (DIFFERENCE (PLUS W X) (PLUS Y Z))) ((ENABLE COMMUTATIVITY-OF-PLUS COMMUTATIVITY2-OF-PLUS DIFFERENCE-PLUS-PLUS-CANCELLATION) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK-OFF DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK T) (PROVE-LEMMA DIFF-SUB1-ARG2 (REWRITE) (EQUAL (DIFFERENCE A (SUB1 B)) (COND ((ZEROP B) (FIX A)) ((LESSP A B) 0) (T (ADD1 (DIFFERENCE A B))))) ((INDUCT (DIFFERENCE A B)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE DIFF-SUB1-ARG2-OFF DIFF-SUB1-ARG2 T) (PROVE-LEMMA DIFF-DIFF-ARG1 (REWRITE) (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z) (DIFFERENCE X (PLUS Y Z))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFF-DIFF-ARG2 (REWRITE) (EQUAL (DIFFERENCE A (DIFFERENCE B C)) (IF (LESSP B C) (FIX A) (DIFFERENCE (PLUS A C) B))) ((ENABLE DIFF-SUB1-ARG2 PLUS-ZERO-ARG2) (INDUCT (DIFFERENCE A B)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFF-DIFF-DIFF (REWRITE) (IMPLIES (AND (IF (LESSP A B) F T) (IF (LESSP C D) F T)) (EQUAL (DIFFERENCE (DIFFERENCE A B) (DIFFERENCE C D)) (DIFFERENCE (PLUS A D) (PLUS B C)))) ((ENABLE DIFF-DIFF-ARG1 DIFF-DIFF-ARG2 PLUS-DIFFERENCE-ARG2 PLUS-ZERO-ARG2) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE DIFF-DIFF-DIFF-OFF DIFF-DIFF-DIFF T) (PROVE-LEMMA DIFFERENCE-LESSP-ARG1 (REWRITE) (IMPLIES (LESSP A B) (EQUAL (DIFFERENCE A B) 0)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE DIFFERENCE-LESSP-ARG1-OFF DIFFERENCE-LESSP-ARG1 T) (DEFN PLUS-FRINGE (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'PLUS)) (APPEND (PLUS-FRINGE (CADR X)) (PLUS-FRINGE (CADDR X))) (LIST X))) (DEFN PLUS-TREE (L) (COND ((NLISTP L) ''0) ((NLISTP (CDR L)) (LIST 'FIX (CAR L))) ((NLISTP (CDDR L)) (LIST 'PLUS (CAR L) (CADR L))) (T (LIST 'PLUS (CAR L) (PLUS-TREE (CDR L)))))) (PROVE-LEMMA NUMBERP-EVAL$-PLUS (REWRITE) (IMPLIES (AND (LISTP X) (EQUAL (CAR X) 'PLUS)) (NUMBERP (EVAL$ T X A))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE NUMBERP-EVAL$-PLUS-OFF NUMBERP-EVAL$-PLUS T) (PROVE-LEMMA NUMBERP-EVAL$-PLUS-TREE (REWRITE) (NUMBERP (EVAL$ T (PLUS-TREE L) A)) ((ENABLE PLUS-TREE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE NUMBERP-EVAL$-PLUS-TREE-OFF NUMBERP-EVAL$-PLUS-TREE T) (PROVE-LEMMA MEMBER-IMPLIES-PLUS-TREE-GREATEREQP (REWRITE) (IMPLIES (MEMBER X Y) (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A) (EVAL$ T X A)))) ((ENABLE PLUS-TREE PLUS-ZERO-ARG2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE MEMBER-IMPLIES-PLUS-TREE-GREATEREQP-OFF MEMBER-IMPLIES-PLUS-TREE-GREATEREQP T) (PROVE-LEMMA PLUS-TREE-DELETE (REWRITE) (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A) (IF (MEMBER X Y) (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A) (EVAL$ T X A)) (EVAL$ T (PLUS-TREE Y) A))) ((ENABLE DELETE PLUS-TREE DELETE-NON-MEMBER DIFFERENCE-PLUS-CANCELLATION EQUAL-DIFFERENCE-0 EQUAL-PLUS-0 LISTP-DELETE MEMBER-IMPLIES-PLUS-TREE-GREATEREQP NUMBERP-EVAL$-PLUS-TREE PLUS-ZERO-ARG2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE PLUS-TREE-DELETE-OFF PLUS-TREE-DELETE T) (PROVE-LEMMA SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP (REWRITE) (IMPLIES (SUBBAGP X Y) (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A) (EVAL$ T (PLUS-TREE X) A)))) ((ENABLE PLUS-TREE SUBBAGP MEMBER-IMPLIES-PLUS-TREE-GREATEREQP PLUS-TREE-DELETE PLUS-ZERO-ARG2 SUBBAGP-CDR2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP-OFF SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP T) (PROVE-LEMMA PLUS-TREE-BAGDIFF (REWRITE) (IMPLIES (SUBBAGP X Y) (EQUAL (EVAL$ T (PLUS-TREE (BAGDIFF Y X)) A) (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A) (EVAL$ T (PLUS-TREE X) A)))) ((ENABLE BAGDIFF PLUS-TREE SUBBAGP COMMUTATIVITY-OF-PLUS DIFF-DIFF-ARG1 DIFFERENCE-LESSP-ARG1 MEMBER-IMPLIES-PLUS-TREE-GREATEREQP NUMBERP-EVAL$-PLUS-TREE PLUS-TREE-DELETE PLUS-ZERO-ARG2 SUBBAGP-CDR2 SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE PLUS-TREE-BAGDIFF-OFF PLUS-TREE-BAGDIFF T) (PROVE-LEMMA NUMBERP-EVAL$-BRIDGE (REWRITE) (IMPLIES (EQUAL (EVAL$ T Z A) (EVAL$ T (PLUS-TREE X) A)) (NUMBERP (EVAL$ T Z A))) ((ENABLE PLUS-TREE NUMBERP-EVAL$-PLUS-TREE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE NUMBERP-EVAL$-BRIDGE-OFF NUMBERP-EVAL$-BRIDGE T) (PROVE-LEMMA BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP (REWRITE) (IMPLIES (AND (SUBBAGP Y (PLUS-FRINGE Z)) (EQUAL (EVAL$ T Z A) (EVAL$ T (PLUS-TREE (PLUS-FRINGE Z)) A))) (EQUAL (LESSP (EVAL$ T Z A) (EVAL$ T (PLUS-TREE Y) A)) F)) ((ENABLE SUBBAGP PLUS-FRINGE PLUS-TREE SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP-OFF BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP T) (PROVE-LEMMA EVAL$-PLUS-TREE-APPEND (REWRITE) (EQUAL (EVAL$ T (PLUS-TREE (APPEND X Y)) A) (PLUS (EVAL$ T (PLUS-TREE X) A) (EVAL$ T (PLUS-TREE Y) A))) ((ENABLE PLUS-ZERO-ARG2 COMMUTATIVITY2-OF-PLUS COMMUTATIVITY-OF-PLUS EQUAL-PLUS-0 PLUS-CANCELLATION PLUS-TREE NUMBERP-EVAL$-PLUS-TREE NUMBERP-EVAL$-BRIDGE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-PLUS-TREE-APPEND-OFF EVAL$-PLUS-TREE-APPEND T) (PROVE-LEMMA PLUS-TREE-PLUS-FRINGE (REWRITE) (EQUAL (EVAL$ T (PLUS-TREE (PLUS-FRINGE X)) A) (FIX (EVAL$ T X A))) ((ENABLE PLUS-ZERO-ARG2 COMMUTATIVITY-OF-PLUS PLUS-FRINGE PLUS-TREE NUMBERP-EVAL$-PLUS NUMBERP-EVAL$-BRIDGE EVAL$-PLUS-TREE-APPEND) (INDUCT (PLUS-FRINGE X)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE PLUS-TREE-PLUS-FRINGE-OFF PLUS-TREE-PLUS-FRINGE T) (PROVE-LEMMA MEMBER-IMPLIES-NUMBERP (REWRITE) (IMPLIES (AND (MEMBER C (PLUS-FRINGE X)) (NUMBERP (EVAL$ T C A))) (NUMBERP (EVAL$ T X A))) ((ENABLE PLUS-FRINGE NUMBERP-EVAL$-PLUS) (INDUCT (PLUS-FRINGE X)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE MEMBER-IMPLIES-NUMBERP-OFF MEMBER-IMPLIES-NUMBERP T) (PROVE-LEMMA CADR-EVAL$-LIST (REWRITE) (AND (EQUAL (CAR (EVAL$ 'LIST X A)) (EVAL$ T (CAR X) A)) (EQUAL (CDR (EVAL$ 'LIST X A)) (IF (LISTP X) (EVAL$ 'LIST (CDR X) A) 0))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE CADR-EVAL$-LIST-OFF CADR-EVAL$-LIST T) (PROVE-LEMMA EVAL$-QUOTE (REWRITE) (EQUAL (EVAL$ T (CONS 'QUOTE ARGS) A) (CAR ARGS)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-QUOTE-OFF EVAL$-QUOTE T) (PROVE-LEMMA LISTP-EVAL$ (REWRITE) (EQUAL (LISTP (EVAL$ 'LIST X A)) (LISTP X)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE LISTP-EVAL$-OFF LISTP-EVAL$ T) (DEFN CANCEL-EQUAL-PLUS (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'EQUAL)) (COND ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'PLUS) (LISTP (CADDR X)) (EQUAL (CAADDR X) 'PLUS)) (LIST 'EQUAL (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADR X)) (BAGINT (PLUS-FRINGE (CADR X)) (PLUS-FRINGE (CADDR X))))) (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADDR X)) (BAGINT (PLUS-FRINGE (CADR X)) (PLUS-FRINGE (CADDR X))))))) ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'PLUS) (MEMBER (CADDR X) (PLUS-FRINGE (CADR X)))) (LIST 'IF (LIST 'NUMBERP (CADDR X)) (CONS 'EQUAL (CONS (PLUS-TREE (DELETE (CADDR X) (PLUS-FRINGE (CADR X)))) '('0))) (LIST 'QUOTE F))) ((AND (LISTP (CADDR X)) (EQUAL (CAADDR X) 'PLUS) (MEMBER (CADR X) (PLUS-FRINGE (CADDR X)))) (LIST 'IF (LIST 'NUMBERP (CADR X)) (LIST 'EQUAL ''0 (PLUS-TREE (DELETE (CADR X) (PLUS-FRINGE (CADDR X))))) (LIST 'QUOTE F))) (T X)) X)) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-EQUAL-PLUS ((META EQUAL)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-EQUAL-PLUS X) A)) ((ENABLE BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP CANCEL-EQUAL-PLUS DIFFERENCE-CANCELLATION EQUAL-DIFFERENCE-0 EVAL$-QUOTE MEMBER-IMPLIES-NUMBERP MEMBER-IMPLIES-PLUS-TREE-GREATEREQP NUMBERP-EVAL$-PLUS PLUS-TREE-BAGDIFF PLUS-TREE-DELETE PLUS-TREE-PLUS-FRINGE SUBBAGP-BAGINT1 SUBBAGP-BAGINT2) (DISABLE EVAL$) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN CANCEL-DIFFERENCE-PLUS (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'DIFFERENCE)) (COND ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'PLUS) (LISTP (CADDR X)) (EQUAL (CAADDR X) 'PLUS)) (LIST 'DIFFERENCE (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADR X)) (BAGINT (PLUS-FRINGE (CADR X)) (PLUS-FRINGE (CADDR X))))) (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADDR X)) (BAGINT (PLUS-FRINGE (CADR X)) (PLUS-FRINGE (CADDR X))))))) ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'PLUS) (MEMBER (CADDR X) (PLUS-FRINGE (CADR X)))) (PLUS-TREE (DELETE (CADDR X) (PLUS-FRINGE (CADR X))))) ((AND (LISTP (CADDR X)) (EQUAL (CAADDR X) 'PLUS) (MEMBER (CADR X) (PLUS-FRINGE (CADDR X)))) ''0) (T X)) X)) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-DIFFERENCE-PLUS ((META DIFFERENCE)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-DIFFERENCE-PLUS X) A)) ((ENABLE CANCEL-DIFFERENCE-PLUS ASSOCIATIVITY-OF-PLUS BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP COMMUTATIVITY-OF-PLUS DIFF-DIFF-DIFF DIFFERENCE-LESSP-ARG1 DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK EQUAL-DIFFERENCE-0 EVAL$-QUOTE MEMBER-IMPLIES-PLUS-TREE-GREATEREQP NUMBERP-EVAL$-PLUS PLUS-TREE-BAGDIFF PLUS-TREE-DELETE PLUS-TREE-PLUS-FRINGE SUBBAGP-BAGINT1 SUBBAGP-BAGINT2) (DISABLE EVAL$) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-ELIM (ELIM) (IMPLIES (AND (NUMBERP Y) (NOT (LESSP Y X))) (EQUAL (PLUS X (DIFFERENCE Y X)) Y)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-LEQ-ARG1 (REWRITE) (IMPLIES (IF (LESSP B A) F T) (EQUAL (DIFFERENCE A B) 0)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-ADD1-ARG2 (REWRITE) (EQUAL (DIFFERENCE A (ADD1 B)) (IF (LESSP B A) (SUB1 (DIFFERENCE A B)) 0)) ((ENABLE DIFFERENCE-LEQ-ARG1) (INDUCT (DIFFERENCE A B)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-SUB1-ARG2 (REWRITE) (EQUAL (DIFFERENCE A (SUB1 B)) (COND ((ZEROP B) (FIX A)) ((LESSP A B) 0) (T (ADD1 (DIFFERENCE A B))))) ((ENABLE DIFF-SUB1-ARG2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-DIFFERENCE-ARG1 (REWRITE) (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z) (DIFFERENCE X (PLUS Y Z))) ((ENABLE DIFF-DIFF-ARG1) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-DIFFERENCE-ARG2 (REWRITE) (EQUAL (DIFFERENCE A (DIFFERENCE B C)) (IF (LESSP B C) (FIX A) (DIFFERENCE (PLUS A C) B))) ((ENABLE DIFF-DIFF-ARG2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DIFFERENCE-X-X (REWRITE) (EQUAL (DIFFERENCE X X) 0) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-DIFFERENCE-CANCELLATION (REWRITE) (EQUAL (LESSP (DIFFERENCE A C) (DIFFERENCE B C)) (IF (IF (LESSP A C) F T) (LESSP A B) (LESSP C B))) ((ENABLE EQUAL-DIFFERENCE-0) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE LESSP-DIFFERENCE-CANCELLATION-OFF LESSP-DIFFERENCE-CANCELLATION T) (DEFN CANCEL-LESSP-PLUS (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'LESSP)) (COND ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'PLUS) (LISTP (CADDR X)) (EQUAL (CAADDR X) 'PLUS)) (LIST 'LESSP (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADR X)) (BAGINT (PLUS-FRINGE (CADR X)) (PLUS-FRINGE (CADDR X))))) (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADDR X)) (BAGINT (PLUS-FRINGE (CADR X)) (PLUS-FRINGE (CADDR X))))))) ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'PLUS) (MEMBER (CADDR X) (PLUS-FRINGE (CADR X)))) (LIST 'QUOTE F)) ((AND (LISTP (CADDR X)) (EQUAL (CAADDR X) 'PLUS) (MEMBER (CADR X) (PLUS-FRINGE (CADDR X)))) (LIST 'NOT (LIST 'ZEROP (PLUS-TREE (DELETE (CADR X) (PLUS-FRINGE (CADDR X))))))) (T X)) X)) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-LESSP-PLUS ((META LESSP)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-LESSP-PLUS X) A)) ((ENABLE CANCEL-LESSP-PLUS BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP EQUAL-DIFFERENCE-0 EVAL$-QUOTE LESSP-DIFFERENCE-CANCELLATION MEMBER-IMPLIES-PLUS-TREE-GREATEREQP NUMBERP-EVAL$-PLUS PLUS-TREE-BAGDIFF PLUS-TREE-DELETE PLUS-TREE-PLUS-FRINGE SUBBAGP-BAGINT1 SUBBAGP-BAGINT2) (DISABLE EVAL$) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFTHEORY ADDITION (EQUAL-PLUS-0 EQUAL-DIFFERENCE-0 COMMUTATIVITY-OF-PLUS COMMUTATIVITY2-OF-PLUS PLUS-ZERO-ARG2 PLUS-ADD1-ARG2 PLUS-ADD1-ARG1 ASSOCIATIVITY-OF-PLUS PLUS-DIFFERENCE-ARG1 PLUS-DIFFERENCE-ARG2 DIFF-DIFF-ARG1 DIFF-DIFF-ARG2 CORRECTNESS-OF-CANCEL-EQUAL-PLUS CORRECTNESS-OF-CANCEL-DIFFERENCE-PLUS DIFFERENCE-ELIM DIFFERENCE-LEQ-ARG1 DIFFERENCE-ADD1-ARG2 DIFFERENCE-SUB1-ARG2 DIFFERENCE-DIFFERENCE-ARG1 DIFFERENCE-DIFFERENCE-ARG2 DIFFERENCE-X-X CORRECTNESS-OF-CANCEL-LESSP-PLUS)) (PROVE-LEMMA EQUAL-TIMES-0 (REWRITE) (EQUAL (EQUAL (TIMES X Y) 0) (OR (ZEROP X) (ZEROP Y))) ((ENABLE EQUAL-PLUS-0) (INDUCT (TIMES X Y)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-TIMES-1 (REWRITE) (EQUAL (EQUAL (TIMES A B) 1) (AND (EQUAL A 1) (EQUAL B 1))) ((ENABLE EQUAL-PLUS-0) (INDUCT (TIMES A B)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-SUB1-0 (REWRITE) (EQUAL (EQUAL (SUB1 X) 0) (OR (ZEROP X) (EQUAL X 1))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-ZERO (REWRITE) (IMPLIES (ZEROP Y) (EQUAL (TIMES X Y) 0)) ((ENABLE PLUS-ZERO-ARG2 COMMUTATIVITY-OF-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-ADD1 (REWRITE) (EQUAL (TIMES X (ADD1 Y)) (IF (NUMBERP Y) (PLUS X (TIMES X Y)) (FIX X))) ((ENABLE PLUS-ZERO-ARG2 COMMUTATIVITY-OF-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY-OF-TIMES (REWRITE) (EQUAL (TIMES Y X) (TIMES X Y)) ((ENABLE TIMES-ZERO TIMES-ADD1) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-DISTRIBUTES-OVER-PLUS-PROOF NIL (EQUAL (TIMES X (PLUS Y Z)) (PLUS (TIMES X Y) (TIMES X Z))) ((ENABLE COMMUTATIVITY2-OF-PLUS ASSOCIATIVITY-OF-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-DISTRIBUTES-OVER-PLUS (REWRITE) (AND (EQUAL (TIMES X (PLUS Y Z)) (PLUS (TIMES X Y) (TIMES X Z))) (EQUAL (TIMES (PLUS X Y) Z) (PLUS (TIMES X Z) (TIMES Y Z)))) ((USE (TIMES-DISTRIBUTES-OVER-PLUS-PROOF (X X) (Y Y) (Z Z)) (TIMES-DISTRIBUTES-OVER-PLUS-PROOF (X Z) (Y X) (Z Y))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY2-OF-TIMES (REWRITE) (EQUAL (TIMES X Y Z) (TIMES Y X Z)) ((ENABLE COMMUTATIVITY-OF-TIMES TIMES-DISTRIBUTES-OVER-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ASSOCIATIVITY-OF-TIMES (REWRITE) (EQUAL (TIMES (TIMES X Y) Z) (TIMES X Y Z)) ((ENABLE COMMUTATIVITY-OF-TIMES COMMUTATIVITY2-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-DISTRIBUTES-OVER-DIFFERENCE-PROOF NIL (EQUAL (TIMES (DIFFERENCE A B) C) (DIFFERENCE (TIMES A C) (TIMES B C))) ((ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY ADDITION GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-DISTRIBUTES-OVER-DIFFERENCE (REWRITE) (AND (EQUAL (TIMES (DIFFERENCE A B) C) (DIFFERENCE (TIMES A C) (TIMES B C))) (EQUAL (TIMES A (DIFFERENCE B C)) (DIFFERENCE (TIMES A B) (TIMES A C)))) ((USE (TIMES-DISTRIBUTES-OVER-DIFFERENCE-PROOF (A A) (B B) (C C)) (TIMES-DISTRIBUTES-OVER-DIFFERENCE-PROOF (A B) (B C) (C A))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-QUOTIENT-PROOF NIL (IMPLIES (AND (NOT (ZEROP X)) (EQUAL (REMAINDER Y X) 0)) (EQUAL (TIMES (QUOTIENT Y X) X) (FIX Y))) ((ENABLE TIMES-ZERO TIMES-ADD1) (INDUCT (REMAINDER Y X)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-QUOTIENT (REWRITE) (IMPLIES (AND (NOT (ZEROP Y)) (EQUAL (REMAINDER X Y) 0)) (AND (EQUAL (TIMES (QUOTIENT X Y) Y) (FIX X)) (EQUAL (TIMES Y (QUOTIENT X Y)) (FIX X)))) ((USE (TIMES-QUOTIENT-PROOF (X Y) (Y X))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TIMES-1-ARG1 (REWRITE) (EQUAL (TIMES 1 X) (FIX X)) ((ENABLE TIMES-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES1-PROOF NIL (IMPLIES (AND (LESSP A B) (NOT (ZEROP C))) (EQUAL (LESSP A (TIMES B C)) T)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES1 (REWRITE) (IMPLIES (AND (LESSP A B) (NOT (ZEROP C))) (AND (EQUAL (LESSP A (TIMES B C)) T) (EQUAL (LESSP A (TIMES C B)) T))) ((ENABLE COMMUTATIVITY-OF-TIMES) (USE (LESSP-TIMES1-PROOF (A A) (B B) (C C))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES2-PROOF NIL (IMPLIES (AND (IF (LESSP B A) F T) (NOT (ZEROP C))) (EQUAL (LESSP (TIMES B C) A) F)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES2 (REWRITE) (IMPLIES (AND (IF (LESSP B A) F T) (NOT (ZEROP C))) (AND (EQUAL (LESSP (TIMES B C) A) F) (EQUAL (LESSP (TIMES C B) A) F))) ((ENABLE COMMUTATIVITY-OF-TIMES) (USE (LESSP-TIMES2-PROOF (A A) (B B) (C C))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES3-PROOF1 NIL (IMPLIES (AND (NOT (ZEROP A)) (LESSP 1 B)) (LESSP A (TIMES A B))) ((ENABLE-THEORY ADDITION GROUND-ZERO) (ENABLE TIMES-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES3-PROOF2 NIL (IMPLIES (LESSP A (TIMES A B)) (AND (NOT (ZEROP A)) (LESSP 1 B))) ((ENABLE-THEORY ADDITION GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES3 (REWRITE) (AND (EQUAL (LESSP A (TIMES A B)) (AND (NOT (ZEROP A)) (LESSP 1 B))) (EQUAL (LESSP A (TIMES B A)) (AND (NOT (ZEROP A)) (LESSP 1 B)))) ((ENABLE COMMUTATIVITY-OF-TIMES) (USE (LESSP-TIMES3-PROOF1 (A A) (B B)) (LESSP-TIMES3-PROOF2 (A A) (B B))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES-CANCELLATION-PROOF NIL (EQUAL (LESSP (TIMES X Z) (TIMES Y Z)) (AND (NOT (ZEROP Z)) (LESSP X Y))) ((ENABLE COMMUTATIVITY-OF-TIMES CORRECTNESS-OF-CANCEL-LESSP-PLUS TIMES-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-TIMES-CANCELLATION1 (REWRITE) (AND (EQUAL (LESSP (TIMES X Z) (TIMES Y Z)) (AND (NOT (ZEROP Z)) (LESSP X Y))) (EQUAL (LESSP (TIMES Z X) (TIMES Y Z)) (AND (NOT (ZEROP Z)) (LESSP X Y))) (EQUAL (LESSP (TIMES X Z) (TIMES Z Y)) (AND (NOT (ZEROP Z)) (LESSP X Y))) (EQUAL (LESSP (TIMES Z X) (TIMES Z Y)) (AND (NOT (ZEROP Z)) (LESSP X Y)))) ((USE (LESSP-TIMES-CANCELLATION-PROOF (X X) (Y Y) (Z Z))) (ENABLE COMMUTATIVITY-OF-TIMES) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE LESSP-TIMES-CANCELLATION1-OFF LESSP-TIMES-CANCELLATION1 T) (PROVE-LEMMA LESSP-PLUS-TIMES-PROOF NIL (IMPLIES (LESSP X A) (EQUAL (LESSP (PLUS X (TIMES A B)) (TIMES A C)) (LESSP B C))) ((ENABLE-THEORY ADDITION GROUND-ZERO) (ENABLE COMMUTATIVITY-OF-TIMES LESSP-TIMES-CANCELLATION1 LESSP-TIMES1 LESSP-TIMES2 LESSP-TIMES3 TIMES-ADD1 TIMES-ZERO) (INDUCT (LESSP B C)) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-PLUS-TIMES1 (REWRITE) (AND (EQUAL (LESSP (PLUS A (TIMES B C)) B) (AND (LESSP A B) (ZEROP C))) (EQUAL (LESSP (PLUS A (TIMES C B)) B) (AND (LESSP A B) (ZEROP C))) (EQUAL (LESSP (PLUS (TIMES C B) A) B) (AND (LESSP A B) (ZEROP C))) (EQUAL (LESSP (PLUS (TIMES B C) A) B) (AND (LESSP A B) (ZEROP C)))) ((USE (LESSP-PLUS-TIMES-PROOF (A B) (B C) (C 1) (X A))) (ENABLE COMMUTATIVITY-OF-PLUS COMMUTATIVITY-OF-TIMES TIMES-1-ARG1) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-PLUS-TIMES2 (REWRITE) (IMPLIES (AND (NOT (ZEROP A)) (LESSP X A)) (AND (EQUAL (LESSP (PLUS X (TIMES A B)) (TIMES A C)) (LESSP B C)) (EQUAL (LESSP (PLUS X (TIMES B A)) (TIMES A C)) (LESSP B C)) (EQUAL (LESSP (PLUS X (TIMES A B)) (TIMES C A)) (LESSP B C)) (EQUAL (LESSP (PLUS X (TIMES B A)) (TIMES C A)) (LESSP B C)) (EQUAL (LESSP (PLUS (TIMES A B) X) (TIMES A C)) (LESSP B C)) (EQUAL (LESSP (PLUS (TIMES B A) X) (TIMES A C)) (LESSP B C)) (EQUAL (LESSP (PLUS (TIMES A B) X) (TIMES C A)) (LESSP B C)) (EQUAL (LESSP (PLUS (TIMES B A) X) (TIMES C A)) (LESSP B C)))) ((ENABLE COMMUTATIVITY-OF-PLUS COMMUTATIVITY-OF-TIMES) (USE (LESSP-PLUS-TIMES-PROOF (A A) (B B) (C C) (X X))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-1-TIMES (REWRITE) (EQUAL (LESSP 1 (TIMES A B)) (NOT (OR (ZEROP A) (ZEROP B) (AND (EQUAL A 1) (EQUAL B 1))))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN TIMES-TREE (X) (COND ((NLISTP X) ''1) ((NLISTP (CDR X)) (LIST 'FIX (CAR X))) ((NLISTP (CDDR X)) (LIST 'TIMES (CAR X) (CADR X))) (T (LIST 'TIMES (CAR X) (TIMES-TREE (CDR X)))))) (DEFN TIMES-FRINGE (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'TIMES)) (APPEND (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X))) (LIST X))) (DEFN OR-ZEROP-TREE (X) (COND ((NLISTP X) '(FALSE)) ((NLISTP (CDR X)) (LIST 'ZEROP (CAR X))) ((NLISTP (CDDR X)) (LIST 'OR (LIST 'ZEROP (CAR X)) (LIST 'ZEROP (CADR X)))) (T (LIST 'OR (LIST 'ZEROP (CAR X)) (OR-ZEROP-TREE (CDR X)))))) (DEFN AND-NOT-ZEROP-TREE (X) (COND ((NLISTP X) '(TRUE)) ((NLISTP (CDR X)) (LIST 'NOT (LIST 'ZEROP (CAR X)))) (T (LIST 'AND (LIST 'NOT (LIST 'ZEROP (CAR X))) (AND-NOT-ZEROP-TREE (CDR X)))))) (PROVE-LEMMA NUMBERP-EVAL$-TIMES (REWRITE) (IMPLIES (EQUAL (CAR X) 'TIMES) (NUMBERP (EVAL$ T X A))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE NUMBERP-EVAL$-TIMES-OFF NUMBERP-EVAL$-TIMES T) (PROVE-LEMMA EVAL$-TIMES (REWRITE) (IMPLIES (EQUAL (CAR X) 'TIMES) (EQUAL (EVAL$ T X A) (TIMES (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-TIMES-OFF EVAL$-TIMES T) (PROVE-LEMMA EVAL$-OR (REWRITE) (IMPLIES (EQUAL (CAR X) 'OR) (EQUAL (EVAL$ T X A) (OR (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-OR-OFF EVAL$-OR T) (PROVE-LEMMA EVAL$-EQUAL (REWRITE) (IMPLIES (EQUAL (CAR X) 'EQUAL) (EQUAL (EVAL$ T X A) (EQUAL (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-EQUAL-OFF EVAL$-EQUAL T) (PROVE-LEMMA EVAL$-LESSP (REWRITE) (IMPLIES (EQUAL (CAR X) 'LESSP) (EQUAL (EVAL$ T X A) (LESSP (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-LESSP-OFF EVAL$-LESSP T) (PROVE-LEMMA EVAL$-QUOTIENT (REWRITE) (IMPLIES (EQUAL (CAR X) 'QUOTIENT) (EQUAL (EVAL$ T X A) (QUOTIENT (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-QUOTIENT-OFF EVAL$-QUOTIENT T) (PROVE-LEMMA EVAL$-IF (REWRITE) (IMPLIES (EQUAL (CAR X) 'IF) (EQUAL (EVAL$ T X A) (IF (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A) (EVAL$ T (CADDDR X) A)))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-IF-OFF EVAL$-IF T) (PROVE-LEMMA NUMBERP-EVAL$-TIMES-TREE (REWRITE) (NUMBERP (EVAL$ T (TIMES-TREE X) A)) ((ENABLE TIMES-TREE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE NUMBERP-EVAL$-TIMES-TREE-OFF NUMBERP-EVAL$-TIMES-TREE T) (PROVE-LEMMA LESSP-TIMES-ARG1 NIL (IMPLIES (NOT (ZEROP A)) (EQUAL (NOT (LESSP (TIMES A X) (TIMES A Y))) (NOT (LESSP X Y)))) ((INDUCT (PLUS A X)) (ENABLE TIMES CORRECTNESS-OF-CANCEL-LESSP-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INFER-EQUALITY-FROM-NOT-LESSP NIL (IMPLIES (AND (NUMBERP A) (NUMBERP B)) (EQUAL (AND (NOT (LESSP A B)) (NOT (LESSP B A))) (EQUAL A B))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-TIMES-ARG1 (REWRITE) (IMPLIES (NOT (ZEROP A)) (EQUAL (EQUAL (TIMES A X) (TIMES A Y)) (EQUAL (FIX X) (FIX Y)))) ((USE (LESSP-TIMES-ARG1 (A A) (X X) (Y Y)) (LESSP-TIMES-ARG1 (A A) (X Y) (Y X)) (INFER-EQUALITY-FROM-NOT-LESSP (A (TIMES A X)) (B (TIMES A Y)))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EQUAL-TIMES-ARG1-OFF EQUAL-TIMES-ARG1 T) (PROVE-LEMMA EQUAL-TIMES-BRIDGE (REWRITE) (EQUAL (EQUAL (TIMES A B) (TIMES C A D)) (OR (ZEROP A) (EQUAL (FIX B) (TIMES C D)))) ((ENABLE COMMUTATIVITY-OF-TIMES COMMUTATIVITY2-OF-TIMES EQUAL-TIMES-0 EQUAL-TIMES-ARG1 TIMES-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EQUAL-TIMES-BRIDGE-OFF EQUAL-TIMES-BRIDGE T) (PROVE-LEMMA EVAL$-TIMES-MEMBER (REWRITE) (IMPLIES (MEMBER E X) (EQUAL (EVAL$ T (TIMES-TREE X) A) (TIMES (EVAL$ T E A) (EVAL$ T (TIMES-TREE (DELETE E X)) A)))) ((ENABLE DELETE TIMES-TREE COMMUTATIVITY-OF-TIMES DELETE-NON-MEMBER EQUAL-TIMES-0 EQUAL-TIMES-BRIDGE LISTP-DELETE MEMBER-NON-LIST TIMES-1-ARG1 TIMES-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-TIMES-MEMBER-OFF EVAL$-TIMES-MEMBER T) (PROVE-LEMMA ZEROP-MAKES-TIMES-TREE-ZERO (REWRITE) (IMPLIES (AND (NOT (EVAL$ T (AND-NOT-ZEROP-TREE X) A)) (SUBBAGP X Y)) (EQUAL (EVAL$ T (TIMES-TREE Y) A) 0)) ((ENABLE AND-NOT-ZEROP-TREE COMMUTATIVITY-OF-TIMES EVAL$-TIMES-MEMBER SUBBAGP TIMES-TREE TIMES-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE ZEROP-MAKES-TIMES-TREE-ZERO-OFF ZEROP-MAKES-TIMES-TREE-ZERO T) (PROVE-LEMMA OR-ZEROP-TREE-IS-NOT-ZEROP-TREE (REWRITE) (EQUAL (EVAL$ T (OR-ZEROP-TREE X) A) (NOT (EVAL$ T (AND-NOT-ZEROP-TREE X) A))) ((ENABLE AND-NOT-ZEROP-TREE OR-ZEROP-TREE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE OR-ZEROP-TREE-IS-NOT-ZEROP-TREE-OFF OR-ZEROP-TREE-IS-NOT-ZEROP-TREE T) (PROVE-LEMMA ZEROP-MAKES-TIMES-TREE-ZERO2 (REWRITE) (IMPLIES (AND (EVAL$ T (OR-ZEROP-TREE X) A) (SUBBAGP X Y)) (EQUAL (EVAL$ T (TIMES-TREE Y) A) 0)) ((USE (ZEROP-MAKES-TIMES-TREE-ZERO) (OR-ZEROP-TREE-IS-NOT-ZEROP-TREE)) (ENABLE OR-ZEROP-TREE SUBBAGP TIMES-TREE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE ZEROP-MAKES-TIMES-TREE-ZERO2-OFF ZEROP-MAKES-TIMES-TREE-ZERO2 T) (PROVE-LEMMA TIMES-TREE-APPEND (REWRITE) (EQUAL (EVAL$ T (TIMES-TREE (APPEND X Y)) A) (TIMES (EVAL$ T (TIMES-TREE X) A) (EVAL$ T (TIMES-TREE Y) A))) ((ENABLE APPEND ASSOCIATIVITY-OF-TIMES COMMUTATIVITY-OF-TIMES COMMUTATIVITY2-OF-TIMES EQUAL-TIMES-0 EQUAL-TIMES-ARG1 EQUAL-TIMES-BRIDGE NUMBERP-EVAL$-TIMES-TREE TIMES-1-ARG1 TIMES-TREE TIMES-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE TIMES-TREE-APPEND-OFF TIMES-TREE-APPEND T) (PROVE-LEMMA TIMES-TREE-OF-TIMES-FRINGE (REWRITE) (EQUAL (EVAL$ T (TIMES-TREE (TIMES-FRINGE X)) A) (FIX (EVAL$ T X A))) ((ENABLE COMMUTATIVITY-OF-TIMES EVAL$-TIMES TIMES-FRINGE TIMES-TREE TIMES-TREE-APPEND TIMES-ZERO) (INDUCT (TIMES-FRINGE X)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE TIMES-TREE-OF-TIMES-FRINGE-OFF TIMES-TREE-OF-TIMES-FRINGE T) (DEFN CANCEL-LESSP-TIMES (X) (IF (AND (EQUAL (CAR X) 'LESSP) (EQUAL (CAADR X) 'TIMES) (EQUAL (CAADDR X) 'TIMES)) (IF (LISTP (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X)))) (LIST 'AND (AND-NOT-ZEROP-TREE (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X)))) (LIST 'LESSP (TIMES-TREE (BAGDIFF (TIMES-FRINGE (CADR X)) (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X))))) (TIMES-TREE (BAGDIFF (TIMES-FRINGE (CADDR X)) (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X))))))) X) X)) (PROVE-LEMMA EVAL$-LESSP-TIMES-TREE-BAGDIFF (REWRITE) (IMPLIES (AND (SUBBAGP X Y) (SUBBAGP X Z) (EVAL$ T (AND-NOT-ZEROP-TREE X) A)) (EQUAL (LESSP (EVAL$ T (TIMES-TREE (BAGDIFF Y X)) A) (EVAL$ T (TIMES-TREE (BAGDIFF Z X)) A)) (LESSP (EVAL$ T (TIMES-TREE Y) A) (EVAL$ T (TIMES-TREE Z) A)))) ((ENABLE AND-NOT-ZEROP-TREE BAGDIFF EVAL$-TIMES-MEMBER LESSP-TIMES-CANCELLATION1 SUBBAGP SUBBAGP-CDR1 SUBBAGP-CDR2 TIMES-TREE ZEROP-MAKES-TIMES-TREE-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-LESSP-TIMES-TREE-BAGDIFF-OFF EVAL$-LESSP-TIMES-TREE-BAGDIFF T) (PROVE-LEMMA ZEROP-MAKES-LESSP-FALSE-BRIDGE (REWRITE) (IMPLIES (AND (EQUAL (CAR X) 'TIMES) (EQUAL (CAR Y) 'TIMES) (NOT (EVAL$ T (AND-NOT-ZEROP-TREE (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) A))) (EQUAL (LESSP (TIMES (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)) (TIMES (EVAL$ T (CADR Y) A) (EVAL$ T (CADDR Y) A))) F)) ((ENABLE AND-NOT-ZEROP-TREE BAGINT COMMUTATIVITY-OF-TIMES DELETE EQUAL-TIMES-0 EVAL$-TIMES SUBBAGP-BAGINT1 SUBBAGP-BAGINT2 TIMES-FRINGE TIMES-TREE TIMES-TREE-APPEND TIMES-TREE-OF-TIMES-FRINGE TIMES-ZERO) (USE (ZEROP-MAKES-TIMES-TREE-ZERO (X (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) (Y (TIMES-FRINGE X))) (ZEROP-MAKES-TIMES-TREE-ZERO (X (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) (Y (TIMES-FRINGE Y)))) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE ZEROP-MAKES-LESSP-FALSE-BRIDGE-OFF ZEROP-MAKES-LESSP-FALSE-BRIDGE T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-LESSP-TIMES ((META LESSP)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-LESSP-TIMES X) A)) ((ENABLE CANCEL-LESSP-TIMES EVAL$-LESSP-TIMES-TREE-BAGDIFF EVAL$-LESSP EVAL$-TIMES SUBBAGP-BAGINT1 SUBBAGP-BAGINT2 TIMES-TREE-OF-TIMES-FRINGE ZEROP-MAKES-LESSP-FALSE-BRIDGE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN CANCEL-EQUAL-TIMES (X) (IF (AND (EQUAL (CAR X) 'EQUAL) (EQUAL (CAADR X) 'TIMES) (EQUAL (CAADDR X) 'TIMES)) (IF (LISTP (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X)))) (LIST 'OR (OR-ZEROP-TREE (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X)))) (LIST 'EQUAL (TIMES-TREE (BAGDIFF (TIMES-FRINGE (CADR X)) (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X))))) (TIMES-TREE (BAGDIFF (TIMES-FRINGE (CADDR X)) (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X))))))) X) X)) (PROVE-LEMMA ZEROP-MAKES-EQUAL-TRUE-BRIDGE (REWRITE) (IMPLIES (AND (EQUAL (CAR X) 'TIMES) (EQUAL (CAR Y) 'TIMES) (EVAL$ T (OR-ZEROP-TREE (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) A)) (EQUAL (EQUAL (TIMES (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)) (TIMES (EVAL$ T (CADR Y) A) (EVAL$ T (CADDR Y) A))) T)) ((ENABLE BAGINT COMMUTATIVITY-OF-TIMES DELETE EQUAL-TIMES-0 EVAL$-TIMES OR-ZEROP-TREE SUBBAGP-BAGINT1 SUBBAGP-BAGINT2 TIMES-FRINGE TIMES-TREE TIMES-TREE-APPEND TIMES-TREE-OF-TIMES-FRINGE TIMES-ZERO) (USE (ZEROP-MAKES-TIMES-TREE-ZERO2 (X (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) (Y (TIMES-FRINGE X))) (ZEROP-MAKES-TIMES-TREE-ZERO2 (X (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) (Y (TIMES-FRINGE Y)))) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE ZEROP-MAKES-EQUAL-TRUE-BRIDGE-OFF ZEROP-MAKES-EQUAL-TRUE-BRIDGE T) (PROVE-LEMMA EVAL$-EQUAL-TIMES-TREE-BAGDIFF (REWRITE) (IMPLIES (AND (SUBBAGP X Y) (SUBBAGP X Z) (NOT (EVAL$ T (OR-ZEROP-TREE X) A))) (EQUAL (EQUAL (EVAL$ T (TIMES-TREE (BAGDIFF Y X)) A) (EVAL$ T (TIMES-TREE (BAGDIFF Z X)) A)) (EQUAL (EVAL$ T (TIMES-TREE Y) A) (EVAL$ T (TIMES-TREE Z) A)))) ((ENABLE AND-NOT-ZEROP-TREE BAGDIFF EQUAL-TIMES-ARG1 EVAL$-TIMES-MEMBER NUMBERP-EVAL$-TIMES-TREE OR-ZEROP-TREE OR-ZEROP-TREE-IS-NOT-ZEROP-TREE SUBBAGP SUBBAGP-CDR1 SUBBAGP-CDR2 TIMES-TREE ZEROP-MAKES-TIMES-TREE-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-EQUAL-TIMES-TREE-BAGDIFF-OFF EVAL$-EQUAL-TIMES-TREE-BAGDIFF T) (PROVE-LEMMA CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY (REWRITE) (IMPLIES (AND (SUBBAGP Z X) (SUBBAGP Z Y) (NOT (EQUAL (EVAL$ T (TIMES-TREE X) A) (EVAL$ T (TIMES-TREE Y) A)))) (NOT (EQUAL (EVAL$ T (TIMES-TREE (BAGDIFF X Z)) A) (EVAL$ T (TIMES-TREE (BAGDIFF Y Z)) A)))) ((ENABLE BAGDIFF EVAL$-TIMES-MEMBER SUBBAGP SUBBAGP-CDR2 TIMES-TREE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY-OFF CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY T) (PROVE-LEMMA CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY-BRIDGE (REWRITE) (IMPLIES (AND (EQUAL (CAR X) 'TIMES) (EQUAL (CAR Y) 'TIMES) (NOT (EQUAL (TIMES (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)) (TIMES (EVAL$ T (CADR Y) A) (EVAL$ T (CADDR Y) A))))) (NOT (EQUAL (EVAL$ T (TIMES-TREE (BAGDIFF (TIMES-FRINGE X) (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y)))) A) (EVAL$ T (TIMES-TREE (BAGDIFF (TIMES-FRINGE Y) (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y)))) A)))) ((ENABLE BAGDIFF BAGINT COMMUTATIVITY-OF-TIMES SUBBAGP-BAGINT1 SUBBAGP-BAGINT2 TIMES-FRINGE TIMES-TREE TIMES-TREE-APPEND TIMES-TREE-OF-TIMES-FRINGE TIMES-ZERO) (USE (CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY (Z (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) (X (TIMES-FRINGE X)) (Y (TIMES-FRINGE Y)))) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY-BRIDGE-OFF CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY-BRIDGE T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-EQUAL-TIMES ((META EQUAL)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-EQUAL-TIMES X) A)) ((ENABLE CANCEL-EQUAL-TIMES CANCEL-EQUAL-TIMES-PRESERVES-INEQUALITY-BRIDGE EVAL$-EQUAL EVAL$-EQUAL-TIMES-TREE-BAGDIFF EVAL$-TIMES SUBBAGP-BAGINT1 SUBBAGP-BAGINT2 TIMES-TREE-OF-TIMES-FRINGE ZEROP-MAKES-EQUAL-TRUE-BRIDGE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFTHEORY MULTIPLICATION (EQUAL-TIMES-0 EQUAL-TIMES-1 EQUAL-SUB1-0 TIMES-ZERO TIMES-ADD1 COMMUTATIVITY-OF-TIMES TIMES-DISTRIBUTES-OVER-PLUS COMMUTATIVITY2-OF-TIMES ASSOCIATIVITY-OF-TIMES TIMES-DISTRIBUTES-OVER-DIFFERENCE TIMES-QUOTIENT TIMES-1-ARG1 LESSP-TIMES1 LESSP-TIMES2 LESSP-TIMES3 LESSP-PLUS-TIMES1 LESSP-PLUS-TIMES2 LESSP-1-TIMES CORRECTNESS-OF-CANCEL-LESSP-TIMES CORRECTNESS-OF-CANCEL-EQUAL-TIMES)) (PROVE-LEMMA LESSP-REMAINDER (REWRITE GENERALIZE) (EQUAL (LESSP (REMAINDER X Y) Y) (NOT (ZEROP Y))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-NOOP (REWRITE) (IMPLIES (LESSP A B) (EQUAL (REMAINDER A B) (FIX A))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-OF-NON-NUMBER (REWRITE) (IMPLIES (NOT (NUMBERP A)) (EQUAL (REMAINDER A N) (REMAINDER 0 N))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-ZERO (REWRITE) (IMPLIES (ZEROP X) (EQUAL (REMAINDER Y X) (FIX Y))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA PLUS-REMAINDER-TIMES-QUOTIENT (REWRITE) (EQUAL (PLUS (REMAINDER X Y) (TIMES Y (QUOTIENT X Y))) (FIX X)) ((ENABLE COMMUTATIVITY2-OF-PLUS COMMUTATIVITY-OF-PLUS TIMES-ZERO TIMES-ADD1 COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE PLUS-REMAINDER-TIMES-QUOTIENT-OFF PLUS-REMAINDER-TIMES-QUOTIENT T) (PROVE-LEMMA REMAINDER-QUOTIENT-ELIM (ELIM) (IMPLIES (AND (NOT (ZEROP Y)) (NUMBERP X)) (EQUAL (PLUS (REMAINDER X Y) (TIMES Y (QUOTIENT X Y))) X)) ((ENABLE PLUS-REMAINDER-TIMES-QUOTIENT) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-ADD1 (REWRITE) (IMPLIES (EQUAL (REMAINDER A B) 0) (EQUAL (REMAINDER (ADD1 A) B) (REMAINDER 1 B))) ((ENABLE REMAINDER-NOOP) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (REMAINDER A B)) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-PLUS-PROOF NIL (IMPLIES (EQUAL (REMAINDER B C) 0) (EQUAL (REMAINDER (PLUS A B) C) (REMAINDER A C))) ((ENABLE REMAINDER-NOOP) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (REMAINDER B C)) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-PLUS (REWRITE) (IMPLIES (EQUAL (REMAINDER A C) 0) (AND (EQUAL (REMAINDER (PLUS A B) C) (REMAINDER B C)) (EQUAL (REMAINDER (PLUS B A) C) (REMAINDER B C)) (EQUAL (REMAINDER (PLUS X Y A) C) (REMAINDER (PLUS X Y) C)))) ((USE (REMAINDER-PLUS-PROOF (A B) (B A) (C C)) (REMAINDER-PLUS-PROOF (A A) (B B) (C C)) (REMAINDER-PLUS-PROOF (B A) (A (PLUS X Y)) (C C))) (ENABLE COMMUTATIVITY-OF-PLUS COMMUTATIVITY2-OF-PLUS ASSOCIATIVITY-OF-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-REMAINDER-PLUS-0-PROOF NIL (IMPLIES (EQUAL (REMAINDER A C) 0) (EQUAL (EQUAL (REMAINDER (PLUS A B) C) 0) (EQUAL (REMAINDER B C) 0))) ((ENABLE REMAINDER-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-REMAINDER-PLUS-0 (REWRITE) (IMPLIES (EQUAL (REMAINDER A C) 0) (AND (EQUAL (EQUAL (REMAINDER (PLUS A B) C) 0) (EQUAL (REMAINDER B C) 0)) (EQUAL (EQUAL (REMAINDER (PLUS B A) C) 0) (EQUAL (REMAINDER B C) 0)) (EQUAL (EQUAL (REMAINDER (PLUS X Y A) C) 0) (EQUAL (REMAINDER (PLUS X Y) C) 0)))) ((USE (EQUAL-REMAINDER-PLUS-0-PROOF (A A) (B B) (C C)) (EQUAL-REMAINDER-PLUS-0-PROOF (A B) (B A) (C C)) (EQUAL-REMAINDER-PLUS-0-PROOF (A A) (B (PLUS X Y)) (C C))) (ENABLE ASSOCIATIVITY-OF-PLUS COMMUTATIVITY-OF-PLUS COMMUTATIVITY2-OF-PLUS) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-REMAINDER-PLUS-REMAINDER-PROOF NIL (IMPLIES (LESSP A C) (EQUAL (EQUAL (REMAINDER (PLUS A B) C) (REMAINDER B C)) (ZEROP A))) ((ENABLE REMAINDER-NOOP) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (REMAINDER B C)) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-REMAINDER-PLUS-REMAINDER (REWRITE) (IMPLIES (LESSP A C) (AND (EQUAL (EQUAL (REMAINDER (PLUS A B) C) (REMAINDER B C)) (ZEROP A)) (EQUAL (EQUAL (REMAINDER (PLUS B A) C) (REMAINDER B C)) (ZEROP A)))) ((USE (EQUAL-REMAINDER-PLUS-REMAINDER-PROOF (A A) (B B) (C C))) (ENABLE COMMUTATIVITY-OF-PLUS) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EQUAL-REMAINDER-PLUS-REMAINDER-OFF EQUAL-REMAINDER-PLUS-REMAINDER T) (PROVE-LEMMA REMAINDER-TIMES1-PROOF NIL (IMPLIES (EQUAL (REMAINDER B C) 0) (EQUAL (REMAINDER (TIMES A B) C) 0)) ((ENABLE-THEORY MULTIPLICATION ADDITION GROUND-ZERO) (ENABLE REMAINDER-PLUS REMAINDER-NOOP REMAINDER-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-TIMES1 (REWRITE) (IMPLIES (EQUAL (REMAINDER B C) 0) (AND (EQUAL (REMAINDER (TIMES A B) C) 0) (EQUAL (REMAINDER (TIMES B A) C) 0))) ((USE (REMAINDER-TIMES1-PROOF (A A) (B B) (C C)) (REMAINDER-TIMES1-PROOF (A B) (B A) (C C))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-TIMES1-INSTANCE-PROOF NIL (EQUAL (REMAINDER (TIMES X Y) Y) 0) ((ENABLE COMMUTATIVITY-OF-TIMES DIFFERENCE-PLUS-CANCELLATION REMAINDER-ZERO) (INDUCT (TIMES X Y)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-TIMES1-INSTANCE (REWRITE) (AND (EQUAL (REMAINDER (TIMES X Y) Y) 0) (EQUAL (REMAINDER (TIMES X Y) X) 0)) ((USE (REMAINDER-TIMES1-INSTANCE-PROOF (X X) (Y Y)) (REMAINDER-TIMES1-INSTANCE-PROOF (X Y) (Y X))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-TIMES-TIMES-PROOF NIL (EQUAL (REMAINDER (TIMES X Y) (TIMES X Z)) (TIMES X (REMAINDER Y Z))) ((ENABLE-THEORY ADDITION MULTIPLICATION GROUND-ZERO) (ENABLE REMAINDER-ZERO) (INDUCT (REMAINDER Y Z)) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-TIMES-TIMES (REWRITE) (AND (EQUAL (REMAINDER (TIMES X Y) (TIMES X Z)) (TIMES X (REMAINDER Y Z))) (EQUAL (REMAINDER (TIMES X Z) (TIMES Y Z)) (TIMES (REMAINDER X Y) Z))) ((USE (REMAINDER-TIMES-TIMES-PROOF (X X) (Y Y) (Z Z)) (REMAINDER-TIMES-TIMES-PROOF (X Z) (Y X) (Z Y))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE REMAINDER-TIMES-TIMES-OFF REMAINDER-TIMES-TIMES T) (PROVE-LEMMA REMAINDER-TIMES2-PROOF NIL (IMPLIES (EQUAL (REMAINDER A Z) 0) (EQUAL (REMAINDER A (TIMES Z Y)) (TIMES Z (REMAINDER (QUOTIENT A Z) Y)))) ((ENABLE-THEORY ADDITION MULTIPLICATION GROUND-ZERO) (ENABLE LESSP-REMAINDER REMAINDER-NOOP REMAINDER-PLUS REMAINDER-QUOTIENT-ELIM REMAINDER-TIMES-TIMES REMAINDER-TIMES1-INSTANCE REMAINDER-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-TIMES2 (REWRITE) (IMPLIES (EQUAL (REMAINDER A Z) 0) (AND (EQUAL (REMAINDER A (TIMES Y Z)) (TIMES Z (REMAINDER (QUOTIENT A Z) Y))) (EQUAL (REMAINDER A (TIMES Z Y)) (TIMES Z (REMAINDER (QUOTIENT A Z) Y))))) ((USE (REMAINDER-TIMES2-PROOF (A A) (Y Y) (Z Z))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-TIMES2-INSTANCE (REWRITE) (AND (EQUAL (REMAINDER (TIMES X Y) (TIMES X Z)) (TIMES X (REMAINDER Y Z))) (EQUAL (REMAINDER (TIMES X Z) (TIMES Y Z)) (TIMES (REMAINDER X Y) Z))) ((ENABLE REMAINDER-TIMES-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-DIFFERENCE1 (REWRITE) (IMPLIES (EQUAL (REMAINDER A C) (REMAINDER B C)) (EQUAL (REMAINDER (DIFFERENCE A B) C) (DIFFERENCE (REMAINDER A C) (REMAINDER B C)))) ((ENABLE LESSP-REMAINDER EQUAL-REMAINDER-PLUS-REMAINDER REMAINDER-PLUS REMAINDER-QUOTIENT-ELIM REMAINDER-TIMES1-INSTANCE) (ENABLE-THEORY ADDITION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (DEFN DOUBLE-REMAINDER-INDUCTION (A B C) (COND ((ZEROP C) 0) ((LESSP A C) 0) ((LESSP B C) 0) (T (DOUBLE-REMAINDER-INDUCTION (DIFFERENCE A C) (DIFFERENCE B C) C)))) (PROVE-LEMMA REMAINDER-DIFFERENCE2 (REWRITE) (IMPLIES (AND (EQUAL (REMAINDER A C) 0) (NOT (EQUAL (REMAINDER B C) 0))) (EQUAL (REMAINDER (DIFFERENCE A B) C) (IF (LESSP B A) (DIFFERENCE C (REMAINDER B C)) 0))) ((ENABLE EQUAL-REMAINDER-PLUS-0 LESSP-REMAINDER REMAINDER-NOOP REMAINDER-OF-NON-NUMBER REMAINDER-QUOTIENT-ELIM REMAINDER-TIMES1-INSTANCE REMAINDER-ZERO) (DISABLE TIMES-DISTRIBUTES-OVER-PLUS) (ENABLE-THEORY ADDITION MULTIPLICATION GROUND-ZERO) (INDUCT (DOUBLE-REMAINDER-INDUCTION A B C)) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-DIFFERENCE3 (REWRITE) (IMPLIES (AND (EQUAL (REMAINDER B C) 0) (NOT (EQUAL (REMAINDER A C) 0))) (EQUAL (REMAINDER (DIFFERENCE A B) C) (IF (LESSP B A) (REMAINDER A C) 0))) ((ENABLE REMAINDER-NOOP REMAINDER-OF-NON-NUMBER REMAINDER-ZERO) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (DOUBLE-REMAINDER-INDUCTION A B C)) (DISABLE-THEORY T))) (TOGGLE REMAINDER-DIFFERENCE3-OFF REMAINDER-DIFFERENCE3 T) (PROVE-LEMMA EQUAL-REMAINDER-DIFFERENCE-0 (REWRITE) (EQUAL (EQUAL (REMAINDER (DIFFERENCE A B) C) 0) (IF (IF (LESSP A B) F T) (EQUAL (REMAINDER A C) (REMAINDER B C)) T)) ((ENABLE LESSP-REMAINDER REMAINDER-DIFFERENCE1 REMAINDER-OF-NON-NUMBER REMAINDER-PLUS REMAINDER-QUOTIENT-ELIM REMAINDER-TIMES1-INSTANCE REMAINDER-ZERO) (ENABLE-THEORY ADDITION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (TOGGLE EQUAL-REMAINDER-DIFFERENCE-0-OFF EQUAL-REMAINDER-DIFFERENCE-0 T) (PROVE-LEMMA LESSP-PLUS-FACT (REWRITE) (IMPLIES (AND (EQUAL (REMAINDER B X) 0) (EQUAL (REMAINDER C X) 0) (LESSP B C) (LESSP A X)) (EQUAL (LESSP (PLUS A B) C) T)) ((ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (DOUBLE-REMAINDER-INDUCTION B C X)) (DISABLE-THEORY T))) (TOGGLE LESSP-PLUS-FACT-OFF LESSP-PLUS-FACT T) (PROVE-LEMMA REMAINDER-PLUS-FACT NIL (IMPLIES (AND (EQUAL (REMAINDER B X) 0) (EQUAL (REMAINDER C X) 0) (LESSP A X)) (EQUAL (REMAINDER (PLUS A B) C) (PLUS A (REMAINDER B C)))) ((ENABLE LESSP-PLUS-FACT REMAINDER-NOOP REMAINDER-DIFFERENCE1) (ENABLE-THEORY ADDITION MULTIPLICATION GROUND-ZERO) (INDUCT (REMAINDER B C)) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-PLUS-TIMES-TIMES-PROOF NIL (IMPLIES (LESSP A B) (EQUAL (REMAINDER (PLUS A (TIMES B C)) (TIMES B D)) (PLUS A (REMAINDER (TIMES B C) (TIMES B D))))) ((USE (REMAINDER-PLUS-FACT (A A) (X B) (B (TIMES B C)) (C (TIMES B D)))) (ENABLE REMAINDER-TIMES1-INSTANCE REMAINDER-TIMES2-INSTANCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-PLUS-TIMES-TIMES (REWRITE) (IMPLIES (LESSP A B) (AND (EQUAL (REMAINDER (PLUS A (TIMES B C)) (TIMES B D)) (PLUS A (REMAINDER (TIMES B C) (TIMES B D)))) (EQUAL (REMAINDER (PLUS A (TIMES C B)) (TIMES D B)) (PLUS A (REMAINDER (TIMES C B) (TIMES D B)))))) ((USE (REMAINDER-PLUS-TIMES-TIMES-PROOF (A A) (B B) (C C) (D D))) (ENABLE COMMUTATIVITY-OF-TIMES) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-PLUS-TIMES-TIMES-INSTANCE (REWRITE) (IMPLIES (LESSP A B) (AND (EQUAL (REMAINDER (PLUS A (TIMES B C) (TIMES B D)) (TIMES B E)) (PLUS A (TIMES B (REMAINDER (PLUS C D) E)))) (EQUAL (REMAINDER (PLUS A (TIMES C B) (TIMES D B)) (TIMES E B)) (PLUS A (TIMES B (REMAINDER (PLUS C D) E)))))) ((ENABLE COMMUTATIVITY-OF-TIMES REMAINDER-TIMES-TIMES REMAINDER-PLUS-TIMES-TIMES) (USE (TIMES-DISTRIBUTES-OVER-PLUS (X B) (Y C) (Z D))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-REMAINDER (REWRITE) (IMPLIES (EQUAL (REMAINDER B A) 0) (EQUAL (REMAINDER (REMAINDER N B) A) (REMAINDER N A))) ((INDUCT (REMAINDER N B)) (ENABLE REMAINDER-PLUS REMAINDER-QUOTIENT-ELIM REMAINDER-ZERO) (ENABLE-THEORY ADDITION MULTIPLICATION GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-1-ARG1 (REWRITE) (EQUAL (REMAINDER 1 X) (IF (EQUAL X 1) 0 1)) ((ENABLE DIFFERENCE-LEQ-ARG1) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-1-ARG2 (REWRITE) (EQUAL (REMAINDER Y 1) 0) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-X-X (REWRITE) (EQUAL (REMAINDER X X) 0) ((ENABLE EQUAL-DIFFERENCE-0) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA TRANSITIVITY-OF-DIVIDES NIL (IMPLIES (AND (EQUAL (REMAINDER A B) 0) (EQUAL (REMAINDER B C) 0)) (EQUAL (REMAINDER A C) 0)) ((ENABLE REMAINDER REMAINDER-NOOP REMAINDER-PLUS) (ENABLE-THEORY ADDITION GROUND-ZERO) (DISABLE-THEORY T))) (DEFTHEORY REMAINDERS (LESSP-REMAINDER REMAINDER-NOOP REMAINDER-OF-NON-NUMBER REMAINDER-ZERO REMAINDER-QUOTIENT-ELIM REMAINDER-ADD1 REMAINDER-PLUS EQUAL-REMAINDER-PLUS-0 REMAINDER-TIMES1 REMAINDER-TIMES1-INSTANCE REMAINDER-TIMES2 REMAINDER-TIMES2-INSTANCE REMAINDER-DIFFERENCE1 REMAINDER-DIFFERENCE2 REMAINDER-PLUS-TIMES-TIMES REMAINDER-PLUS-TIMES-TIMES-INSTANCE REMAINDER-REMAINDER REMAINDER-1-ARG1 REMAINDER-1-ARG2 REMAINDER-X-X)) (PROVE-LEMMA QUOTIENT-NOOP (REWRITE) (IMPLIES (EQUAL B 1) (EQUAL (QUOTIENT A B) (FIX A))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-OF-NON-NUMBER (REWRITE) (IMPLIES (NOT (NUMBERP A)) (EQUAL (QUOTIENT A N) (QUOTIENT 0 N))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-ZERO (REWRITE) (IMPLIES (ZEROP X) (EQUAL (QUOTIENT Y X) 0)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-ADD1 (REWRITE) (IMPLIES (EQUAL (REMAINDER A B) 0) (EQUAL (QUOTIENT (ADD1 A) B) (IF (EQUAL B 1) (ADD1 (QUOTIENT A B)) (QUOTIENT A B)))) ((ENABLE QUOTIENT-NOOP) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (REMAINDER A B)) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-QUOTIENT-0 (REWRITE) (EQUAL (EQUAL (QUOTIENT A B) 0) (OR (ZEROP B) (LESSP A B))) ((INDUCT (QUOTIENT A B)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-SUB1 (REWRITE) (IMPLIES (AND (NOT (ZEROP A)) (NOT (ZEROP B))) (EQUAL (QUOTIENT (SUB1 A) B) (IF (EQUAL (REMAINDER A B) 0) (SUB1 (QUOTIENT A B)) (QUOTIENT A B)))) ((ENABLE QUOTIENT-NOOP EQUAL-QUOTIENT-0) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (REMAINDER A B)) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-PLUS-PROOF NIL (IMPLIES (EQUAL (REMAINDER B C) 0) (EQUAL (QUOTIENT (PLUS A B) C) (PLUS (QUOTIENT A C) (QUOTIENT B C)))) ((ENABLE REMAINDER-NOOP) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (REMAINDER B C)) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-PLUS (REWRITE) (IMPLIES (EQUAL (REMAINDER A C) 0) (AND (EQUAL (QUOTIENT (PLUS A B) C) (PLUS (QUOTIENT A C) (QUOTIENT B C))) (EQUAL (QUOTIENT (PLUS B A) C) (PLUS (QUOTIENT A C) (QUOTIENT B C))) (EQUAL (QUOTIENT (PLUS X Y A) C) (PLUS (QUOTIENT (PLUS X Y) C) (QUOTIENT A C))))) ((USE (QUOTIENT-PLUS-PROOF (A B) (B A) (C C)) (QUOTIENT-PLUS-PROOF (A A) (B B) (C C)) (QUOTIENT-PLUS-PROOF (A (PLUS X Y)) (B A) (C C))) (ENABLE COMMUTATIVITY-OF-PLUS COMMUTATIVITY2-OF-PLUS ASSOCIATIVITY-OF-PLUS) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-TIMES-INSTANCE-TEMP-PROOF NIL (EQUAL (QUOTIENT (TIMES Y X) Y) (IF (ZEROP Y) 0 (FIX X))) ((ENABLE TIMES-ZERO COMMUTATIVITY-OF-TIMES DIFFERENCE-PLUS-CANCELLATION) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-TIMES-INSTANCE-TEMP (REWRITE) (AND (EQUAL (QUOTIENT (TIMES Y X) Y) (IF (ZEROP Y) 0 (FIX X))) (EQUAL (QUOTIENT (TIMES X Y) Y) (IF (ZEROP Y) 0 (FIX X)))) ((USE (QUOTIENT-TIMES-INSTANCE-TEMP-PROOF (X X) (Y Y)) (QUOTIENT-TIMES-INSTANCE-TEMP-PROOF (X Y) (Y X))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE QUOTIENT-TIMES-INSTANCE-TEMP-OFF QUOTIENT-TIMES-INSTANCE-TEMP T) (PROVE-LEMMA QUOTIENT-TIMES-PROOF NIL (IMPLIES (EQUAL (REMAINDER A C) 0) (EQUAL (QUOTIENT (TIMES A B) C) (TIMES B (QUOTIENT A C)))) ((ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (ENABLE QUOTIENT-PLUS QUOTIENT-NOOP EQUAL-QUOTIENT-0 QUOTIENT-TIMES-INSTANCE-TEMP) (INDUCT (REMAINDER A C)) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-TIMES (REWRITE) (IMPLIES (EQUAL (REMAINDER A C) 0) (AND (EQUAL (QUOTIENT (TIMES A B) C) (TIMES B (QUOTIENT A C))) (EQUAL (QUOTIENT (TIMES B A) C) (TIMES B (QUOTIENT A C))))) ((ENABLE COMMUTATIVITY-OF-TIMES) (USE (QUOTIENT-TIMES-PROOF (A A) (B B) (C C))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-TIMES-INSTANCE (REWRITE) (AND (EQUAL (QUOTIENT (TIMES Y X) Y) (IF (ZEROP Y) 0 (FIX X))) (EQUAL (QUOTIENT (TIMES X Y) Y) (IF (ZEROP Y) 0 (FIX X)))) ((ENABLE QUOTIENT-TIMES-INSTANCE-TEMP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-TIMES-TIMES-PROOF NIL (EQUAL (QUOTIENT (TIMES X Y) (TIMES X Z)) (IF (ZEROP X) 0 (QUOTIENT Y Z))) ((ENABLE-THEORY ADDITION GROUND-ZERO) (ENABLE LESSP-TIMES-CANCELLATION1 EQUAL-TIMES-0 TIMES-ZERO COMMUTATIVITY-OF-TIMES TIMES-DISTRIBUTES-OVER-DIFFERENCE) (INDUCT (QUOTIENT Y Z)) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-TIMES-TIMES (REWRITE) (AND (EQUAL (QUOTIENT (TIMES X Y) (TIMES X Z)) (IF (ZEROP X) 0 (QUOTIENT Y Z))) (EQUAL (QUOTIENT (TIMES X Z) (TIMES Y Z)) (IF (ZEROP Z) 0 (QUOTIENT X Y)))) ((USE (QUOTIENT-TIMES-TIMES-PROOF (X X) (Y Y) (Z Z)) (QUOTIENT-TIMES-TIMES-PROOF (X Z) (Y X) (Z Y))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE QUOTIENT-TIMES-TIMES-OFF QUOTIENT-TIMES-TIMES T) (PROVE-LEMMA QUOTIENT-DIFFERENCE1 (REWRITE) (IMPLIES (EQUAL (REMAINDER A C) (REMAINDER B C)) (EQUAL (QUOTIENT (DIFFERENCE A B) C) (DIFFERENCE (QUOTIENT A C) (QUOTIENT B C)))) ((ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (ENABLE QUOTIENT-PLUS QUOTIENT-TIMES-INSTANCE EQUAL-REMAINDER-PLUS-REMAINDER) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-LESSP-ARG1 (REWRITE) (IMPLIES (LESSP A B) (EQUAL (QUOTIENT A B) 0)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-DIFFERENCE2 (REWRITE) (IMPLIES (AND (EQUAL (REMAINDER A C) 0) (NOT (EQUAL (REMAINDER B C) 0))) (EQUAL (QUOTIENT (DIFFERENCE A B) C) (IF (LESSP B A) (DIFFERENCE (QUOTIENT A C) (ADD1 (QUOTIENT B C))) 0))) ((ENABLE EQUAL-QUOTIENT-0 EQUAL-REMAINDER-PLUS-0 QUOTIENT-TIMES-INSTANCE QUOTIENT-ZERO) (DISABLE TIMES-DISTRIBUTES-OVER-PLUS EQUAL-REMAINDER-DIFFERENCE-0 REMAINDER-DIFFERENCE3) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (INDUCT (DOUBLE-REMAINDER-INDUCTION A B C)) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-DIFFERENCE3 (REWRITE) (IMPLIES (AND (EQUAL (REMAINDER B C) 0) (NOT (EQUAL (REMAINDER A C) 0))) (EQUAL (QUOTIENT (DIFFERENCE A B) C) (IF (LESSP B A) (DIFFERENCE (QUOTIENT A C) (QUOTIENT B C)) 0))) ((ENABLE EQUAL-QUOTIENT-0 EQUAL-REMAINDER-PLUS-0 QUOTIENT-LESSP-ARG1 QUOTIENT-TIMES-INSTANCE QUOTIENT-ZERO) (DISABLE TIMES-DISTRIBUTES-OVER-PLUS EQUAL-REMAINDER-DIFFERENCE-0 REMAINDER-DIFFERENCE3) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (INDUCT (DOUBLE-REMAINDER-INDUCTION A B C)) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-EQUALS-ITS-FIRST-ARGUMENT (REWRITE) (EQUAL (EQUAL A (REMAINDER A B)) (AND (NUMBERP A) (OR (ZEROP B) (LESSP A B)))) ((INDUCT (REMAINDER A B)) (ENABLE LESSP-REMAINDER REMAINDER-NOOP REMAINDER-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE REMAINDER-EQUALS-ITS-FIRST-ARGUMENT-OFF REMAINDER-EQUALS-ITS-FIRST-ARGUMENT T) (PROVE-LEMMA QUOTIENT-REMAINDER-TIMES (REWRITE) (EQUAL (QUOTIENT (REMAINDER X (TIMES A B)) A) (REMAINDER (QUOTIENT X A) B)) ((ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (ENABLE REMAINDER-EQUALS-ITS-FIRST-ARGUMENT QUOTIENT-NOOP QUOTIENT-PLUS QUOTIENT-TIMES-INSTANCE QUOTIENT-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-REMAINDER (REWRITE) (IMPLIES (EQUAL (REMAINDER C A) 0) (EQUAL (QUOTIENT (REMAINDER B C) A) (REMAINDER (QUOTIENT B A) (QUOTIENT C A)))) ((ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (ENABLE QUOTIENT-NOOP QUOTIENT-PLUS QUOTIENT-REMAINDER-TIMES QUOTIENT-TIMES-INSTANCE QUOTIENT-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-REMAINDER-INSTANCE (REWRITE) (EQUAL (QUOTIENT (REMAINDER X (TIMES A B)) A) (REMAINDER (QUOTIENT X A) B)) ((ENABLE QUOTIENT-REMAINDER QUOTIENT-TIMES-INSTANCE REMAINDER-TIMES1-INSTANCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-PLUS-FACT NIL (IMPLIES (AND (EQUAL (REMAINDER B X) 0) (EQUAL (REMAINDER C X) 0) (LESSP A X)) (EQUAL (QUOTIENT (PLUS A B) C) (QUOTIENT B C))) ((ENABLE QUOTIENT-LESSP-ARG1 LESSP-PLUS-FACT) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (INDUCT (QUOTIENT B C)) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-PLUS-TIMES-TIMES-PROOF NIL (IMPLIES (LESSP A B) (EQUAL (QUOTIENT (PLUS A (TIMES B C)) (TIMES B D)) (QUOTIENT (TIMES B C) (TIMES B D)))) ((USE (QUOTIENT-PLUS-FACT (A A) (X B) (B (TIMES B C)) (C (TIMES B D)))) (ENABLE REMAINDER-TIMES1-INSTANCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-PLUS-TIMES-TIMES (REWRITE) (IMPLIES (LESSP A B) (AND (EQUAL (QUOTIENT (PLUS A (TIMES B C)) (TIMES B D)) (QUOTIENT (TIMES B C) (TIMES B D))) (EQUAL (QUOTIENT (PLUS A (TIMES B C)) (TIMES B D)) (QUOTIENT (TIMES B C) (TIMES B D))))) ((USE (QUOTIENT-PLUS-TIMES-TIMES-PROOF (A A) (B B) (C C) (D D))) (ENABLE COMMUTATIVITY-OF-TIMES) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-PLUS-TIMES-TIMES-INSTANCE (REWRITE) (IMPLIES (LESSP A B) (AND (EQUAL (QUOTIENT (PLUS A (TIMES B C) (TIMES B D)) (TIMES B E)) (IF (ZEROP B) 0 (QUOTIENT (PLUS C D) E))) (EQUAL (QUOTIENT (PLUS A (TIMES C B) (TIMES D B)) (TIMES E B)) (IF (ZEROP B) 0 (QUOTIENT (PLUS D C) E))))) ((ENABLE COMMUTATIVITY-OF-TIMES COMMUTATIVITY-OF-PLUS QUOTIENT-TIMES-TIMES QUOTIENT-PLUS-TIMES-TIMES) (USE (TIMES-DISTRIBUTES-OVER-PLUS (X B) (Y C) (Z D))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-QUOTIENT (REWRITE) (EQUAL (QUOTIENT (QUOTIENT B A) C) (QUOTIENT B (TIMES A C))) ((ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (DISABLE TIMES-DISTRIBUTES-OVER-PLUS) (ENABLE QUOTIENT-LESSP-ARG1 QUOTIENT-PLUS QUOTIENT-PLUS-TIMES-TIMES QUOTIENT-TIMES-INSTANCE QUOTIENT-TIMES-TIMES QUOTIENT-NOOP QUOTIENT-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA LEQ-QUOTIENT NIL (IMPLIES (LESSP A B) (IF (LESSP (QUOTIENT B C) (QUOTIENT A C)) F T)) ((INDUCT (DOUBLE-REMAINDER-INDUCTION A B C)) (ENABLE QUOTIENT-LESSP-ARG1 QUOTIENT-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-1-ARG2 (REWRITE) (EQUAL (QUOTIENT N 1) (FIX N)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-1-ARG1-CASESPLIT NIL (OR (ZEROP N) (EQUAL N 1) (LESSP 1 N)) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-1-ARG1 (REWRITE) (EQUAL (QUOTIENT 1 N) (IF (EQUAL N 1) 1 0)) ((ENABLE QUOTIENT-LESSP-ARG1) (USE (QUOTIENT-1-ARG1-CASESPLIT)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-X-X (REWRITE) (IMPLIES (NOT (ZEROP X)) (EQUAL (QUOTIENT X X) 1)) ((ENABLE DIFFERENCE-X-X) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-QUOTIENT (REWRITE) (EQUAL (LESSP (QUOTIENT I J) I) (AND (NOT (ZEROP I)) (NOT (EQUAL J 1)))) ((ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN CANCEL-QUOTIENT-TIMES (X) (IF (AND (EQUAL (CAR X) 'QUOTIENT) (EQUAL (CAADR X) 'TIMES) (EQUAL (CAADDR X) 'TIMES)) (IF (LISTP (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X)))) (CONS 'IF (CONS (AND-NOT-ZEROP-TREE (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X)))) (CONS (LIST 'QUOTIENT (TIMES-TREE (BAGDIFF (TIMES-FRINGE (CADR X)) (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X))))) (TIMES-TREE (BAGDIFF (TIMES-FRINGE (CADDR X)) (BAGINT (TIMES-FRINGE (CADR X)) (TIMES-FRINGE (CADDR X)))))) '((ZERO))))) X) X)) (PROVE-LEMMA ZEROP-MAKES-QUOTIENT-ZERO-BRIDGE (REWRITE) (IMPLIES (AND (EQUAL (CAR X) 'TIMES) (EQUAL (CAR Y) 'TIMES) (NOT (EVAL$ T (AND-NOT-ZEROP-TREE (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) A))) (EQUAL (QUOTIENT (TIMES (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A)) (TIMES (EVAL$ T (CADR Y) A) (EVAL$ T (CADDR Y) A))) 0)) ((USE (ZEROP-MAKES-TIMES-TREE-ZERO (X (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) (Y (TIMES-FRINGE X))) (ZEROP-MAKES-TIMES-TREE-ZERO (X (BAGINT (TIMES-FRINGE X) (TIMES-FRINGE Y))) (Y (TIMES-FRINGE Y)))) (ENABLE AND-NOT-ZEROP-TREE BAGINT DELETE EQUAL-QUOTIENT-0 EQUAL-TIMES-0 EVAL$-TIMES SUBBAGP-BAGINT1 SUBBAGP-BAGINT2 TIMES-FRINGE TIMES-TREE TIMES-TREE-APPEND TIMES-TREE-OF-TIMES-FRINGE ZEROP-MAKES-LESSP-FALSE-BRIDGE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE ZEROP-MAKES-QUOTIENT-ZERO-BRIDGE-OFF ZEROP-MAKES-QUOTIENT-ZERO-BRIDGE T) (PROVE-LEMMA EVAL$-QUOTIENT-TIMES-TREE-BAGDIFF (REWRITE) (IMPLIES (AND (SUBBAGP X Y) (SUBBAGP X Z) (EVAL$ T (AND-NOT-ZEROP-TREE X) A)) (EQUAL (QUOTIENT (EVAL$ T (TIMES-TREE (BAGDIFF Y X)) A) (EVAL$ T (TIMES-TREE (BAGDIFF Z X)) A)) (QUOTIENT (EVAL$ T (TIMES-TREE Y) A) (EVAL$ T (TIMES-TREE Z) A)))) ((ENABLE AND-NOT-ZEROP-TREE BAGDIFF EQUAL-QUOTIENT-0 EVAL$-TIMES-MEMBER NUMBERP-EVAL$-TIMES-TREE QUOTIENT-TIMES-TIMES SUBBAGP SUBBAGP-CDR1 SUBBAGP-CDR2 TIMES-TREE ZEROP-MAKES-TIMES-TREE-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE EVAL$-QUOTIENT-TIMES-TREE-BAGDIFF-OFF EVAL$-QUOTIENT-TIMES-TREE-BAGDIFF T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-QUOTIENT-TIMES ((META QUOTIENT)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-QUOTIENT-TIMES X) A)) ((ENABLE CANCEL-QUOTIENT-TIMES EVAL$-QUOTIENT-TIMES-TREE-BAGDIFF EVAL$-QUOTIENT EVAL$-TIMES SUBBAGP-BAGINT1 SUBBAGP-BAGINT2 TIMES-TREE-OF-TIMES-FRINGE ZEROP-MAKES-QUOTIENT-ZERO-BRIDGE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFTHEORY QUOTIENTS (QUOTIENT-NOOP QUOTIENT-OF-NON-NUMBER QUOTIENT-ZERO QUOTIENT-ADD1 EQUAL-QUOTIENT-0 QUOTIENT-SUB1 QUOTIENT-PLUS QUOTIENT-TIMES QUOTIENT-TIMES-INSTANCE QUOTIENT-DIFFERENCE1 QUOTIENT-LESSP-ARG1 QUOTIENT-DIFFERENCE2 QUOTIENT-DIFFERENCE3 QUOTIENT-REMAINDER-TIMES QUOTIENT-REMAINDER QUOTIENT-REMAINDER-INSTANCE QUOTIENT-PLUS-TIMES-TIMES QUOTIENT-PLUS-TIMES-TIMES-INSTANCE QUOTIENT-QUOTIENT QUOTIENT-1-ARG2 QUOTIENT-1-ARG1 QUOTIENT-X-X LESSP-QUOTIENT CORRECTNESS-OF-CANCEL-QUOTIENT-TIMES)) (DEFN EXP (I J) (IF (ZEROP J) 1 (TIMES I (EXP I (SUB1 J))))) (DEFN LOG (BASE N) (COND ((LESSP BASE 2) 0) ((ZEROP N) 0) (T (ADD1 (LOG BASE (QUOTIENT N BASE)))))) (DEFN GCD (X Y) (COND ((ZEROP X) (FIX Y)) ((ZEROP Y) X) ((LESSP X Y) (GCD X (DIFFERENCE Y X))) (T (GCD (DIFFERENCE X Y) Y))) ((ORD-LESSP (CONS (ADD1 X) (FIX Y))))) (PROVE-LEMMA REMAINDER-EXP (REWRITE) (IMPLIES (NOT (ZEROP K)) (EQUAL (REMAINDER (EXP N K) N) 0)) ((ENABLE EXP REMAINDER-TIMES1-INSTANCE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN DOUBLE-NUMBER-INDUCTION (I J) (COND ((ZEROP I) 0) ((ZEROP J) 0) (T (DOUBLE-NUMBER-INDUCTION (SUB1 I) (SUB1 J))))) (PROVE-LEMMA REMAINDER-EXP-EXP (REWRITE) (IMPLIES (IF (LESSP J I) F T) (EQUAL (REMAINDER (EXP A J) (EXP A I)) 0)) ((ENABLE EXP REMAINDER-1-ARG2 REMAINDER-TIMES2-INSTANCE) (ENABLE-THEORY ADDITION MULTIPLICATION GROUND-ZERO) (INDUCT (DOUBLE-NUMBER-INDUCTION I J)) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-EXP (REWRITE) (IMPLIES (NOT (ZEROP K)) (EQUAL (QUOTIENT (EXP N K) N) (IF (ZEROP N) 0 (EXP N (SUB1 K))))) ((ENABLE EXP QUOTIENT-TIMES-INSTANCE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-ZERO (REWRITE) (IMPLIES (ZEROP K) (EQUAL (EXP N K) 1)) ((ENABLE EXP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-ADD1 (REWRITE) (EQUAL (EXP N (ADD1 K)) (TIMES N (EXP N K))) ((ENABLE EXP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-PLUS (REWRITE) (EQUAL (EXP I (PLUS J K)) (TIMES (EXP I J) (EXP I K))) ((ENABLE EXP ASSOCIATIVITY-OF-TIMES COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-0-ARG1 (REWRITE) (EQUAL (EXP 0 K) (IF (ZEROP K) 1 0)) ((ENABLE EXP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-1-ARG1 (REWRITE) (EQUAL (EXP 1 K) 1) ((ENABLE EXP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-0-ARG2 (REWRITE) (EQUAL (EXP N 0) 1) ((ENABLE EXP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-TIMES (REWRITE) (EQUAL (EXP (TIMES I J) K) (TIMES (EXP I K) (EXP J K))) ((ENABLE EXP ASSOCIATIVITY-OF-TIMES COMMUTATIVITY2-OF-TIMES EXP-ZERO) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-EXP (REWRITE) (EQUAL (EXP (EXP I J) K) (EXP I (TIMES J K))) ((ENABLE EXP EXP-ZERO EXP-1-ARG1 EXP-PLUS EXP-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-EXP-0 (REWRITE) (EQUAL (EQUAL (EXP N K) 0) (AND (ZEROP N) (NOT (ZEROP K)))) ((ENABLE EXP EQUAL-TIMES-0) (INDUCT (EXP N K)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-EXP-1 (REWRITE) (EQUAL (EQUAL (EXP N K) 1) (IF (ZEROP K) T (EQUAL N 1))) ((ENABLE EXP TIMES-ZERO TIMES-ADD1) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EXP-DIFFERENCE (REWRITE) (IMPLIES (AND (IF (LESSP B C) F T) (NOT (ZEROP A))) (EQUAL (EXP A (DIFFERENCE B C)) (QUOTIENT (EXP A B) (EXP A C)))) ((ENABLE EXP) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS QUOTIENTS GROUND-ZERO) (DISABLE-THEORY T))) (DEFTHEORY EXPONENTIATION (EQUAL-EXP-0 EQUAL-EXP-1 EXP-EXP EXP-ADD1 EXP-TIMES EXP-1-ARG1 EXP-ZERO EXP-0-ARG2 EXP-0-ARG1 EXP-DIFFERENCE EXP-PLUS QUOTIENT-EXP REMAINDER-EXP-EXP REMAINDER-EXP)) (PROVE-LEMMA EQUAL-LOG-0 (REWRITE) (EQUAL (EQUAL (LOG BASE N) 0) (OR (LESSP BASE 2) (ZEROP N))) ((ENABLE LOG) (INDUCT (LOG BASE N)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-0 (REWRITE) (IMPLIES (ZEROP N) (EQUAL (LOG BASE N) 0)) ((ENABLE LOG) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-1 (REWRITE) (IMPLIES (LESSP 1 BASE) (EQUAL (LOG BASE 1) 1)) ((ENABLE LOG) (INDUCT (LOG BASE N)) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN DOUBLE-LOG-INDUCTION (BASE A B) (COND ((LESSP BASE 2) 0) ((ZEROP A) 0) ((ZEROP B) 0) (T (DOUBLE-LOG-INDUCTION BASE (QUOTIENT A BASE) (QUOTIENT B BASE))))) (PROVE-LEMMA LEQ-LOG-LOG NIL (IMPLIES (IF (LESSP M N) F T) (IF (LESSP (LOG C M) (LOG C N)) F T)) ((ENABLE LOG) (INDUCT (DOUBLE-LOG-INDUCTION C N M)) (USE (LEQ-QUOTIENT (A N) (B M) (C C))) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-QUOTIENT (REWRITE) (IMPLIES (LESSP 1 C) (EQUAL (LOG C (QUOTIENT N C)) (SUB1 (LOG C N)))) ((ENABLE LOG) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-QUOTIENT-TIMES-PROOF NIL (IMPLIES (LESSP 1 C) (EQUAL (LOG C (QUOTIENT N (TIMES C M))) (SUB1 (LOG C (QUOTIENT N M))))) ((ENABLE LOG) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS QUOTIENTS GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-QUOTIENT-TIMES (REWRITE) (IMPLIES (LESSP 1 C) (AND (EQUAL (LOG C (QUOTIENT N (TIMES C M))) (SUB1 (LOG C (QUOTIENT N M)))) (EQUAL (LOG C (QUOTIENT N (TIMES M C))) (SUB1 (LOG C (QUOTIENT N M)))))) ((USE (LOG-QUOTIENT-TIMES-PROOF (C C) (N N) (M M))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-QUOTIENT-EXP (REWRITE) (IMPLIES (LESSP 1 C) (EQUAL (LOG C (QUOTIENT N (EXP C M))) (DIFFERENCE (LOG C N) M))) ((ENABLE EXP LOG LOG-QUOTIENT-TIMES) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS QUOTIENTS GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-TIMES-PROOF NIL (IMPLIES (AND (LESSP 1 C) (NOT (ZEROP N))) (EQUAL (LOG C (TIMES C N)) (ADD1 (LOG C N)))) ((ENABLE LOG) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS QUOTIENTS GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-TIMES (REWRITE) (IMPLIES (AND (LESSP 1 C) (NOT (ZEROP N))) (AND (EQUAL (LOG C (TIMES C N)) (ADD1 (LOG C N))) (EQUAL (LOG C (TIMES N C)) (ADD1 (LOG C N))))) ((USE (LOG-TIMES-PROOF (C C) (N N))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-TIMES-EXP-PROOF NIL (IMPLIES (AND (LESSP 1 C) (NOT (ZEROP N))) (EQUAL (LOG C (TIMES N (EXP C M))) (PLUS (LOG C N) M))) ((ENABLE LOG EXP) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS QUOTIENTS GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-TIMES-EXP (REWRITE) (IMPLIES (AND (LESSP 1 C) (NOT (ZEROP N))) (AND (EQUAL (LOG C (TIMES N (EXP C M))) (PLUS (LOG C N) M)) (EQUAL (LOG C (TIMES (EXP C M) N)) (PLUS (LOG C N) M)))) ((USE (LOG-TIMES-EXP-PROOF (C C) (N N) (M M))) (ENABLE COMMUTATIVITY-OF-TIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA LOG-EXP (REWRITE) (IMPLIES (LESSP 1 C) (EQUAL (LOG C (EXP C N)) (ADD1 N))) ((ENABLE LOG EXP LOG-1) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS QUOTIENTS GROUND-ZERO) (DISABLE-THEORY T))) (DEFTHEORY LOGS (LOG-EXP LOG-TIMES-EXP LOG-TIMES LOG-QUOTIENT-EXP LOG-QUOTIENT-TIMES LOG-QUOTIENT LOG-1 LOG-0 EQUAL-LOG-0 EXP-EXP)) (PROVE-LEMMA COMMUTATIVITY-OF-GCD (REWRITE) (EQUAL (GCD B A) (GCD A B)) ((ENABLE GCD) (ENABLE-THEORY ADDITION GROUND-ZERO) (DISABLE-THEORY T))) (DEFN SINGLE-NUMBER-INDUCTION (N) (IF (ZEROP N) 0 (SINGLE-NUMBER-INDUCTION (SUB1 N)))) (PROVE-LEMMA GCD-0 (REWRITE) (AND (EQUAL (GCD 0 X) (FIX X)) (EQUAL (GCD X 0) (FIX X))) ((ENABLE GCD) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-1 (REWRITE) (AND (EQUAL (GCD 1 X) 1) (EQUAL (GCD X 1) 1)) ((ENABLE GCD) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (SINGLE-NUMBER-INDUCTION X)) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-GCD-0 (REWRITE) (EQUAL (EQUAL (GCD A B) 0) (AND (ZEROP A) (ZEROP B))) ((ENABLE GCD) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (GCD A B)) (DISABLE-THEORY T))) (PROVE-LEMMA LESSP-GCD (REWRITE) (IMPLIES (NOT (ZEROP B)) (AND (EQUAL (LESSP B (GCD A B)) F) (EQUAL (LESSP B (GCD B A)) F))) ((ENABLE GCD COMMUTATIVITY-OF-GCD) (ENABLE-THEORY ADDITION GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-PLUS-INSTANCE-TEMP-PROOF NIL (EQUAL (GCD A (PLUS A B)) (GCD A B)) ((ENABLE GCD COMMUTATIVITY-OF-GCD) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (GCD A B)) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-PLUS-INSTANCE-TEMP (REWRITE) (AND (EQUAL (GCD A (PLUS A B)) (GCD A B)) (EQUAL (GCD A (PLUS B A)) (GCD A B))) ((ENABLE COMMUTATIVITY-OF-PLUS) (USE (GCD-PLUS-INSTANCE-TEMP-PROOF (A A) (B B))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-PLUS-PROOF NIL (IMPLIES (EQUAL (REMAINDER B A) 0) (EQUAL (GCD A (PLUS B C)) (GCD A C))) ((ENABLE GCD COMMUTATIVITY-OF-GCD GCD-1 GCD-PLUS-INSTANCE-TEMP) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (REMAINDER B A)) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-PLUS (REWRITE) (IMPLIES (EQUAL (REMAINDER B A) 0) (AND (EQUAL (GCD A (PLUS B C)) (GCD A C)) (EQUAL (GCD A (PLUS C B)) (GCD A C)) (EQUAL (GCD (PLUS B C) A) (GCD A C)) (EQUAL (GCD (PLUS C B) A) (GCD A C)))) ((ENABLE COMMUTATIVITY-OF-PLUS COMMUTATIVITY-OF-GCD) (USE (GCD-PLUS-PROOF (A A) (B B) (C C))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-PLUS-INSTANCE (REWRITE) (AND (EQUAL (GCD A (PLUS A B)) (GCD A B)) (EQUAL (GCD A (PLUS B A)) (GCD A B))) ((ENABLE GCD-PLUS-INSTANCE-TEMP) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA REMAINDER-GCD (REWRITE) (AND (EQUAL (REMAINDER A (GCD A B)) 0) (EQUAL (REMAINDER B (GCD A B)) 0)) ((ENABLE GCD) (ENABLE-THEORY ADDITION REMAINDERS GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DISTRIBUTIVITY-OF-TIMES-OVER-GCD-PROOF NIL (EQUAL (GCD (TIMES X Z) (TIMES Y Z)) (TIMES Z (GCD X Y))) ((ENABLE GCD COMMUTATIVITY-OF-GCD GCD-0 GCD-PLUS) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA DISTRIBUTIVITY-OF-TIMES-OVER-GCD (REWRITE) (AND (EQUAL (GCD (TIMES X Z) (TIMES Y Z)) (TIMES Z (GCD X Y))) (EQUAL (GCD (TIMES Z X) (TIMES Y Z)) (TIMES Z (GCD X Y))) (EQUAL (GCD (TIMES X Z) (TIMES Z Y)) (TIMES Z (GCD X Y))) (EQUAL (GCD (TIMES Z X) (TIMES Z Y)) (TIMES Z (GCD X Y)))) ((USE (DISTRIBUTIVITY-OF-TIMES-OVER-GCD-PROOF (X X) (Y Y) (Z Z))) (ENABLE COMMUTATIVITY-OF-TIMES) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-IS-THE-GREATEST NIL (IMPLIES (AND (NOT (ZEROP X)) (NOT (ZEROP Y)) (EQUAL (REMAINDER X Z) 0) (EQUAL (REMAINDER Y Z) 0)) (IF (LESSP (GCD X Y) Z) F T)) ((ENABLE GCD COMMUTATIVITY-OF-GCD DISTRIBUTIVITY-OF-TIMES-OVER-GCD EQUAL-GCD-0) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA COMMON-DIVISOR-DIVIDES-GCD (REWRITE) (IMPLIES (AND (EQUAL (REMAINDER X Z) 0) (EQUAL (REMAINDER Y Z) 0)) (EQUAL (REMAINDER (GCD X Y) Z) 0)) ((ENABLE GCD COMMUTATIVITY-OF-GCD DISTRIBUTIVITY-OF-TIMES-OVER-GCD EQUAL-GCD-0) (ENABLE-THEORY ADDITION MULTIPLICATION REMAINDERS GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA ASSOCIATIVITY-OF-GCD-ZERO-CASE NIL (IMPLIES (OR (ZEROP A) (ZEROP B) (ZEROP C)) (EQUAL (GCD (GCD A B) C) (GCD A (GCD B C)))) ((ENABLE GCD GCD-0) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ASSOCIATIVITY-OF-GCD (REWRITE) (EQUAL (GCD (GCD A B) C) (GCD A (GCD B C))) ((ENABLE EQUAL-GCD-0 REMAINDER-GCD) (USE (GCD-IS-THE-GREATEST (X A) (Y (GCD B C)) (Z (GCD (GCD A B) C))) (GCD-IS-THE-GREATEST (X (GCD A B)) (Y C) (Z (GCD A (GCD B C)))) (ASSOCIATIVITY-OF-GCD-ZERO-CASE (A A) (B B) (C C)) (TRANSITIVITY-OF-DIVIDES (A A) (B (GCD A B)) (C (GCD (GCD A B) C))) (TRANSITIVITY-OF-DIVIDES (A B) (B (GCD A B)) (C (GCD (GCD A B) C))) (TRANSITIVITY-OF-DIVIDES (A B) (B (GCD B C)) (C (GCD A (GCD B C)))) (TRANSITIVITY-OF-DIVIDES (A C) (B (GCD B C)) (C (GCD A (GCD B C)))) (COMMON-DIVISOR-DIVIDES-GCD (X B) (Y C) (Z (GCD (GCD A B) C))) (COMMON-DIVISOR-DIVIDES-GCD (X A) (Y B) (Z (GCD A (GCD B C))))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY2-OF-GCD-ZERO-CASE NIL (IMPLIES (OR (ZEROP A) (ZEROP B) (ZEROP C)) (EQUAL (GCD B (GCD A C)) (GCD A (GCD B C)))) ((ENABLE GCD GCD-0 COMMUTATIVITY-OF-GCD) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY2-OF-GCD (REWRITE) (EQUAL (GCD B (GCD A C)) (GCD A (GCD B C))) ((ENABLE EQUAL-GCD-0 REMAINDER-GCD) (USE (GCD-IS-THE-GREATEST (X A) (Y (GCD B C)) (Z (GCD B (GCD A C)))) (GCD-IS-THE-GREATEST (X B) (Y (GCD A C)) (Z (GCD A (GCD B C)))) (COMMUTATIVITY2-OF-GCD-ZERO-CASE (A A) (B B) (C C)) (TRANSITIVITY-OF-DIVIDES (A A) (B (GCD A C)) (C (GCD B (GCD A C)))) (TRANSITIVITY-OF-DIVIDES (A C) (B (GCD A C)) (C (GCD B (GCD A C)))) (TRANSITIVITY-OF-DIVIDES (A B) (B (GCD B C)) (C (GCD A (GCD B C)))) (TRANSITIVITY-OF-DIVIDES (A C) (B (GCD B C)) (C (GCD A (GCD B C)))) (COMMON-DIVISOR-DIVIDES-GCD (X B) (Y C) (Z (GCD B (GCD A C)))) (COMMON-DIVISOR-DIVIDES-GCD (X A) (Y C) (Z (GCD A (GCD B C))))) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-X-X (REWRITE) (EQUAL (GCD X X) (FIX X)) ((ENABLE GCD) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (SINGLE-NUMBER-INDUCTION X)) (DISABLE-THEORY T))) (PROVE-LEMMA GCD-IDEMPOTENCE (REWRITE) (AND (EQUAL (GCD X (GCD X Y)) (GCD X Y)) (EQUAL (GCD Y (GCD X Y)) (GCD X Y))) ((ENABLE GCD GCD-X-X GCD-PLUS REMAINDER-GCD GCD-1 COMMUTATIVITY-OF-GCD) (ENABLE-THEORY ADDITION GROUND-ZERO) (INDUCT (GCD X Y)) (DISABLE-THEORY T))) (DEFTHEORY GCDS (COMMUTATIVITY2-OF-GCD ASSOCIATIVITY-OF-GCD COMMON-DIVISOR-DIVIDES-GCD DISTRIBUTIVITY-OF-TIMES-OVER-GCD LESSP-GCD EQUAL-GCD-0 GCD-0 GCD-IDEMPOTENCE GCD-X-X REMAINDER-GCD GCD-PLUS GCD-PLUS-INSTANCE GCD-1 COMMUTATIVITY-OF-GCD)) (DEFTHEORY NATURALS (ADDITION MULTIPLICATION REMAINDERS QUOTIENTS EXPONENTIATION LOGS GCDS)) (DEFN INTEGERP (X) (COND ((NUMBERP X) T) ((NEGATIVEP X) (NOT (ZEROP (NEGATIVE-GUTS X)))) (T F))) (DEFN FIX-INT (X) (IF (INTEGERP X) X 0)) (DEFN IZEROP (I) (EQUAL (FIX-INT I) 0)) (DEFN ILESSP (I J) (COND ((NEGATIVEP I) (COND ((NEGATIVEP J) (LESSP (NEGATIVE-GUTS J) (NEGATIVE-GUTS I))) ((EQUAL I (MINUS 0)) (LESSP 0 J)) (T T))) ((NEGATIVEP J) F) (T (LESSP I J)))) (DEFN ILEQ (I J) (NOT (ILESSP J I))) (DEFN IPLUS (X Y) (COND ((NEGATIVEP X) (COND ((NEGATIVEP Y) (IF (AND (ZEROP (NEGATIVE-GUTS X)) (ZEROP (NEGATIVE-GUTS Y))) 0 (MINUS (PLUS (NEGATIVE-GUTS X) (NEGATIVE-GUTS Y))))) ((LESSP Y (NEGATIVE-GUTS X)) (MINUS (DIFFERENCE (NEGATIVE-GUTS X) Y))) (T (DIFFERENCE Y (NEGATIVE-GUTS X))))) ((NEGATIVEP Y) (IF (LESSP X (NEGATIVE-GUTS Y)) (MINUS (DIFFERENCE (NEGATIVE-GUTS Y) X)) (DIFFERENCE X (NEGATIVE-GUTS Y)))) (T (PLUS X Y)))) (DEFN INEG (X) (COND ((NEGATIVEP X) (NEGATIVE-GUTS X)) ((ZEROP X) 0) (T (MINUS X)))) (DEFN IDIFFERENCE (X Y) (IPLUS X (INEG Y))) (DEFN IABS (I) (IF (NEGATIVEP I) (NEGATIVE-GUTS I) (FIX I))) (DEFN ITIMES (I J) (COND ((NEGATIVEP I) (IF (NEGATIVEP J) (TIMES (NEGATIVE-GUTS I) (NEGATIVE-GUTS J)) (FIX-INT (MINUS (TIMES (NEGATIVE-GUTS I) J))))) ((NEGATIVEP J) (FIX-INT (MINUS (TIMES I (NEGATIVE-GUTS J))))) (T (TIMES I J)))) (DEFN IQUOTIENT (I J) (COND ((EQUAL (FIX-INT J) 0) 0) ((NEGATIVEP I) (COND ((NEGATIVEP J) (IF (EQUAL (REMAINDER (NEGATIVE-GUTS I) (NEGATIVE-GUTS J)) 0) (QUOTIENT (NEGATIVE-GUTS I) (NEGATIVE-GUTS J)) (ADD1 (QUOTIENT (NEGATIVE-GUTS I) (NEGATIVE-GUTS J))))) ((EQUAL (REMAINDER (NEGATIVE-GUTS I) J) 0) (FIX-INT (MINUS (QUOTIENT (NEGATIVE-GUTS I) J)))) (T (FIX-INT (MINUS (ADD1 (QUOTIENT (NEGATIVE-GUTS I) J))))))) ((NEGATIVEP J) (FIX-INT (MINUS (QUOTIENT I (NEGATIVE-GUTS J))))) (T (QUOTIENT I J)))) (DEFN IREMAINDER (I J) (IDIFFERENCE I (ITIMES J (IQUOTIENT I J)))) (DEFN IDIV (I J) (COND ((EQUAL (FIX-INT J) 0) 0) ((NEGATIVEP I) (COND ((NEGATIVEP J) (QUOTIENT (NEGATIVE-GUTS I) (NEGATIVE-GUTS J))) ((EQUAL (REMAINDER (NEGATIVE-GUTS I) J) 0) (FIX-INT (MINUS (QUOTIENT (NEGATIVE-GUTS I) J)))) (T (FIX-INT (MINUS (ADD1 (QUOTIENT (NEGATIVE-GUTS I) J))))))) ((NEGATIVEP J) (IF (EQUAL (REMAINDER I (NEGATIVE-GUTS J)) 0) (FIX-INT (MINUS (QUOTIENT I (NEGATIVE-GUTS J)))) (FIX-INT (MINUS (ADD1 (QUOTIENT I (NEGATIVE-GUTS J))))))) (T (QUOTIENT I J)))) (DEFN IMOD (I J) (IDIFFERENCE (FIX-INT I) (ITIMES J (IDIV I J)))) (DEFN IQUO (I J) (COND ((EQUAL (FIX-INT J) 0) 0) ((NEGATIVEP I) (IF (NEGATIVEP J) (QUOTIENT (NEGATIVE-GUTS I) (NEGATIVE-GUTS J)) (FIX-INT (MINUS (QUOTIENT (NEGATIVE-GUTS I) J))))) ((NEGATIVEP J) (FIX-INT (MINUS (QUOTIENT I (NEGATIVE-GUTS J))))) (T (QUOTIENT I J)))) (DEFN IREM (I J) (IDIFFERENCE (FIX-INT I) (ITIMES J (IQUO I J)))) (DEFTHEORY INTEGER-DEFNS (INTEGERP FIX-INT ILESSP IPLUS INEG IABS ITIMES IQUOTIENT IREMAINDER IDIV IMOD IQUO IREM)) (DEFTHEORY ALL-INTEGER-DEFNS (INTEGERP FIX-INT IZEROP ILESSP ILEQ IPLUS INEG IDIFFERENCE IABS ITIMES IQUOTIENT IREMAINDER IDIV IMOD IQUO IREM)) (TOGGLE INTEGERP-OFF INTEGERP T) (TOGGLE FIX-INT-OFF FIX-INT T) (TOGGLE ILESSP-OFF ILESSP T) (TOGGLE IPLUS-OFF IPLUS T) (TOGGLE INEG-OFF INEG T) (TOGGLE IABS-OFF IABS T) (TOGGLE ITIMES-OFF ITIMES T) (PROVE-LEMMA INTEGERP-FIX-INT (REWRITE) (INTEGERP (FIX-INT X)) ((ENABLE INTEGERP FIX-INT) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IPLUS (REWRITE) (INTEGERP (IPLUS X Y)) ((ENABLE INTEGERP IPLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IDIFFERENCE (REWRITE) (INTEGERP (IDIFFERENCE X Y)) ((ENABLE INTEGERP-IPLUS IDIFFERENCE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-INEG (REWRITE) (INTEGERP (INEG X)) ((ENABLE INTEGERP INEG) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IABS (REWRITE) (INTEGERP (IABS X)) ((ENABLE INTEGERP IABS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-ITIMES (REWRITE) (INTEGERP (ITIMES X Y)) ((ENABLE INTEGERP ITIMES FIX-INT) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-REMOVER (REWRITE) (IMPLIES (INTEGERP X) (EQUAL (FIX-INT X) X)) ((ENABLE FIX-INT INTEGERP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-FIX-INT (REWRITE) (EQUAL (FIX-INT (FIX-INT X)) (FIX-INT X)) ((ENABLE FIX-INT INTEGERP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IPLUS (REWRITE) (EQUAL (FIX-INT (IPLUS A B)) (IPLUS A B)) ((ENABLE FIX-INT INTEGERP IPLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IDIFFERENCE (REWRITE) (EQUAL (FIX-INT (IDIFFERENCE A B)) (IDIFFERENCE A B)) ((ENABLE FIX-INT-IPLUS IDIFFERENCE) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-INEG (REWRITE) (EQUAL (FIX-INT (INEG X)) (INEG X)) ((ENABLE FIX-INT INTEGERP INEG) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IABS (REWRITE) (EQUAL (FIX-INT (IABS X)) (IABS X)) ((ENABLE INTEGERP FIX-INT IABS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-ITIMES (REWRITE) (EQUAL (FIX-INT (ITIMES X Y)) (ITIMES X Y)) ((ENABLE INTEGERP ITIMES FIX-INT) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INEG-IPLUS (REWRITE) (EQUAL (INEG (IPLUS A B)) (IPLUS (INEG A) (INEG B))) ((ENABLE IPLUS INEG PLUS-ZERO-ARG2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INEG-INEG (REWRITE) (EQUAL (INEG (INEG X)) (FIX-INT X)) ((ENABLE INEG FIX-INT INTEGERP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INEG-FIX-INT (REWRITE) (EQUAL (INEG (FIX-INT X)) (INEG X)) ((ENABLE INEG FIX-INT INTEGERP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INEG-OF-NON-INTEGERP (REWRITE) (IMPLIES (NOT (INTEGERP X)) (EQUAL (INEG X) 0)) ((ENABLE INEG INTEGERP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE INEG-OF-NON-INTEGERP-OFF INEG-OF-NON-INTEGERP T) (PROVE-LEMMA INEG-0 (REWRITE) (EQUAL (INEG 0) 0) ((ENABLE INEG) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-LEFT-ID (REWRITE) (IMPLIES (NOT (INTEGERP X)) (EQUAL (IPLUS X Y) (FIX-INT Y))) ((ENABLE INTEGERP IPLUS FIX-INT) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE IPLUS-LEFT-ID-OFF IPLUS-LEFT-ID T) (PROVE-LEMMA IPLUS-RIGHT-ID (REWRITE) (IMPLIES (NOT (INTEGERP Y)) (EQUAL (IPLUS X Y) (FIX-INT X))) ((ENABLE INTEGERP IPLUS FIX-INT PLUS-ZERO-ARG2) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE IPLUS-RIGHT-ID-OFF IPLUS-RIGHT-ID T) (PROVE-LEMMA IPLUS-0-LEFT (REWRITE) (EQUAL (IPLUS 0 X) (FIX-INT X)) ((ENABLE IPLUS FIX-INT INTEGERP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-0-RIGHT (REWRITE) (EQUAL (IPLUS X 0) (FIX-INT X)) ((ENABLE IPLUS FIX-INT INTEGERP) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY2-OF-IPLUS (REWRITE) (EQUAL (IPLUS X (IPLUS Y Z)) (IPLUS Y (IPLUS X Z))) ((ENABLE IPLUS COMMUTATIVITY2-OF-PLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY-OF-IPLUS (REWRITE) (EQUAL (IPLUS X Y) (IPLUS Y X)) ((ENABLE IPLUS COMMUTATIVITY2-OF-IPLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ASSOCIATIVITY-OF-IPLUS (REWRITE) (EQUAL (IPLUS (IPLUS X Y) Z) (IPLUS X (IPLUS Y Z))) ((ENABLE IPLUS) (ENABLE-THEORY ADDITION GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-CANCELLATION-1 (REWRITE) (EQUAL (EQUAL (IPLUS A B) (IPLUS A C)) (EQUAL (FIX-INT B) (FIX-INT C))) ((ENABLE IPLUS FIX-INT INTEGERP) (ENABLE-THEORY ADDITION GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-CANCELLATION-2 (REWRITE) (EQUAL (EQUAL (IPLUS B A) (IPLUS C A)) (EQUAL (FIX-INT B) (FIX-INT C))) ((USE (IPLUS-CANCELLATION-1)) (ENABLE COMMUTATIVITY-OF-IPLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-INEG1 (REWRITE) (EQUAL (IPLUS (INEG A) A) 0) ((ENABLE IPLUS INEG INTEGERP FIX-INT) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-INEG2 (REWRITE) (EQUAL (IPLUS A (INEG A)) 0) ((ENABLE IPLUS INEG INTEGERP FIX-INT) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-FIX-INT1 (REWRITE) (EQUAL (IPLUS (FIX-INT A) B) (IPLUS A B)) ((ENABLE IPLUS FIX-INT INTEGERP PLUS-ZERO-ARG2) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-FIX-INT2 (REWRITE) (EQUAL (IPLUS A (FIX-INT B)) (IPLUS A B)) ((ENABLE IPLUS FIX-INT INTEGERP PLUS-ZERO-ARG2) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IDIFFERENCE-FIX-INT1 (REWRITE) (EQUAL (IDIFFERENCE (FIX-INT A) B) (IDIFFERENCE A B)) ((ENABLE IDIFFERENCE IPLUS-FIX-INT1) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IDIFFERENCE-FIX-INT2 (REWRITE) (EQUAL (IDIFFERENCE A (FIX-INT B)) (IDIFFERENCE A B)) ((ENABLE IDIFFERENCE IPLUS-FIX-INT2 INEG-FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN CANCEL-INEG-AUX (X Y) (COND ((LISTP X) (COND ((EQUAL (CAR X) 'INEG) (COND ((EQUAL Y (CADR X)) ''0) ((LISTP Y) (IF (EQUAL (CAR Y) 'IPLUS) (COND ((EQUAL (CADR Y) (CADR X)) (LIST 'FIX-INT (CADDR Y))) ((CANCEL-INEG-AUX X (CADDR Y)) (LIST 'IPLUS (CADR Y) (CANCEL-INEG-AUX X (CADDR Y)))) (T F)) F)) (T F))) ((NLISTP Y) F) ((EQUAL (CAR Y) 'INEG) (IF (EQUAL X (CADR Y)) ''0 F)) ((EQUAL (CAR Y) 'IPLUS) (COND ((LISTP (CADR Y)) (COND ((EQUAL (CAADR Y) 'INEG) (COND ((EQUAL X (CADADR Y)) (LIST 'FIX-INT (CADDR Y))) ((CANCEL-INEG-AUX X (CADDR Y)) (LIST 'IPLUS (CADR Y) (CANCEL-INEG-AUX X (CADDR Y)))) (T F))) ((CANCEL-INEG-AUX X (CADDR Y)) (LIST 'IPLUS (CADR Y) (CANCEL-INEG-AUX X (CADDR Y)))) (T F))) ((CANCEL-INEG-AUX X (CADDR Y)) (LIST 'IPLUS (CADR Y) (CANCEL-INEG-AUX X (CADDR Y)))) (T F))) (T F))) ((NLISTP Y) F) ((EQUAL (CAR Y) 'INEG) (IF (EQUAL X (CADR Y)) ''0 F)) ((EQUAL (CAR Y) 'IPLUS) (COND ((LISTP (CADR Y)) (COND ((EQUAL (CAADR Y) 'INEG) (COND ((EQUAL X (CADADR Y)) (LIST 'FIX-INT (CADDR Y))) ((CANCEL-INEG-AUX X (CADDR Y)) (LIST 'IPLUS (CADR Y) (CANCEL-INEG-AUX X (CADDR Y)))) (T F))) ((CANCEL-INEG-AUX X (CADDR Y)) (LIST 'IPLUS (CADR Y) (CANCEL-INEG-AUX X (CADDR Y)))) (T F))) ((CANCEL-INEG-AUX X (CADDR Y)) (LIST 'IPLUS (CADR Y) (CANCEL-INEG-AUX X (CADDR Y)))) (T F))) (T F))) (DEFN CANCEL-INEG (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'IPLUS) (IF (CANCEL-INEG-AUX (CADR X) (CADDR X)) (CANCEL-INEG-AUX (CADR X) (CADDR X)) X) X) X)) (PROVE-LEMMA EVAL$-LIST-CONS (REWRITE) (EQUAL (EVAL$ 'LIST (CONS X Y) A) (CONS (EVAL$ T X A) (EVAL$ 'LIST Y A)))) (PROVE-LEMMA EVAL$-LIST-NLISTP (REWRITE) (IMPLIES (NLISTP X) (EQUAL (EVAL$ 'LIST X A) NIL))) (PROVE-LEMMA EVAL$-LITATOM (REWRITE) (IMPLIES (LITATOM X) (EQUAL (EVAL$ T X A) (CDR (ASSOC X A))))) (TOGGLE EVAL$-QUOTE-ON EVAL$-QUOTE NIL) (PROVE-LEMMA EVAL$-OTHER (REWRITE) (IMPLIES (AND (NOT (LITATOM X)) (NLISTP X)) (EQUAL (EVAL$ T X A) X))) (TOGGLE EVAL$-OFF EVAL$ T) (DEFN EVAL$-CANCEL-INEG-AUX-FN (X Y A) (COND ((AND (LISTP X) (EQUAL (CAR X) 'INEG)) (COND ((EQUAL Y (CADR X)) 0) ((EQUAL (CADR Y) (CADR X)) (FIX-INT (EVAL$ T (CADDR Y) A))) ((LISTP Y) (IPLUS (EVAL$ T (CADR Y) A) (EVAL$-CANCEL-INEG-AUX-FN X (CADDR Y) A))) (T 0))) ((EQUAL (CAR Y) 'INEG) 0) ((AND (LISTP (CADR Y)) (EQUAL (CAADR Y) 'INEG) (EQUAL X (CADADR Y))) (FIX-INT (EVAL$ T (CADDR Y) A))) ((LISTP Y) (IPLUS (EVAL$ T (CADR Y) A) (EVAL$-CANCEL-INEG-AUX-FN X (CADDR Y) A))) (T 0))) (PROVE-LEMMA EVAL$-CANCEL-INEG-AUX-IS-ITS-FN (REWRITE) (IMPLIES (NOT (EQUAL (CANCEL-INEG-AUX X Y) F)) (EQUAL (EVAL$ T (CANCEL-INEG-AUX X Y) A) (EVAL$-CANCEL-INEG-AUX-FN X Y A)))) (PROVE-LEMMA IPLUS-INEG3 (REWRITE) (EQUAL (IPLUS (INEG X) (IPLUS X Y)) (FIX-INT Y)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA IPLUS-INEG4 (REWRITE) (EQUAL (IPLUS X (IPLUS (INEG X) Y)) (FIX-INT Y)) ((USE (IPLUS-INEG3 (X (INEG X)) (Y Y))))) (PROVE-LEMMA IPLUS-INEG-PROMOTE (REWRITE) (EQUAL (IPLUS Y (INEG X)) (IPLUS (INEG X) Y))) (PROVE-LEMMA IPLUS-X-Y-INEG-X (REWRITE) (EQUAL (IPLUS X (IPLUS Y (INEG X))) (FIX-INT Y))) (TOGGLE IPLUS-INEG-PROMOTE-OFF IPLUS-INEG-PROMOTE T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-INEG-AUX (REWRITE) (IMPLIES (NOT (EQUAL (CANCEL-INEG-AUX X Y) F)) (EQUAL (EVAL$-CANCEL-INEG-AUX-FN X Y A) (IPLUS (EVAL$ T X A) (EVAL$ T Y A)))) ((INDUCT (CANCEL-INEG-AUX X Y)))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-INEG ((META IPLUS)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-INEG X) A)) ((DISABLE CANCEL-INEG-AUX))) (TOGGLE CORRECTNESS-OF-CANCEL-INEG-AUX-OFF CORRECTNESS-OF-CANCEL-INEG-AUX T) (DEFN IPLUS-FRINGE (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'IPLUS) (APPEND (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST X)) (LIST X))) (PROVE-LEMMA LESSP-COUNT-LISTP-CDR (REWRITE) (IMPLIES (LISTP (CDR X)) (LESSP (COUNT (CDR X)) (COUNT X)))) (DEFN IPLUS-TREE-REC (L) (IF (NLISTP (CDR L)) (CAR L) (LIST 'IPLUS (CAR L) (IPLUS-TREE-REC (CDR L))))) (DEFN IPLUS-TREE (L) (IF (LISTP L) (IF (LISTP (CDR L)) (IPLUS-TREE-REC L) (LIST 'FIX-INT (CAR L))) ''0)) (DEFN IPLUS-LIST (X) (IF (LISTP X) (IPLUS (CAR X) (IPLUS-LIST (CDR X))) 0)) (PROVE-LEMMA INTEGERP-IPLUS-LIST (REWRITE) (INTEGERP (IPLUS-LIST X))) (PROVE-LEMMA EVAL$-IPLUS-TREE-REC (REWRITE) (EQUAL (EVAL$ T (IPLUS-TREE-REC X) A) (IF (LISTP X) (IF (LISTP (CDR X)) (IPLUS-LIST (EVAL$ 'LIST X A)) (EVAL$ T (CAR X) A)) 0))) (PROVE-LEMMA EVAL$-IPLUS-TREE (REWRITE) (EQUAL (EVAL$ T (IPLUS-TREE X) A) (IPLUS-LIST (EVAL$ 'LIST X A)))) (PROVE-LEMMA EVAL$-LIST-APPEND (REWRITE) (EQUAL (EVAL$ 'LIST (APPEND X Y) A) (APPEND (EVAL$ 'LIST X A) (EVAL$ 'LIST Y A)))) (DEFN CANCEL-IPLUS (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'EQUAL) (COND ((LISTP (CADR X)) (COND ((EQUAL (CAADR X) 'IPLUS) (COND ((LISTP (CADDR X)) (COND ((EQUAL (CAADDR X) 'IPLUS) (IF (LISTP (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))) (LIST 'EQUAL (IPLUS-TREE (BAGDIFF (IPLUS-FRINGE (CADR X)) (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (BAGDIFF (IPLUS-FRINGE (CADDR X)) (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) ((MEMBER (CADDR X) (IPLUS-FRINGE (CADR X))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (CONS 'EQUAL (CONS (IPLUS-TREE (DELETE (CADDR X) (IPLUS-FRINGE (CADR X)))) '('0))) (LIST 'QUOTE F))) (T X))) ((MEMBER (CADDR X) (IPLUS-FRINGE (CADR X))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (CONS 'EQUAL (CONS (IPLUS-TREE (DELETE (CADDR X) (IPLUS-FRINGE (CADR X)))) '('0))) (LIST 'QUOTE F))) (T X))) ((LISTP (CADDR X)) (IF (EQUAL (CAADDR X) 'IPLUS) (IF (MEMBER (CADR X) (IPLUS-FRINGE (CADDR X))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (LIST 'EQUAL ''0 (IPLUS-TREE (DELETE (CADR X) (IPLUS-FRINGE (CADDR X))))) (LIST 'QUOTE F)) X) X)) (T X))) ((LISTP (CADDR X)) (IF (EQUAL (CAADDR X) 'IPLUS) (IF (MEMBER (CADR X) (IPLUS-FRINGE (CADDR X))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (LIST 'EQUAL ''0 (IPLUS-TREE (DELETE (CADR X) (IPLUS-FRINGE (CADDR X))))) (LIST 'QUOTE F)) X) X)) (T X)) X) X)) (PROVE-LEMMA EVAL$-CANCEL-IPLUS (REWRITE) (EQUAL (EVAL$ T (CANCEL-IPLUS X) A) (IF (AND (LISTP X) (EQUAL (CAR X) 'EQUAL)) (COND ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'IPLUS) (LISTP (CADDR X)) (EQUAL (CAADDR X) 'IPLUS)) (IF (LISTP (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (BAGDIFF (IPLUS-FRINGE (CADR X)) (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))) A)) (IPLUS-LIST (EVAL$ 'LIST (BAGDIFF (IPLUS-FRINGE (CADDR X)) (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))) A))) (EVAL$ T X A))) ((AND (LISTP (CADR X)) (EQUAL (CAADR X) 'IPLUS) (MEMBER (CADDR X) (IPLUS-FRINGE (CADR X)))) (IF (INTEGERP (EVAL$ T (CADDR X) A)) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (DELETE (CADDR X) (IPLUS-FRINGE (CADR X))) A)) 0) F)) ((AND (LISTP (CADDR X)) (EQUAL (CAADDR X) 'IPLUS) (MEMBER (CADR X) (IPLUS-FRINGE (CADDR X)))) (IF (INTEGERP (EVAL$ T (CADR X) A)) (EQUAL 0 (IPLUS-LIST (EVAL$ 'LIST (DELETE (CADR X) (IPLUS-FRINGE (CADDR X))) A))) F)) (T (EVAL$ T X A))) (EVAL$ T X A))) ((ENABLE EVAL$-IPLUS-TREE CANCEL-IPLUS EVAL$-LIST-CONS EVAL$-LITATOM EVAL$-QUOTE) (DISABLE EVAL$) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE CANCEL-IPLUS-OFF CANCEL-IPLUS T) (PROVE-LEMMA EVAL$-IPLUS-LIST-DELETE (REWRITE) (IMPLIES (MEMBER Z Y) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (DELETE Z Y) A)) (IDIFFERENCE (IPLUS-LIST (EVAL$ 'LIST Y A)) (EVAL$ T Z A))))) (PROVE-LEMMA EVAL$-IPLUS-LIST-BAGDIFF (REWRITE) (IMPLIES (SUBBAGP X Y) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (BAGDIFF Y X) A)) (IDIFFERENCE (IPLUS-LIST (EVAL$ 'LIST Y A)) (IPLUS-LIST (EVAL$ 'LIST X A)))))) (PROVE-LEMMA IPLUS-LIST-APPEND (REWRITE) (EQUAL (IPLUS-LIST (APPEND X Y)) (IPLUS (IPLUS-LIST X) (IPLUS-LIST Y)))) (TOGGLE IPLUS-TREE-OFF IPLUS-TREE T) (PROVE-LEMMA NOT-INTEGERP-IMPLIES-NOT-EQUAL-IPLUS (REWRITE) (IMPLIES (NOT (INTEGERP A)) (EQUAL (EQUAL A (IPLUS B C)) F)) ((USE (INTEGERP-IPLUS (X B) (Y C))) (ENABLE INTEGERP) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IPLUS-LIST-EVAL$-FRINGE (REWRITE) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (IPLUS-FRINGE X) A)) (FIX-INT (EVAL$ T X A))) ((INDUCT (IPLUS-FRINGE X)))) (PROVE-LEMMA IPLUS-INEG5-LEMMA-1 (REWRITE) (IMPLIES (INTEGERP X) (EQUAL (EQUAL X (IPLUS Y (IPLUS (INEG Z) W))) (EQUAL X (IPLUS (INEG Z) (IPLUS Y W)))))) (PROVE-LEMMA IPLUS-INEG5-LEMMA-2 (REWRITE) (IMPLIES (AND (INTEGERP X) (INTEGERP V)) (EQUAL (EQUAL X (IPLUS (INEG Z) V)) (EQUAL (IPLUS X Z) V)))) (PROVE-LEMMA IPLUS-INEG5 (REWRITE) (IMPLIES (INTEGERP X) (EQUAL (EQUAL X (IPLUS Y (IPLUS (INEG Z) W))) (EQUAL (IPLUS X Z) (IPLUS Y W)))) ((ENABLE IPLUS-INEG5-LEMMA-1 IPLUS-INEG5-LEMMA-2 INTEGERP-IPLUS) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE IPLUS-INEG5-LEMMA-1-OFF IPLUS-INEG5-LEMMA-1 T) (TOGGLE IPLUS-INEG5-LEMMA-2-OFF IPLUS-INEG5-LEMMA-2 T) (PROVE-LEMMA IPLUS-INEG6 (REWRITE) (IMPLIES (INTEGERP X) (EQUAL (EQUAL X (IPLUS Y (IPLUS W (INEG Z)))) (EQUAL (IPLUS X Z) (IPLUS Y W)))) ((USE (IPLUS-INEG5) (COMMUTATIVITY-OF-IPLUS (X W) (Y (INEG Z)))) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA EVAL$-IPLUS (REWRITE) (IMPLIES (AND (LISTP X) (EQUAL (CAR X) 'IPLUS)) (EQUAL (EVAL$ T X A) (IPLUS (EVAL$ T (CADR X) A) (EVAL$ T (CADDR X) A))))) (PROVE-LEMMA IPLUS-INEG7 (REWRITE) (EQUAL (EQUAL 0 (IPLUS X (INEG Y))) (EQUAL (FIX-INT Y) (FIX-INT X))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-IPLUS ((META EQUAL)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-IPLUS X) A))) (TOGGLE IPLUS-INEG5-OFF IPLUS-INEG5 T) (TOGGLE IPLUS-INEG6-OFF IPLUS-INEG6 T) (PROVE-LEMMA ILESSP-FIX-INT-1 (REWRITE) (EQUAL (ILESSP (FIX-INT X) Y) (ILESSP X Y)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ILESSP-FIX-INT-2 (REWRITE) (EQUAL (ILESSP X (FIX-INT Y)) (ILESSP X Y)) ((ENABLE-THEORY INTEGER-DEFNS))) (DEFN MAKE-CANCEL-IPLUS-INEQUALITY-1 (X Y) (LIST 'ILESSP (IPLUS-TREE (BAGDIFF X (BAGINT X Y))) (IPLUS-TREE (BAGDIFF Y (BAGINT X Y))))) (DEFN CANCEL-IPLUS-ILESSP-1 (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'ILESSP) (MAKE-CANCEL-IPLUS-INEQUALITY-1 (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) X) X)) (PROVE-LEMMA LESSP-DIFFERENCE-PLUS-ARG1 (REWRITE) (EQUAL (LESSP W (DIFFERENCE (PLUS W Y) X)) (LESSP X Y))) (PROVE-LEMMA LESSP-DIFFERENCE-PLUS-ARG1-COMMUTED (REWRITE) (EQUAL (LESSP W (DIFFERENCE (PLUS Y W) X)) (LESSP X Y))) (PROVE-LEMMA IPLUS-CANCELLATION-1-FOR-ILESSP (REWRITE) (EQUAL (ILESSP (IPLUS A B) (IPLUS A C)) (ILESSP B C)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA IPLUS-CANCELLATION-2-FOR-ILESSP (REWRITE) (EQUAL (ILESSP (IPLUS B A) (IPLUS C A)) (ILESSP B C))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-IPLUS-ILESSP-LEMMA NIL (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-IPLUS-ILESSP-1 X) A))) (DEFN IPLUS-TREE-NO-FIX-INT (L) (IF (LISTP L) (IPLUS-TREE-REC L) ''0)) (PROVE-LEMMA EVAL$-ILESSP-IPLUS-TREE-NO-FIX-INT (REWRITE) (EQUAL (ILESSP (EVAL$ T (IPLUS-TREE-NO-FIX-INT X) A) (EVAL$ T (IPLUS-TREE-NO-FIX-INT Y) A)) (ILESSP (EVAL$ T (IPLUS-TREE X) A) (EVAL$ T (IPLUS-TREE Y) A)))) (TOGGLE IPLUS-TREE-NO-FIX-INT-OFF IPLUS-TREE-NO-FIX-INT T) (PROVE-LEMMA MAKE-CANCEL-IPLUS-INEQUALITY-SIMPLIFIER (REWRITE) (EQUAL (EVAL$ T (MAKE-CANCEL-IPLUS-INEQUALITY-1 X Y) A) (EVAL$ T (LIST 'ILESSP (IPLUS-TREE-NO-FIX-INT (BAGDIFF X (BAGINT X Y))) (IPLUS-TREE-NO-FIX-INT (BAGDIFF Y (BAGINT X Y)))) A)) ((ENABLE MAKE-CANCEL-IPLUS-INEQUALITY-1 EVAL$-ILESSP-IPLUS-TREE-NO-FIX-INT) (DISABLE EVAL$) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (DEFN CANCEL-IPLUS-ILESSP (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'ILESSP) (IF (LISTP (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))) (LIST 'ILESSP (IPLUS-TREE-NO-FIX-INT (BAGDIFF (IPLUS-FRINGE (CADR X)) (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE-NO-FIX-INT (BAGDIFF (IPLUS-FRINGE (CADDR X)) (BAGINT (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X) X) X)) (TOGGLE MAKE-CANCEL-IPLUS-INEQUALITY-1-OFF MAKE-CANCEL-IPLUS-INEQUALITY-1 T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-IPLUS-ILESSP ((META ILESSP)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-IPLUS-ILESSP X) A)) ((USE (CORRECTNESS-OF-CANCEL-IPLUS-ILESSP-LEMMA)))) (PROVE-LEMMA ITIMES-ZERO1 (REWRITE) (IMPLIES (EQUAL (FIX-INT X) 0) (EQUAL (ITIMES X Y) 0)) ((ENABLE ITIMES TIMES FIX-INT INTEGERP) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-0-LEFT (REWRITE) (EQUAL (ITIMES 0 Y) 0)) (TOGGLE ITIMES-ZERO1-OFF ITIMES-ZERO1 T) (PROVE-LEMMA ITIMES-ZERO2 (REWRITE) (IMPLIES (EQUAL (FIX-INT Y) 0) (EQUAL (ITIMES X Y) 0)) ((ENABLE ITIMES FIX-INT INTEGERP TIMES-ZERO) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-0-RIGHT (REWRITE) (EQUAL (ITIMES X 0) 0)) (TOGGLE ITIMES-ZERO2-OFF ITIMES-ZERO2 T) (PROVE-LEMMA ITIMES-FIX-INT1 (REWRITE) (EQUAL (ITIMES (FIX-INT A) B) (ITIMES A B)) ((ENABLE ITIMES FIX-INT INTEGERP) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-FIX-INT2 (REWRITE) (EQUAL (ITIMES A (FIX-INT B)) (ITIMES A B)) ((ENABLE ITIMES FIX-INT INTEGERP TIMES-ZERO) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY-OF-ITIMES (REWRITE) (EQUAL (ITIMES X Y) (ITIMES Y X)) ((ENABLE ITIMES FIX-INT INTEGERP) (ENABLE-THEORY MULTIPLICATION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-DISTRIBUTES-OVER-IPLUS-PROOF NIL (EQUAL (ITIMES X (IPLUS Y Z)) (IPLUS (ITIMES X Y) (ITIMES X Z))) ((ENABLE ITIMES IPLUS INTEGERP FIX-INT COMMUTATIVITY2-OF-IPLUS ASSOCIATIVITY-OF-IPLUS) (ENABLE-THEORY MULTIPLICATION ADDITION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-DISTRIBUTES-OVER-IPLUS (REWRITE) (AND (EQUAL (ITIMES X (IPLUS Y Z)) (IPLUS (ITIMES X Y) (ITIMES X Z))) (EQUAL (ITIMES (IPLUS X Y) Z) (IPLUS (ITIMES X Z) (ITIMES Y Z)))) ((USE (ITIMES-DISTRIBUTES-OVER-IPLUS-PROOF (X X) (Y Y) (Z Z)) (ITIMES-DISTRIBUTES-OVER-IPLUS-PROOF (X Z) (Y X) (Z Y))) (ENABLE COMMUTATIVITY-OF-ITIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA COMMUTATIVITY2-OF-ITIMES (REWRITE) (EQUAL (ITIMES X (ITIMES Y Z)) (ITIMES Y (ITIMES X Z))) ((ENABLE ITIMES INTEGERP FIX-INT) (ENABLE-THEORY MULTIPLICATION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA ASSOCIATIVITY-OF-ITIMES (REWRITE) (EQUAL (ITIMES (ITIMES X Y) Z) (ITIMES X (ITIMES Y Z))) ((ENABLE ITIMES INTEGERP FIX-INT) (ENABLE-THEORY MULTIPLICATION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-ITIMES-0 (REWRITE) (EQUAL (EQUAL (ITIMES X Y) 0) (OR (EQUAL (FIX-INT X) 0) (EQUAL (FIX-INT Y) 0))) ((ENABLE ITIMES INTEGERP FIX-INT) (ENABLE-THEORY MULTIPLICATION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-ITIMES-1 (REWRITE) (EQUAL (EQUAL (ITIMES A B) 1) (OR (AND (EQUAL A 1) (EQUAL B 1)) (AND (EQUAL A -1) (EQUAL B -1)))) ((ENABLE ITIMES INTEGERP FIX-INT) (ENABLE-THEORY MULTIPLICATION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA EQUAL-ITIMES-MINUS-1 (REWRITE) (EQUAL (EQUAL (ITIMES A B) -1) (OR (AND (EQUAL A -1) (EQUAL B 1)) (AND (EQUAL A 1) (EQUAL B -1)))) ((ENABLE ITIMES INTEGERP FIX-INT) (ENABLE-THEORY MULTIPLICATION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-1-ARG1 (REWRITE) (EQUAL (ITIMES 1 X) (FIX-INT X)) ((ENABLE INTEGERP FIX-INT ITIMES) (ENABLE-THEORY MULTIPLICATION GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-REMAINDER-UNIQUENESS NIL (IMPLIES (AND (EQUAL A (PLUS R (TIMES B Q))) (LESSP R B)) (AND (EQUAL (FIX R) (REMAINDER A B)) (EQUAL (FIX Q) (QUOTIENT A B)))) ((ENABLE-THEORY NATURALS GROUND-ZERO) (ENABLE REMAINDER QUOTIENT) (DISABLE-THEORY T))) (PROVE-LEMMA DIVISION-THEOREM-PART1 NIL (IMPLIES (INTEGERP I) (EQUAL (IPLUS (IREMAINDER I J) (ITIMES J (IQUOTIENT I J))) I))) (PROVE-LEMMA DIVISION-THEOREM-PART2 NIL (IMPLIES (AND (INTEGERP J) (NOT (EQUAL J 0))) (NOT (ILESSP (IREMAINDER I J) 0))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA DIVISION-THEOREM-PART3 NIL (IMPLIES (AND (INTEGERP J) (NOT (EQUAL J 0))) (ILESSP (IREMAINDER I J) (IABS J))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA DIVISION-THEOREM NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (NOT (EQUAL J 0))) (AND (EQUAL (IPLUS (IREMAINDER I J) (ITIMES J (IQUOTIENT I J))) I) (NOT (ILESSP (IREMAINDER I J) 0)) (ILESSP (IREMAINDER I J) (IABS J)))) ((USE (DIVISION-THEOREM-PART1 (I I) (J J)) (DIVISION-THEOREM-PART2 (I I) (J J)) (DIVISION-THEOREM-PART3 (I I) (J J))) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA QUOTIENT-DIFFERENCE-LESSP-ARG2 (REWRITE) (IMPLIES (AND (EQUAL (REMAINDER A C) 0) (LESSP B C)) (EQUAL (QUOTIENT (DIFFERENCE A B) C) (COND ((ZEROP B) (QUOTIENT A C)) ((LESSP B A) (DIFFERENCE (QUOTIENT A C) (ADD1 (QUOTIENT B C)))) (T 0)))) ((ENABLE-THEORY NATURALS GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA IQUOTIENT-IREMAINDER-UNIQUENESS NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (INTEGERP R) (INTEGERP Q) (NOT (EQUAL J 0)) (EQUAL I (IPLUS R (ITIMES J Q))) (NOT (ILESSP R 0)) (ILESSP R (IABS J))) (AND (EQUAL R (IREMAINDER I J)) (EQUAL Q (IQUOTIENT I J)))) ((ENABLE IREMAINDER IABS IDIFFERENCE IPLUS INEG FIX-INT ITIMES IQUOTIENT ILESSP INTEGERP QUOTIENT-DIFFERENCE-LESSP-ARG2) (ENABLE-THEORY NATURALS GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART1 NIL (IMPLIES (INTEGERP I) (EQUAL (IPLUS (IMOD I J) (ITIMES J (IDIV I J))) I)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART2 NIL (IMPLIES (ILESSP 0 J) (AND (NOT (ILESSP (IMOD I J) 0)) (ILESSP (IMOD I J) J))) ((ENABLE IMOD ILESSP IDIFFERENCE IPLUS INEG ITIMES IDIV INTEGERP FIX-INT) (ENABLE-THEORY NATURALS GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART3 NIL (IMPLIES (AND (INTEGERP J) (ILESSP J 0)) (AND (NOT (ILESSP 0 (IMOD I J))) (ILESSP J (IMOD I J)))) ((ENABLE IMOD ILESSP IDIFFERENCE IPLUS INEG ITIMES IDIV INTEGERP FIX-INT) (ENABLE-THEORY NATURALS GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (NOT (EQUAL J 0))) (AND (EQUAL (IPLUS (IMOD I J) (ITIMES J (IDIV I J))) I) (IF (ILESSP 0 J) (AND (NOT (ILESSP (IMOD I J) 0)) (ILESSP (IMOD I J) J)) (AND (NOT (ILESSP 0 (IMOD I J))) (ILESSP J (IMOD I J)))))) ((USE (DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART1 (I I) (J J)) (DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART2 (I I) (J J)) (DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART3 (I I) (J J))) (ENABLE INTEGERP ILESSP) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IDIV-IMOD-UNIQUENESS NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (INTEGERP R) (INTEGERP Q) (NOT (EQUAL J 0)) (EQUAL I (IPLUS R (ITIMES J Q))) (IF (ILESSP 0 J) (AND (NOT (ILESSP R 0)) (ILESSP R J)) (AND (NOT (ILESSP 0 R)) (ILESSP J R)))) (AND (EQUAL R (IMOD I J)) (EQUAL Q (IDIV I J)))) ((ENABLE IMOD IABS IDIFFERENCE IPLUS INEG FIX-INT ITIMES IDIV ILESSP INTEGERP QUOTIENT-DIFFERENCE-LESSP-ARG2) (ENABLE-THEORY NATURALS GROUND-ZERO) (DO-NOT-INDUCT T) (DISABLE-THEORY T))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART1 NIL (IMPLIES (INTEGERP I) (EQUAL (IPLUS (IREM I J) (ITIMES J (IQUO I J))) I)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART2 NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (NOT (EQUAL J 0)) (NOT (ILESSP I 0))) (AND (NOT (ILESSP (IREM I J) 0)) (ILESSP (IREM I J) (IABS J)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART3 NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (NOT (EQUAL J 0)) (ILESSP I 0)) (AND (NOT (ILESSP 0 (IREM I J))) (ILESSP (INEG (IABS J)) (IREM I J)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (NOT (EQUAL J 0))) (AND (EQUAL (IPLUS (IREM I J) (ITIMES J (IQUO I J))) I) (IF (NOT (ILESSP I 0)) (AND (NOT (ILESSP (IREM I J) 0)) (ILESSP (IREM I J) (IABS J))) (AND (NOT (ILESSP 0 (IREM I J))) (ILESSP (INEG (IABS J)) (IREM I J)))))) ((USE (DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART1 (I I) (J J)) (DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART2 (I I) (J J)) (DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART3 (I I) (J J))) (ENABLE INTEGERP ILESSP) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IQUO-IREM-UNIQUENESS NIL (IMPLIES (AND (INTEGERP I) (INTEGERP J) (INTEGERP R) (INTEGERP Q) (NOT (EQUAL J 0)) (EQUAL I (IPLUS R (ITIMES J Q))) (IF (NOT (ILESSP I 0)) (AND (NOT (ILESSP R 0)) (ILESSP R (IABS J))) (AND (NOT (ILESSP 0 R)) (ILESSP (INEG (IABS J)) R)))) (AND (EQUAL R (IREM I J)) (EQUAL Q (IQUO I J)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ITIMES-INEG-1 (REWRITE) (EQUAL (ITIMES (INEG X) Y) (INEG (ITIMES X Y))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ITIMES-INEG-2 (REWRITE) (EQUAL (ITIMES X (INEG Y)) (INEG (ITIMES X Y))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ITIMES-CANCELLATION-1 (REWRITE) (EQUAL (EQUAL (ITIMES A B) (ITIMES A C)) (OR (EQUAL (FIX-INT A) 0) (EQUAL (FIX-INT B) (FIX-INT C)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ITIMES-CANCELLATION-2 (REWRITE) (EQUAL (EQUAL (ITIMES B A) (ITIMES C A)) (OR (EQUAL (FIX-INT A) 0) (EQUAL (FIX-INT B) (FIX-INT C)))) ((USE (ITIMES-CANCELLATION-1)) (ENABLE COMMUTATIVITY-OF-ITIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-CANCELLATION-3 (REWRITE) (EQUAL (EQUAL (ITIMES A B) (ITIMES C A)) (OR (EQUAL (FIX-INT A) 0) (EQUAL (FIX-INT B) (FIX-INT C)))) ((USE (ITIMES-CANCELLATION-1)) (ENABLE COMMUTATIVITY-OF-ITIMES) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IQUOTIENT (REWRITE) (INTEGERP (IQUOTIENT I J)) ((ENABLE INTEGERP IQUOTIENT FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IREMAINDER (REWRITE) (INTEGERP (IREMAINDER I J)) ((ENABLE IREMAINDER INTEGERP-IDIFFERENCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IDIV (REWRITE) (INTEGERP (IDIV I J)) ((ENABLE INTEGERP IDIV FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IMOD (REWRITE) (INTEGERP (IMOD I J)) ((ENABLE IMOD INTEGERP-IDIFFERENCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IQUO (REWRITE) (INTEGERP (IQUO I J)) ((ENABLE INTEGERP IQUO FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA INTEGERP-IREM (REWRITE) (INTEGERP (IREM I J)) ((ENABLE IREM INTEGERP-IDIFFERENCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IQUOTIENT-FIX-INT1 (REWRITE) (EQUAL (IQUOTIENT (FIX-INT I) J) (IQUOTIENT I J)) ((ENABLE INTEGERP IQUOTIENT FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IQUOTIENT-FIX-INT2 (REWRITE) (EQUAL (IQUOTIENT I (FIX-INT J)) (IQUOTIENT I J)) ((ENABLE INTEGERP IQUOTIENT FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IREMAINDER-FIX-INT1 (REWRITE) (EQUAL (IREMAINDER (FIX-INT I) J) (IREMAINDER I J)) ((ENABLE IREMAINDER IDIFFERENCE-FIX-INT1 IQUOTIENT-FIX-INT1) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IREMAINDER-FIX-INT2 (REWRITE) (EQUAL (IREMAINDER I (FIX-INT J)) (IREMAINDER I J)) ((ENABLE IREMAINDER ITIMES-FIX-INT1 IQUOTIENT-FIX-INT2) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IDIV-FIX-INT1 (REWRITE) (EQUAL (IDIV (FIX-INT I) J) (IDIV I J)) ((ENABLE INTEGERP IDIV FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IDIV-FIX-INT2 (REWRITE) (EQUAL (IDIV I (FIX-INT J)) (IDIV I J)) ((ENABLE INTEGERP IDIV FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IMOD-FIX-INT1 (REWRITE) (EQUAL (IMOD (FIX-INT I) J) (IMOD I J)) ((ENABLE IMOD FIX-INT-FIX-INT IDIV-FIX-INT1) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IMOD-FIX-INT2 (REWRITE) (EQUAL (IMOD I (FIX-INT J)) (IMOD I J)) ((ENABLE IMOD ITIMES-FIX-INT1 IDIV-FIX-INT2) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IQUO-FIX-INT1 (REWRITE) (EQUAL (IQUO (FIX-INT I) J) (IQUO I J)) ((ENABLE INTEGERP IQUO FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IQUO-FIX-INT2 (REWRITE) (EQUAL (IQUO I (FIX-INT J)) (IQUO I J)) ((ENABLE INTEGERP IQUO FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IREM-FIX-INT1 (REWRITE) (EQUAL (IREM (FIX-INT I) J) (IREM I J)) ((ENABLE IREM FIX-INT-FIX-INT IQUO-FIX-INT1) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA IREM-FIX-INT2 (REWRITE) (EQUAL (IREM I (FIX-INT J)) (IREM I J)) ((ENABLE IREM ITIMES-FIX-INT1 IQUO-FIX-INT2) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IQUOTIENT (REWRITE) (EQUAL (FIX-INT (IQUOTIENT I J)) (IQUOTIENT I J)) ((ENABLE INTEGERP IQUOTIENT FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IREMAINDER (REWRITE) (EQUAL (FIX-INT (IREMAINDER I J)) (IREMAINDER I J)) ((ENABLE IREMAINDER FIX-INT-IDIFFERENCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IDIV (REWRITE) (EQUAL (FIX-INT (IDIV I J)) (IDIV I J)) ((ENABLE INTEGERP IDIV FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IMOD (REWRITE) (EQUAL (FIX-INT (IMOD I J)) (IMOD I J)) ((ENABLE IMOD FIX-INT-IDIFFERENCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IQUO (REWRITE) (EQUAL (FIX-INT (IQUO I J)) (IQUO I J)) ((ENABLE INTEGERP IQUO FIX-INT) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA FIX-INT-IREM (REWRITE) (EQUAL (FIX-INT (IREM I J)) (IREM I J)) ((ENABLE IREM FIX-INT-IDIFFERENCE) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (TOGGLE IQUOTIENT-OFF IQUOTIENT T) (TOGGLE IREMAINDER-OFF IREMAINDER T) (TOGGLE IDIV-OFF IDIV T) (TOGGLE IMOD-OFF IMOD T) (TOGGLE IQUO-OFF IQUO T) (TOGGLE IREM-OFF IREM T) (DEFN ITIMES-FRINGE (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'ITIMES) (APPEND (ITIMES-FRINGE (CADR X)) (ITIMES-FRINGE (CADDR X))) (LIST X)) (LIST X))) (DEFN ITIMES-TREE-REC (L) (IF (NLISTP (CDR L)) (CAR L) (LIST 'ITIMES (CAR L) (ITIMES-TREE-REC (CDR L))))) (DEFN ITIMES-TREE (L) (IF (LISTP L) (IF (LISTP (CDR L)) (ITIMES-TREE-REC L) (LIST 'FIX-INT (CAR L))) ''1)) (DEFN ITIMES-LIST (X) (IF (LISTP X) (ITIMES (CAR X) (ITIMES-LIST (CDR X))) 1)) (PROVE-LEMMA INTEGERP-ITIMES-LIST (REWRITE) (INTEGERP (ITIMES-LIST X))) (PROVE-LEMMA EVAL$-ITIMES-TREE-REC (REWRITE) (IMPLIES (LISTP X) (EQUAL (EVAL$ T (ITIMES-TREE-REC X) A) (IF (LISTP (CDR X)) (ITIMES-LIST (EVAL$ 'LIST X A)) (EVAL$ T (CAR X) A))))) (PROVE-LEMMA EVAL$-ITIMES-TREE (REWRITE) (EQUAL (EVAL$ T (ITIMES-TREE X) A) (ITIMES-LIST (EVAL$ 'LIST X A)))) (TOGGLE ITIMES-TREE-OFF ITIMES-TREE T) (DEFN MAKE-CANCEL-ITIMES-EQUALITY (X Y IN-BOTH) (LIST 'IF (CONS 'EQUAL (CONS (ITIMES-TREE IN-BOTH) '('0))) (LIST 'QUOTE T) (LIST 'EQUAL (ITIMES-TREE (BAGDIFF X IN-BOTH)) (ITIMES-TREE (BAGDIFF Y IN-BOTH))))) (DEFN CANCEL-ITIMES (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'EQUAL) (COND ((LISTP (CADR X)) (COND ((EQUAL (CAADR X) 'ITIMES) (COND ((LISTP (CADDR X)) (COND ((EQUAL (CAADDR X) 'ITIMES) (IF (LISTP (BAGINT (ITIMES-FRINGE (CADR X)) (ITIMES-FRINGE (CADDR X)))) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FRINGE (CADR X)) (ITIMES-FRINGE (CADDR X)) (BAGINT (ITIMES-FRINGE (CADR X)) (ITIMES-FRINGE (CADDR X)))) X)) ((MEMBER (CADDR X) (ITIMES-FRINGE (CADR X))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FRINGE (CADR X)) (LIST (CADDR X)) (LIST (CADDR X))) (LIST 'QUOTE F))) (T X))) ((MEMBER (CADDR X) (ITIMES-FRINGE (CADR X))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FRINGE (CADR X)) (LIST (CADDR X)) (LIST (CADDR X))) (LIST 'QUOTE F))) (T X))) ((LISTP (CADDR X)) (IF (EQUAL (CAADDR X) 'ITIMES) (IF (MEMBER (CADR X) (ITIMES-FRINGE (CADDR X))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (LIST (CADR X)) (ITIMES-FRINGE (CADDR X)) (LIST (CADR X))) (LIST 'QUOTE F)) X) X)) (T X))) ((LISTP (CADDR X)) (IF (EQUAL (CAADDR X) 'ITIMES) (IF (MEMBER (CADR X) (ITIMES-FRINGE (CADDR X))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (LIST (CADR X)) (ITIMES-FRINGE (CADDR X)) (LIST (CADR X))) (LIST 'QUOTE F)) X) X)) (T X)) X) X)) (PROVE-LEMMA ITIMES-LIST-APPEND (REWRITE) (EQUAL (ITIMES-LIST (APPEND X Y)) (ITIMES (ITIMES-LIST X) (ITIMES-LIST Y)))) (PROVE-LEMMA ITIMES-LIST-EVAL$-FRINGE (REWRITE) (EQUAL (ITIMES-LIST (EVAL$ 'LIST (ITIMES-FRINGE X) A)) (FIX-INT (EVAL$ T X A))) ((INDUCT (ITIMES-FRINGE X)))) (PROVE-LEMMA INTEGERP-EVAL$-ITIMES (REWRITE) (IMPLIES (EQUAL (CAR X) 'ITIMES) (INTEGERP (EVAL$ T X A)))) (PROVE-LEMMA NOT-INTEGERP-IMPLIES-NOT-EQUAL-ITIMES (REWRITE) (IMPLIES (NOT (INTEGERP A)) (EQUAL (EQUAL A (ITIMES B C)) F)) ((USE (INTEGERP-ITIMES (X B) (Y C))) (ENABLE INTEGERP) (DO-NOT-INDUCT T) (ENABLE-THEORY GROUND-ZERO) (DISABLE-THEORY T))) (PROVE-LEMMA ITIMES-LIST-EVAL$-DELETE (REWRITE) (IMPLIES (MEMBER Z Y) (EQUAL (ITIMES-LIST (EVAL$ 'LIST Y A)) (ITIMES (EVAL$ T Z A) (ITIMES-LIST (EVAL$ 'LIST (DELETE Z Y) A)))))) (PROVE-LEMMA ITIMES-LIST-BAGDIFF (REWRITE) (IMPLIES (SUBBAGP X Y) (EQUAL (ITIMES-LIST (EVAL$ 'LIST Y A)) (ITIMES (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF Y X) A)) (ITIMES-LIST (EVAL$ 'LIST X A))))) ((INDUCT (BAGDIFF Y X)))) (PROVE-LEMMA EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE (REWRITE) (IMPLIES (AND (MEMBER C Y) (NOT (EQUAL (FIX-INT (EVAL$ T C A)) 0))) (EQUAL (EQUAL X (ITIMES-LIST (EVAL$ 'LIST (DELETE C Y) A))) (AND (INTEGERP X) (EQUAL (ITIMES X (EVAL$ T C A)) (ITIMES-LIST (EVAL$ 'LIST Y A))))))) (TOGGLE ITIMES-LIST-EVAL$-DELETE-OFF ITIMES-LIST-EVAL$-DELETE T) (PROVE-LEMMA MEMBER-APPEND (REWRITE) (EQUAL (MEMBER A (APPEND X Y)) (OR (MEMBER A X) (MEMBER A Y)))) (PROVE-LEMMA MEMBER-IZEROP-ITIMES-FRINGE (REWRITE) (IMPLIES (AND (MEMBER Z (ITIMES-FRINGE X)) (EQUAL (FIX-INT (EVAL$ T Z A)) 0)) (EQUAL (FIX-INT (EVAL$ T X A)) 0)) ((INDUCT (ITIMES-FRINGE X)))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-HACK-1 (REWRITE) (IMPLIES (AND (MEMBER W (ITIMES-FRINGE (CONS 'ITIMES X1))) (EQUAL (FIX-INT (EVAL$ T W A)) 0) (NOT (EQUAL (FIX-INT (EVAL$ T (CAR X1) A)) 0))) (EQUAL (FIX-INT (EVAL$ T (CADR X1) A)) 0))) (TOGGLE EVAL$-EQUAL-ON EVAL$-EQUAL NIL) (PROVE-LEMMA EVAL$-MAKE-CANCEL-ITIMES-EQUALITY (REWRITE) (EQUAL (EVAL$ T (MAKE-CANCEL-ITIMES-EQUALITY X Y IN-BOTH) A) (IF (EVAL$ T (CONS 'EQUAL (CONS (ITIMES-TREE IN-BOTH) '('0))) A) T (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF X IN-BOTH) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF Y IN-BOTH) A)))))) (TOGGLE MAKE-CANCEL-ITIMES-EQUALITY-OFF MAKE-CANCEL-ITIMES-EQUALITY T) (PROVE-LEMMA EVAL$-MAKE-CANCEL-ITIMES-EQUALITY-1 (REWRITE) (EQUAL (EVAL$ T (MAKE-CANCEL-ITIMES-EQUALITY (LIST X) Y (LIST X)) A) (IF (EQUAL (FIX-INT (EVAL$ T X A)) 0) T (EQUAL 1 (ITIMES-LIST (EVAL$ 'LIST (DELETE X Y) A)))))) (PROVE-LEMMA EQUAL-FIX-INT (REWRITE) (EQUAL (EQUAL (FIX-INT X) X) (INTEGERP X)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA EVAL$-MAKE-CANCEL-ITIMES-EQUALITY-2 (REWRITE) (EQUAL (EVAL$ T (MAKE-CANCEL-ITIMES-EQUALITY X (LIST Y) (LIST Y)) A) (IF (EQUAL (FIX-INT (EVAL$ T Y A)) 0) T (EQUAL 1 (ITIMES-LIST (EVAL$ 'LIST (DELETE Y X) A)))))) (PROVE-LEMMA EVAL$-EQUAL-ITIMES-TREE-ITIMES-FRINGE-0 (REWRITE) (IMPLIES (AND (EVAL$ T (CONS 'EQUAL (CONS (ITIMES-TREE (ITIMES-FRINGE X)) '('0))) A) (EQUAL (CAR X) 'ITIMES)) (EQUAL (EVAL$ T X A) 0))) (PROVE-LEMMA IZEROP-EVAL-OF-MEMBER-IMPLIES-ITIMES-LIST-0 (REWRITE) (IMPLIES (AND (MEMBER Z Y) (EQUAL (FIX-INT (EVAL$ T Z A)) 0)) (EQUAL (ITIMES-LIST (EVAL$ 'LIST Y A)) 0))) (DEFN SUBSETP (X Y) (COND ((NLISTP X) T) ((MEMBER (CAR X) Y) (SUBSETP (CDR X) Y)) (T F))) (PROVE-LEMMA SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 (REWRITE) (IMPLIES (AND (SUBSETP X Y) (EQUAL (ITIMES-LIST (EVAL$ 'LIST X A)) 0)) (EQUAL (ITIMES-LIST (EVAL$ 'LIST Y A)) 0))) (PROVE-LEMMA SUBBAGP-SUBSETP (REWRITE) (IMPLIES (SUBBAGP X Y) (SUBSETP X Y))) (PROVE-LEMMA EQUAL-0-ITIMES-LIST-EVAL$-BAGINT-1 (REWRITE) (IMPLIES (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGINT X Y) A)) 0) (EQUAL (ITIMES-LIST (EVAL$ 'LIST X A)) 0)) ((USE (SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 (X (BAGINT X Y)) (Y X))) (DISABLE SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0))) (PROVE-LEMMA EQUAL-0-ITIMES-LIST-EVAL$-BAGINT-2 (REWRITE) (IMPLIES (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGINT X Y) A)) 0) (EQUAL (ITIMES-LIST (EVAL$ 'LIST Y A)) 0)) ((USE (SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 (X (BAGINT X Y)) (Y Y))) (DISABLE SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-HACK-2 (REWRITE) (IMPLIES (AND (LISTP U) (EQUAL (CAR U) 'ITIMES) (LISTP V) (EQUAL (CAR V) 'ITIMES) (NOT (EQUAL (EVAL$ T U A) (EVAL$ T V A)))) (NOT (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF (ITIMES-FRINGE U) (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF (ITIMES-FRINGE V) (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) A))))) ((USE (ITIMES-LIST-BAGDIFF (Y (ITIMES-FRINGE U)) (X (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) (A A)) (ITIMES-LIST-BAGDIFF (Y (ITIMES-FRINGE V)) (X (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) (A A))))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-HACK-3-LEMMA (REWRITE) (IMPLIES (AND (EQUAL U (ITIMES A B)) (NOT (EQUAL (FIX-INT A) 0))) (EQUAL (EQUAL U (ITIMES A C)) (EQUAL (FIX-INT B) (FIX-INT C))))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-HACK-3 (REWRITE) (IMPLIES (AND (LISTP U) (EQUAL (CAR U) 'ITIMES) (LISTP V) (EQUAL (CAR V) 'ITIMES) (EQUAL (EVAL$ T U A) (EVAL$ T V A)) (NOT (EVAL$ T (CONS 'EQUAL (CONS (ITIMES-TREE (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) '('0))) A))) (EQUAL (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF (ITIMES-FRINGE U) (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF (ITIMES-FRINGE V) (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) A))) T)) ((USE (ITIMES-LIST-BAGDIFF (Y (ITIMES-FRINGE U)) (X (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) (A A)) (ITIMES-LIST-BAGDIFF (Y (ITIMES-FRINGE V)) (X (BAGINT (ITIMES-FRINGE U) (ITIMES-FRINGE V))) (A A))))) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-HACK-3-LEMMA-OFF CORRECTNESS-OF-CANCEL-ITIMES-HACK-3-LEMMA T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES ((META EQUAL)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-ITIMES X) A)) ((DO-NOT-INDUCT T))) (DEFN ITIMES-TREE-NO-FIX-INT (L) (IF (LISTP L) (ITIMES-TREE-REC L) ''1)) (PROVE-LEMMA EVAL$-ITIMES-TREE-NO-FIX-INT-1 (REWRITE) (EQUAL (ILESSP (EVAL$ T (ITIMES-TREE-NO-FIX-INT X) A) Y) (ILESSP (EVAL$ T (ITIMES-TREE X) A) Y))) (PROVE-LEMMA EVAL$-ITIMES-TREE-NO-FIX-INT-2 (REWRITE) (EQUAL (ILESSP Y (EVAL$ T (ITIMES-TREE-NO-FIX-INT X) A)) (ILESSP Y (EVAL$ T (ITIMES-TREE X) A)))) (TOGGLE ITIMES-TREE-NO-FIX-INT-OFF ITIMES-TREE-NO-FIX-INT T) (DEFN MAKE-CANCEL-ITIMES-INEQUALITY (X Y IN-BOTH) (LIST 'IF (CONS 'ILESSP (CONS (ITIMES-TREE-NO-FIX-INT IN-BOTH) '('0))) (LIST 'ILESSP (ITIMES-TREE-NO-FIX-INT (BAGDIFF Y IN-BOTH)) (ITIMES-TREE-NO-FIX-INT (BAGDIFF X IN-BOTH))) (CONS 'IF (CONS (LIST 'ILESSP ''0 (ITIMES-TREE-NO-FIX-INT IN-BOTH)) (CONS (LIST 'ILESSP (ITIMES-TREE-NO-FIX-INT (BAGDIFF X IN-BOTH)) (ITIMES-TREE-NO-FIX-INT (BAGDIFF Y IN-BOTH))) '((FALSE))))))) (DEFN CANCEL-ITIMES-ILESSP (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'ILESSP) (IF (LISTP (BAGINT (ITIMES-FRINGE (CADR X)) (ITIMES-FRINGE (CADDR X)))) (MAKE-CANCEL-ITIMES-INEQUALITY (ITIMES-FRINGE (CADR X)) (ITIMES-FRINGE (CADDR X)) (BAGINT (ITIMES-FRINGE (CADR X)) (ITIMES-FRINGE (CADDR X)))) X) X) X)) (PROVE-LEMMA EVAL$-MAKE-CANCEL-ITIMES-INEQUALITY (REWRITE) (EQUAL (EVAL$ T (MAKE-CANCEL-ITIMES-INEQUALITY X Y IN-BOTH) A) (COND ((EVAL$ T (CONS 'ILESSP (CONS (ITIMES-TREE-NO-FIX-INT IN-BOTH) '('0))) A) (ILESSP (EVAL$ T (ITIMES-TREE-NO-FIX-INT (BAGDIFF Y IN-BOTH)) A) (EVAL$ T (ITIMES-TREE-NO-FIX-INT (BAGDIFF X IN-BOTH)) A))) ((EVAL$ T (LIST 'ILESSP ''0 (ITIMES-TREE-NO-FIX-INT IN-BOTH)) A) (ILESSP (EVAL$ T (ITIMES-TREE-NO-FIX-INT (BAGDIFF X IN-BOTH)) A) (EVAL$ T (ITIMES-TREE-NO-FIX-INT (BAGDIFF Y IN-BOTH)) A))) (T F)))) (TOGGLE MAKE-CANCEL-ITIMES-INEQUALITY-OFF MAKE-CANCEL-ITIMES-INEQUALITY T) (PROVE-LEMMA LISTP-BAGINT-WITH-SINGLETON-IMPLIES-MEMBER (REWRITE) (IMPLIES (LISTP (BAGINT Y (LIST Z))) (MEMBER Z Y))) (PROVE-LEMMA ITIMES-LIST-EVAL$-LIST-0 (REWRITE) (IMPLIES (MEMBER 0 X) (EQUAL (ITIMES-LIST (EVAL$ 'LIST X A)) 0))) (PROVE-LEMMA ILESSP-ITIMES-RIGHT-POSITIVE NIL (IMPLIES (ILESSP 0 X) (EQUAL (ILESSP Y Z) (ILESSP (ITIMES Y X) (ITIMES Z X)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-1 (REWRITE) (IMPLIES (AND (SUBBAGP BAG X) (SUBBAGP BAG Y) (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST BAG A)))) (EQUAL (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF X BAG) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF Y BAG) A))) (ILESSP (ITIMES-LIST (EVAL$ 'LIST X A)) (ITIMES-LIST (EVAL$ 'LIST Y A))))) ((USE (ILESSP-ITIMES-RIGHT-POSITIVE (X (ITIMES-LIST (EVAL$ 'LIST BAG A))) (Y (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF X BAG) A))) (Z (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF Y BAG) A)))) (ITIMES-LIST-BAGDIFF (Y X) (X BAG) (A A)) (ITIMES-LIST-BAGDIFF (Y Y) (X BAG) (A A))))) (PROVE-LEMMA LISTP-BAGINT-WITH-SINGLETON-MEMBER (REWRITE) (EQUAL (LISTP (BAGINT Y (LIST Z))) (MEMBER Z Y))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-2-LEMMA (REWRITE) (IMPLIES (MEMBER 0 (ITIMES-FRINGE W)) (EQUAL (EVAL$ T W A) 0)) ((EXPAND (ITIMES-FRINGE W)))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-2 (REWRITE) (IMPLIES (MEMBER 0 (ITIMES-FRINGE W)) (NOT (ILESSP (EVAL$ T W A) 0)))) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-2-LEMMA-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-2-LEMMA T) (PROVE-LEMMA ILESSP-TRICHOTOMY (REWRITE) (IMPLIES (NOT (ILESSP X Y)) (EQUAL (ILESSP Y X) (NOT (EQUAL (FIX-INT X) (FIX-INT Y))))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-1 NIL (IMPLIES (AND (EQUAL 0 (ITIMES-LIST (EVAL$ 'LIST BAG A))) (SUBSETP BAG Z)) (EQUAL (ITIMES-LIST (EVAL$ 'LIST Z A)) 0))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-2 NIL (IMPLIES (AND (EQUAL 0 (ITIMES-LIST (EVAL$ 'LIST BAG A))) (SUBSETP BAG (ITIMES-FRINGE X))) (EQUAL (FIX-INT (EVAL$ T X A)) 0)) ((USE (CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-1 (Z (ITIMES-FRINGE X)))))) (PROVE-LEMMA SAME-FIX-INT-IMPLIES-NOT-ILESSP (REWRITE) (IMPLIES (EQUAL (FIX-INT X) (FIX-INT Y)) (NOT (ILESSP X Y))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3 (REWRITE) (IMPLIES (AND (NOT (ILESSP (ITIMES-LIST (EVAL$ 'LIST BAG A)) 0)) (NOT (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST BAG A)))) (SUBBAGP BAG (ITIMES-FRINGE W)) (SUBBAGP BAG (ITIMES-FRINGE V))) (NOT (ILESSP (EVAL$ T W A) (EVAL$ T V A)))) ((USE (CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-2 (X W) (BAG BAG)) (CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-2 (X V) (BAG BAG))))) (PROVE-LEMMA ILESSP-ITIMES-RIGHT-NEGATIVE NIL (IMPLIES (ILESSP X 0) (EQUAL (ILESSP Y Z) (ILESSP (ITIMES Z X) (ITIMES Y X)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-4 (REWRITE) (IMPLIES (AND (SUBBAGP BAG X) (SUBBAGP BAG Y) (ILESSP (ITIMES-LIST (EVAL$ 'LIST BAG A)) 0)) (EQUAL (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF X BAG) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF Y BAG) A))) (ILESSP (ITIMES-LIST (EVAL$ 'LIST Y A)) (ITIMES-LIST (EVAL$ 'LIST X A))))) ((USE (ILESSP-ITIMES-RIGHT-NEGATIVE (X (ITIMES-LIST (EVAL$ 'LIST BAG A))) (Y (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF X BAG) A))) (Z (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF Y BAG) A)))) (ITIMES-LIST-BAGDIFF (Y X) (X BAG) (A A)) (ITIMES-LIST-BAGDIFF (Y Y) (X BAG) (A A))))) (TOGGLE ILESSP-TRICHOTOMY-OFF ILESSP-TRICHOTOMY T) (TOGGLE SAME-FIX-INT-IMPLIES-NOT-ILESSP-OFF SAME-FIX-INT-IMPLIES-NOT-ILESSP T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP ((META ILESSP)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-ITIMES-ILESSP X) A)) ((DO-NOT-INDUCT T))) (PROVE-LEMMA ILESSP-STRICT (REWRITE) (IMPLIES (ILESSP X Y) (NOT (ILESSP Y X))) ((ENABLE-THEORY INTEGER-DEFNS))) (TOGGLE EVAL$-CANCEL-IPLUS-OFF EVAL$-CANCEL-IPLUS T) (TOGGLE EVAL$-IPLUS-OFF EVAL$-IPLUS T) (TOGGLE LESSP-COUNT-LISTP-CDR-OFF LESSP-COUNT-LISTP-CDR T) (TOGGLE EVAL$-IPLUS-TREE-REC-OFF EVAL$-IPLUS-TREE-REC T) (TOGGLE EVAL$-IPLUS-TREE-OFF EVAL$-IPLUS-TREE T) (TOGGLE IPLUS-LIST-EVAL$-FRINGE-OFF IPLUS-LIST-EVAL$-FRINGE T) (TOGGLE EVAL$-IPLUS-LIST-BAGDIFF-OFF EVAL$-IPLUS-LIST-BAGDIFF T) (TOGGLE LESSP-DIFFERENCE-PLUS-ARG1-OFF LESSP-DIFFERENCE-PLUS-ARG1 T) (TOGGLE LESSP-DIFFERENCE-PLUS-ARG1-COMMUTED-OFF LESSP-DIFFERENCE-PLUS-ARG1-COMMUTED T) (TOGGLE CORRECTNESS-OF-CANCEL-IPLUS-ILESSP-LEMMA-OFF CORRECTNESS-OF-CANCEL-IPLUS-ILESSP-LEMMA T) (TOGGLE EVAL$-ILESSP-IPLUS-TREE-NO-FIX-INT-OFF EVAL$-ILESSP-IPLUS-TREE-NO-FIX-INT T) (TOGGLE MAKE-CANCEL-IPLUS-INEQUALITY-SIMPLIFIER-OFF MAKE-CANCEL-IPLUS-INEQUALITY-SIMPLIFIER T) (TOGGLE QUOTIENT-DIFFERENCE-LESSP-ARG2-OFF QUOTIENT-DIFFERENCE-LESSP-ARG2 T) (TOGGLE EVAL$-ITIMES-TREE-REC-OFF EVAL$-ITIMES-TREE-REC T) (TOGGLE EVAL$-ITIMES-TREE-OFF EVAL$-ITIMES-TREE T) (TOGGLE ITIMES-LIST-EVAL$-FRINGE-OFF ITIMES-LIST-EVAL$-FRINGE T) (TOGGLE INTEGERP-EVAL$-ITIMES-OFF INTEGERP-EVAL$-ITIMES T) (TOGGLE ITIMES-LIST-BAGDIFF-OFF ITIMES-LIST-BAGDIFF T) (TOGGLE EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE-OFF EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE T) (TOGGLE MEMBER-IZEROP-ITIMES-FRINGE-OFF MEMBER-IZEROP-ITIMES-FRINGE T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-HACK-1-OFF CORRECTNESS-OF-CANCEL-ITIMES-HACK-1 T) (TOGGLE EVAL$-MAKE-CANCEL-ITIMES-EQUALITY-OFF EVAL$-MAKE-CANCEL-ITIMES-EQUALITY T) (TOGGLE EVAL$-MAKE-CANCEL-ITIMES-EQUALITY-1-OFF EVAL$-MAKE-CANCEL-ITIMES-EQUALITY-1 T) (TOGGLE EVAL$-MAKE-CANCEL-ITIMES-EQUALITY-2-OFF EVAL$-MAKE-CANCEL-ITIMES-EQUALITY-2 T) (TOGGLE EVAL$-EQUAL-ITIMES-TREE-ITIMES-FRINGE-0-OFF EVAL$-EQUAL-ITIMES-TREE-ITIMES-FRINGE-0 T) (TOGGLE IZEROP-EVAL-OF-MEMBER-IMPLIES-ITIMES-LIST-0-OFF IZEROP-EVAL-OF-MEMBER-IMPLIES-ITIMES-LIST-0 T) (TOGGLE SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0-OFF SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 T) (TOGGLE EQUAL-0-ITIMES-LIST-EVAL$-BAGINT-1-OFF EQUAL-0-ITIMES-LIST-EVAL$-BAGINT-1 T) (TOGGLE EQUAL-0-ITIMES-LIST-EVAL$-BAGINT-2-OFF EQUAL-0-ITIMES-LIST-EVAL$-BAGINT-2 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-HACK-2-OFF CORRECTNESS-OF-CANCEL-ITIMES-HACK-2 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-HACK-3-LEMMA-OFF1 CORRECTNESS-OF-CANCEL-ITIMES-HACK-3-LEMMA T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-HACK-3-OFF CORRECTNESS-OF-CANCEL-ITIMES-HACK-3 T) (TOGGLE EVAL$-ITIMES-TREE-NO-FIX-INT-1-OFF EVAL$-ITIMES-TREE-NO-FIX-INT-1 T) (TOGGLE EVAL$-ITIMES-TREE-NO-FIX-INT-2-OFF EVAL$-ITIMES-TREE-NO-FIX-INT-2 T) (TOGGLE EVAL$-MAKE-CANCEL-ITIMES-INEQUALITY-OFF EVAL$-MAKE-CANCEL-ITIMES-INEQUALITY T) (TOGGLE LISTP-BAGINT-WITH-SINGLETON-IMPLIES-MEMBER-OFF LISTP-BAGINT-WITH-SINGLETON-IMPLIES-MEMBER T) (TOGGLE ITIMES-LIST-EVAL$-LIST-0-OFF ITIMES-LIST-EVAL$-LIST-0 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-1-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-1 T) (TOGGLE LISTP-BAGINT-WITH-SINGLETON-MEMBER-OFF LISTP-BAGINT-WITH-SINGLETON-MEMBER T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-2-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-2 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-1-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-1 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-2-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-LEMMA-2 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-3 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-4-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-HACK-4 T) (DEFN ITIMES-TREE-INEG (L) (IF (LISTP L) (IF (EQUAL (CAR L) ''-1) (IF (LISTP (CDR L)) (LIST 'INEG (ITIMES-TREE-REC (CDR L))) (CAR L)) (ITIMES-TREE-REC L)) ''1)) (DEFN ITIMES-FACTORS (X) (IF (LISTP X) (CASE (CAR X) (ITIMES (APPEND (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (IPLUS (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (CONS (LIST 'IPLUS (ITIMES-TREE-INEG (BAGDIFF (ITIMES-FACTORS (CADR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X))))) (ITIMES-TREE-INEG (BAGDIFF (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))))) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST X))) (INEG (CONS ''-1 (ITIMES-FACTORS (CADR X)))) (OTHERWISE (LIST X))) (LIST X))) (PROVE-LEMMA ITIMES--1 (REWRITE) (EQUAL (ITIMES -1 X) (INEG X)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA EQUAL-INEG-INEG (REWRITE) (EQUAL (EQUAL (INEG X) (INEG Y)) (EQUAL (FIX-INT X) (FIX-INT Y))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ILESSP-INEG-INEG (REWRITE) (EQUAL (ILESSP (INEG X) (INEG Y)) (ILESSP Y X)) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA FIX-INT-EVAL$-ITIMES-TREE-REC (REWRITE) (IMPLIES (LISTP X) (EQUAL (FIX-INT (EVAL$ T (ITIMES-TREE-REC X) A)) (ITIMES-LIST (EVAL$ 'LIST X A)))) ((ENABLE EVAL$-ITIMES-TREE-REC))) (PROVE-LEMMA EVAL$-ITIMES-TREE-INEG (REWRITE) (EQUAL (FIX-INT (EVAL$ T (ITIMES-TREE-INEG X) A)) (ITIMES-LIST (EVAL$ 'LIST X A))) ((ENABLE EVAL$-ITIMES-TREE-REC))) (PROVE-LEMMA INEG-EVAL$-ITIMES-TREE-INEG (REWRITE) (EQUAL (INEG (EVAL$ T (ITIMES-TREE-INEG X) A)) (INEG (ITIMES-LIST (EVAL$ 'LIST X A)))) ((USE (EVAL$-ITIMES-TREE-INEG)))) (PROVE-LEMMA IPLUS-EVAL$-ITIMES-TREE-INEG (REWRITE) (AND (EQUAL (IPLUS (EVAL$ T (ITIMES-TREE-INEG X) A) Y) (IPLUS (ITIMES-LIST (EVAL$ 'LIST X A)) Y)) (EQUAL (IPLUS Y (EVAL$ T (ITIMES-TREE-INEG X) A)) (IPLUS Y (ITIMES-LIST (EVAL$ 'LIST X A))))) ((USE (EVAL$-ITIMES-TREE-INEG)))) (PROVE-LEMMA ITIMES-EVAL$-ITIMES-TREE-INEG (REWRITE) (AND (EQUAL (ITIMES (EVAL$ T (ITIMES-TREE-INEG X) A) Y) (ITIMES (ITIMES-LIST (EVAL$ 'LIST X A)) Y)) (EQUAL (ITIMES Y (EVAL$ T (ITIMES-TREE-INEG X) A)) (ITIMES Y (ITIMES-LIST (EVAL$ 'LIST X A))))) ((USE (EVAL$-ITIMES-TREE-INEG)))) (TOGGLE ITIMES-TREE-INEG-OFF ITIMES-TREE-INEG T) (DEFN IPLUS-OR-ITIMES-TERM (X) (IF (LISTP X) (CASE (CAR X) (IPLUS T) (ITIMES T) (INEG (IF (LISTP (CADR X)) (EQUAL (CAADR X) 'ITIMES) F)) (OTHERWISE F)) F)) (DEFN CANCEL-ITIMES-FACTORS (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'EQUAL)) (COND ((IPLUS-OR-ITIMES-TERM (CADR X)) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (IF (IPLUS-OR-ITIMES-TERM (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F))) X)) ((IPLUS-OR-ITIMES-TERM (CADDR X)) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (T X)) X)) (DEFN CANCEL-ITIMES-FACTORS-EXPANDED (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'EQUAL) (COND ((LISTP (CADR X)) (CASE (CAADR X) (IPLUS (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (IF (LISTP (CADDR X)) (CASE (CAADDR X) (IPLUS (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X))))) (ITIMES (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X))))) (INEG (IF (LISTP (CADADDR X)) (IF (EQUAL (CAADADDR X) 'ITIMES) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)))) (OTHERWISE (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F))) X)) (ITIMES (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (IF (LISTP (CADDR X)) (CASE (CAADDR X) (IPLUS (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X))))) (ITIMES (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X))))) (INEG (IF (LISTP (CADADDR X)) (IF (EQUAL (CAADADDR X) 'ITIMES) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)))) (OTHERWISE (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F))) X)) (INEG (COND ((LISTP (CADADR X)) (COND ((EQUAL (CAADADR X) 'ITIMES) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (IF (LISTP (CADDR X)) (CASE (CAADDR X) (IPLUS (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X))))) (ITIMES (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X))))) (INEG (IF (LISTP (CADADDR X)) (IF (EQUAL (CAADADDR X) 'ITIMES) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)))) (OTHERWISE (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F))) X)) ((LISTP (CADDR X)) (CASE (CAADDR X) (IPLUS (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (ITIMES (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (INEG (IF (LISTP (CADADDR X)) (IF (EQUAL (CAADADDR X) 'ITIMES) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X) X) X)) (OTHERWISE X))) (T X))) ((LISTP (CADDR X)) (CASE (CAADDR X) (IPLUS (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (ITIMES (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (INEG (IF (LISTP (CADADDR X)) (IF (EQUAL (CAADADDR X) 'ITIMES) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X) X) X)) (OTHERWISE X))) (T X))) (OTHERWISE (IF (LISTP (CADDR X)) (CASE (CAADDR X) (IPLUS (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (ITIMES (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (INEG (IF (LISTP (CADADDR X)) (IF (EQUAL (CAADADDR X) 'ITIMES) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X) X) X)) (OTHERWISE X)) X)))) ((LISTP (CADDR X)) (CASE (CAADDR X) (IPLUS (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (ITIMES (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X)) (INEG (IF (LISTP (CADADDR X)) (IF (EQUAL (CAADADDR X) 'ITIMES) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'IF (LIST 'INTEGERP (CADR X)) (MAKE-CANCEL-ITIMES-EQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (LIST 'QUOTE F)) X) X) X)) (OTHERWISE X))) (T X)) X) X)) (PROVE-LEMMA CANCEL-ITIMES-FACTORS-EXPANDED-CANCEL-ITIMES-FACTORS (REWRITE) (EQUAL (CANCEL-ITIMES-FACTORS-EXPANDED X) (CANCEL-ITIMES-FACTORS X)) ((DISABLE-THEORY T) (ENABLE-THEORY GROUND-ZERO) (ENABLE IPLUS-OR-ITIMES-TERM CANCEL-ITIMES-FACTORS CANCEL-ITIMES-FACTORS-EXPANDED))) (TOGGLE CANCEL-ITIMES-FACTORS-EXPANDED-OFF CANCEL-ITIMES-FACTORS-EXPANDED T) (TOGGLE IPLUS-OR-ITIMES-TERM-OFF IPLUS-OR-ITIMES-TERM T) (PROVE-LEMMA EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE-NEW-1 (REWRITE) (IMPLIES (NOT (EQUAL (FIX-INT (EVAL$ T ELT A)) 0)) (EQUAL (EQUAL X (ITIMES-LIST (EVAL$ 'LIST (DELETE ELT BAG) A))) (IF (MEMBER ELT BAG) (AND (INTEGERP X) (EQUAL (ITIMES X (EVAL$ T ELT A)) (ITIMES-LIST (EVAL$ 'LIST BAG A)))) (EQUAL X (ITIMES-LIST (EVAL$ 'LIST BAG A)))))) ((ENABLE EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE))) (PROVE-LEMMA EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE-NEW-2 (REWRITE) (IMPLIES (NOT (EQUAL (FIX-INT (EVAL$ T ELT A)) 0)) (EQUAL (EQUAL (ITIMES-LIST (EVAL$ 'LIST (DELETE ELT BAG) A)) X) (IF (MEMBER ELT BAG) (AND (INTEGERP X) (EQUAL (ITIMES X (EVAL$ T ELT A)) (ITIMES-LIST (EVAL$ 'LIST BAG A)))) (EQUAL X (ITIMES-LIST (EVAL$ 'LIST BAG A))))))) (PROVE-LEMMA ITIMES-ITIMES-LIST-EVAL$-LIST-DELETE (REWRITE) (IMPLIES (MEMBER X BAG) (EQUAL (ITIMES (EVAL$ T X A) (ITIMES-LIST (EVAL$ 'LIST (DELETE X BAG) A))) (ITIMES-LIST (EVAL$ 'LIST BAG A))))) (PROVE-LEMMA EQUAL-ITIMES-LIST-EVAL$-LIST-BAGDIFF (REWRITE) (IMPLIES (AND (SUBBAGP IN-BOTH BAG1) (SUBBAGP IN-BOTH BAG2) (NOT (EQUAL (ITIMES-LIST (EVAL$ 'LIST IN-BOTH A)) 0))) (EQUAL (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG1 IN-BOTH) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG2 IN-BOTH) A))) (EQUAL (ITIMES-LIST (EVAL$ 'LIST BAG1 A)) (ITIMES-LIST (EVAL$ 'LIST BAG2 A)))))) (PROVE-LEMMA MEMBERSHIP-OF-0-IMPLIES-ITIMES-LIST-IS-0 (REWRITE) (IMPLIES (MEMBER 0 X) (EQUAL (ITIMES-LIST X) 0))) (PROVE-LEMMA MEMBER-0-EVAL$-LIST (REWRITE) (IMPLIES (MEMBER 0 X) (MEMBER 0 (EVAL$ 'LIST X A)))) (PROVE-LEMMA ITIMES-LIST-EVAL$-FACTORS-LEMMA (REWRITE) (EQUAL (ITIMES (ITIMES-LIST (EVAL$ 'LIST (BAGINT BAG1 BAG2) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG2 (BAGINT BAG1 BAG2)) A))) (ITIMES-LIST (EVAL$ 'LIST BAG2 A))) ((USE (ITIMES-LIST-BAGDIFF (X (BAGINT BAG1 BAG2)) (Y BAG2))))) (PROVE-LEMMA ITIMES-LIST-EVAL$-FACTORS-LEMMA-PRIME (REWRITE) (EQUAL (ITIMES (ITIMES-LIST (EVAL$ 'LIST (BAGINT BAG1 BAG2) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG1 (BAGINT BAG1 BAG2)) A))) (ITIMES-LIST (EVAL$ 'LIST BAG1 A))) ((USE (ITIMES-LIST-BAGDIFF (X (BAGINT BAG1 BAG2)) (Y BAG1))))) (PROVE-LEMMA ITIMES-LIST-EVAL$-FACTORS (REWRITE) (EQUAL (ITIMES-LIST (EVAL$ 'LIST (ITIMES-FACTORS X) A)) (FIX-INT (EVAL$ T X A))) ((INDUCT (ITIMES-FACTORS X)) (ENABLE INTEGERP-EVAL$-ITIMES ITIMES-LIST-BAGDIFF LISTP-BAGINT-WITH-SINGLETON-MEMBER))) (PROVE-LEMMA IPLUS-OR-ITIMES-TERM-INTEGERP-EVAL$ (REWRITE) (IMPLIES (IPLUS-OR-ITIMES-TERM X) (INTEGERP (EVAL$ T X A))) ((ENABLE IPLUS-OR-ITIMES-TERM))) (PROVE-LEMMA EVAL$-LIST-BAGINT-0 NIL (IMPLIES (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGINT X Y) A)) 0) (AND (EQUAL (ITIMES-LIST (EVAL$ 'LIST X A)) 0) (EQUAL (ITIMES-LIST (EVAL$ 'LIST Y A)) 0))) ((USE (SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 (X (BAGINT X Y)) (Y X)) (SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 (X (BAGINT X Y)) (Y Y))))) (PROVE-LEMMA EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL (REWRITE) (IMPLIES (AND (EQUAL (ITIMES-LIST (EVAL$ 'LIST (BAGINT (ITIMES-FACTORS V) (ITIMES-FACTORS W)) A)) 0) (INTEGERP (EVAL$ T V A)) (INTEGERP (EVAL$ T W A))) (EQUAL (EQUAL (EVAL$ T V A) (EVAL$ T W A)) T)) ((USE (EVAL$-LIST-BAGINT-0 (X (ITIMES-FACTORS V)) (Y (ITIMES-FACTORS W)))))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-FACTORS ((META EQUAL)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-ITIMES-FACTORS-EXPANDED X) A)) ((DO-NOT-INDUCT T) (ENABLE EVAL$-ITIMES-TREE EVAL$-MAKE-CANCEL-ITIMES-EQUALITY))) (DEFN CANCEL-ITIMES-ILESSP-FACTORS (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'ILESSP) (IF (LISTP (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) (MAKE-CANCEL-ITIMES-INEQUALITY (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)) (BAGINT (ITIMES-FACTORS (CADR X)) (ITIMES-FACTORS (CADDR X)))) X) X) X)) (PROVE-LEMMA BAGINT-SINGLETON (REWRITE) (EQUAL (BAGINT X (LIST Y)) (IF (MEMBER Y X) (LIST Y) NIL))) (PROVE-LEMMA IZEROP-ILESSP-0-RELATIONSHIP (REWRITE) (EQUAL (EQUAL (FIX-INT X) 0) (AND (NOT (ILESSP X 0)) (NOT (ILESSP 0 X)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-HELPER-1 (REWRITE) (IMPLIES (ILESSP 0 W) (EQUAL (ILESSP (ITIMES X W) (ITIMES W U)) (ILESSP X U)))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-HELPER-2 (REWRITE) (IMPLIES (ILESSP W 0) (EQUAL (ILESSP (ITIMES W U) (ITIMES X W)) (ILESSP X U)))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE (REWRITE) (IMPLIES (AND (MEMBER Z Y) (NOT (EQUAL (FIX-INT (EVAL$ T Z A)) 0))) (EQUAL (ILESSP X (ITIMES-LIST (EVAL$ 'LIST (DELETE Z Y) A))) (COND ((ILESSP 0 (EVAL$ T Z A)) (ILESSP (ITIMES X (EVAL$ T Z A)) (ITIMES-LIST (EVAL$ 'LIST Y A)))) ((ILESSP (EVAL$ T Z A) 0) (ILESSP (ITIMES-LIST (EVAL$ 'LIST Y A)) (ITIMES X (EVAL$ T Z A)))) (T F)))) ((ENABLE ITIMES-LIST-EVAL$-DELETE) (DISABLE ITIMES-ITIMES-LIST-EVAL$-LIST-DELETE))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME-HELPER-1 (REWRITE) (IMPLIES (ILESSP 0 W) (EQUAL (ILESSP (ITIMES W U) (ITIMES X W)) (ILESSP U X)))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME-HELPER-2 (REWRITE) (IMPLIES (ILESSP W 0) (EQUAL (ILESSP (ITIMES X W) (ITIMES W U)) (ILESSP U X)))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME (REWRITE) (IMPLIES (AND (MEMBER Z Y) (NOT (EQUAL (FIX-INT (EVAL$ T Z A)) 0))) (EQUAL (ILESSP (ITIMES-LIST (EVAL$ 'LIST (DELETE Z Y) A)) X) (COND ((ILESSP 0 (EVAL$ T Z A)) (ILESSP (ITIMES-LIST (EVAL$ 'LIST Y A)) (ITIMES X (EVAL$ T Z A)))) ((ILESSP (EVAL$ T Z A) 0) (ILESSP (ITIMES X (EVAL$ T Z A)) (ITIMES-LIST (EVAL$ 'LIST Y A)))) (T F)))) ((ENABLE ITIMES-LIST-EVAL$-DELETE) (DISABLE ITIMES-ITIMES-LIST-EVAL$-LIST-DELETE ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE))) (PROVE-LEMMA ILESSP-0-ITIMES (REWRITE) (EQUAL (ILESSP 0 (ITIMES X Y)) (OR (AND (ILESSP 0 X) (ILESSP 0 Y)) (AND (ILESSP X 0) (ILESSP Y 0)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ILESSP-ITIMES-0 (REWRITE) (EQUAL (ILESSP (ITIMES X Y) 0) (OR (AND (ILESSP 0 X) (ILESSP Y 0)) (AND (ILESSP X 0) (ILESSP 0 Y)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF (REWRITE) (IMPLIES (AND (SUBBAGP IN-BOTH BAG1) (SUBBAGP IN-BOTH BAG2) (NOT (EQUAL (ITIMES-LIST (EVAL$ 'LIST IN-BOTH A)) 0))) (EQUAL (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG1 IN-BOTH) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG2 IN-BOTH) A))) (IF (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST IN-BOTH A))) (ILESSP (ITIMES-LIST (EVAL$ 'LIST BAG1 A)) (ITIMES-LIST (EVAL$ 'LIST BAG2 A))) (ILESSP (ITIMES-LIST (EVAL$ 'LIST BAG2 A)) (ITIMES-LIST (EVAL$ 'LIST BAG1 A)))))) ((ENABLE ILESSP-TRICHOTOMY) (DISABLE IZEROP-ILESSP-0-RELATIONSHIP))) (PROVE-LEMMA ZERO-ILESSP-IMPLIES-NOT-EQUAL NIL (IMPLIES (ILESSP 0 X) (NOT (EQUAL 0 X)))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-1 (REWRITE) (IMPLIES (AND (SUBBAGP IN-BOTH BAG1) (SUBBAGP IN-BOTH BAG2) (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST IN-BOTH A)))) (EQUAL (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG1 IN-BOTH) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG2 IN-BOTH) A))) (ILESSP (ITIMES-LIST (EVAL$ 'LIST BAG1 A)) (ITIMES-LIST (EVAL$ 'LIST BAG2 A))))) ((USE (ZERO-ILESSP-IMPLIES-NOT-EQUAL (X (ITIMES-LIST (EVAL$ 'LIST IN-BOTH A))))))) (PROVE-LEMMA ILESSP-ZERO-IMPLIES-NOT-EQUAL NIL (IMPLIES (ILESSP X 0) (NOT (EQUAL 0 X)))) (PROVE-LEMMA ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-2 (REWRITE) (IMPLIES (AND (SUBBAGP IN-BOTH BAG1) (SUBBAGP IN-BOTH BAG2) (ILESSP (ITIMES-LIST (EVAL$ 'LIST IN-BOTH A)) 0)) (EQUAL (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG1 IN-BOTH) A)) (ITIMES-LIST (EVAL$ 'LIST (BAGDIFF BAG2 IN-BOTH) A))) (ILESSP (ITIMES-LIST (EVAL$ 'LIST BAG2 A)) (ITIMES-LIST (EVAL$ 'LIST BAG1 A))))) ((USE (ILESSP-ZERO-IMPLIES-NOT-EQUAL (X (ITIMES-LIST (EVAL$ 'LIST IN-BOTH A))))))) (PROVE-LEMMA MEMBER-0-ITIMES-FACTORS-YIELDS-0 (REWRITE) (IMPLIES (NOT (EQUAL (EVAL$ T W A) 0)) (NOT (MEMBER 0 (ITIMES-FACTORS W))))) (PROVE-LEMMA MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-1 (REWRITE) (IMPLIES (ILESSP (EVAL$ T W A) 0) (NOT (MEMBER 0 (ITIMES-FACTORS W)))) ((USE (MEMBER-0-ITIMES-FACTORS-YIELDS-0)))) (PROVE-LEMMA MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-2 (REWRITE) (IMPLIES (ILESSP 0 (EVAL$ T W A)) (NOT (MEMBER 0 (ITIMES-FACTORS W)))) ((USE (MEMBER-0-ITIMES-FACTORS-YIELDS-0)))) (TOGGLE ILESSP-TRICHOTOMY-ON ILESSP-TRICHOTOMY NIL) (TOGGLE IZEROP-ILESSP-0-RELATIONSHIP-OFF IZEROP-ILESSP-0-RELATIONSHIP T) (PROVE-LEMMA EVAL$-LIST-BAGINT-0-FOR-ILESSP NIL (IMPLIES (AND (NOT (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGINT X Y) A)) 0)) (NOT (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST (BAGINT X Y) A))))) (AND (EQUAL (FIX-INT (ITIMES-LIST (EVAL$ 'LIST X A))) 0) (EQUAL (FIX-INT (ITIMES-LIST (EVAL$ 'LIST Y A))) 0))) ((USE (SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 (X (BAGINT X Y)) (Y X)) (SUBSETP-IMPLIES-ITIMES-LIST-EVAL$-EQUALS-0 (X (BAGINT X Y)) (Y Y))))) (PROVE-LEMMA EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP-LEMMA NIL (IMPLIES (AND (NOT (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGINT (ITIMES-FACTORS V) (ITIMES-FACTORS W)) A)) 0)) (NOT (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST (BAGINT (ITIMES-FACTORS V) (ITIMES-FACTORS W)) A))))) (EQUAL (FIX-INT (EVAL$ T V A)) (FIX-INT (EVAL$ T W A)))) ((USE (EVAL$-LIST-BAGINT-0-FOR-ILESSP (X (ITIMES-FACTORS V)) (Y (ITIMES-FACTORS W)))))) (PROVE-LEMMA EQUAL-FIX-INT-TO-ILESSP NIL (IMPLIES (EQUAL (FIX-INT X) (FIX-INT Y)) (NOT (ILESSP X Y))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP (REWRITE) (IMPLIES (AND (NOT (ILESSP (ITIMES-LIST (EVAL$ 'LIST (BAGINT (ITIMES-FACTORS V) (ITIMES-FACTORS W)) A)) 0)) (NOT (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST (BAGINT (ITIMES-FACTORS V) (ITIMES-FACTORS W)) A))))) (AND (NOT (ILESSP (EVAL$ T V A) (EVAL$ T W A))) (NOT (ILESSP (EVAL$ T W A) (EVAL$ T V A))))) ((USE (EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP-LEMMA) (EQUAL-FIX-INT-TO-ILESSP (X (EVAL$ T V A)) (Y (EVAL$ T W A))) (EQUAL-FIX-INT-TO-ILESSP (X (EVAL$ T W A)) (Y (EVAL$ T V A)))))) (TOGGLE ILESSP-TRICHOTOMY-OFF1 ILESSP-TRICHOTOMY T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-FACTORS ((META ILESSP)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-ITIMES-ILESSP-FACTORS X) A)) ((DO-NOT-INDUCT T) (ENABLE EVAL$-ITIMES-TREE-NO-FIX-INT-1 EVAL$-ITIMES-TREE-NO-FIX-INT-2 EVAL$-ITIMES-TREE EVAL$-MAKE-CANCEL-ITIMES-INEQUALITY))) (TOGGLE LESSP-COUNT-LISTP-CDR-ON LESSP-COUNT-LISTP-CDR NIL) (DEFN DISJOIN-EQUALITIES-WITH-0 (FACTORS) (IF (LISTP (CDR FACTORS)) (LIST 'OR (CONS 'EQUAL (CONS (LIST 'FIX-INT (CAR FACTORS)) '('0))) (DISJOIN-EQUALITIES-WITH-0 (CDR FACTORS))) (CONS 'EQUAL (CONS (LIST 'FIX-INT (CAR FACTORS)) '('0))))) (TOGGLE LESSP-COUNT-LISTP-CDR-OFF1 LESSP-COUNT-LISTP-CDR T) (DEFN CANCEL-FACTORS-0 (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'EQUAL) (COND ((EQUAL (CADR X) ''0) (IF (LISTP (CDR (ITIMES-FACTORS (CADDR X)))) (DISJOIN-EQUALITIES-WITH-0 (ITIMES-FACTORS (CADDR X))) X)) ((EQUAL (CADDR X) ''0) (IF (LISTP (CDR (ITIMES-FACTORS (CADR X)))) (DISJOIN-EQUALITIES-WITH-0 (ITIMES-FACTORS (CADR X))) X)) (T X)) X) X)) (DEFN SOME-EVAL$S-TO-0 (X A) (IF (LISTP X) (OR (EQUAL (FIX-INT (EVAL$ T (CAR X) A)) 0) (SOME-EVAL$S-TO-0 (CDR X) A)) F)) (PROVE-LEMMA EVAL$-DISJOIN-EQUALITIES-WITH-0 (REWRITE) (IMPLIES (LISTP LST) (EQUAL (EVAL$ T (DISJOIN-EQUALITIES-WITH-0 LST) A) (SOME-EVAL$S-TO-0 LST A)))) (PROVE-LEMMA SOME-EVAL$S-TO-0-APPEND (REWRITE) (EQUAL (SOME-EVAL$S-TO-0 (APPEND X Y) A) (OR (SOME-EVAL$S-TO-0 X A) (SOME-EVAL$S-TO-0 Y A)))) (PROVE-LEMMA SOME-EVAL$S-TO-0-ELIMINATOR (REWRITE) (EQUAL (SOME-EVAL$S-TO-0 X A) (EQUAL (ITIMES-LIST (EVAL$ 'LIST X A)) 0))) (PROVE-LEMMA LISTP-CDR-FACTORS-IMPLIES-INTEGERP (REWRITE) (IMPLIES (LISTP (CDR (ITIMES-FACTORS V))) (INTEGERP (EVAL$ T V A))) ((EXPAND (ITIMES-FACTORS V)))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-FACTORS-0 ((META EQUAL)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-FACTORS-0 X) A))) (TOGGLE LESSP-COUNT-LISTP-CDR-ON1 LESSP-COUNT-LISTP-CDR NIL) (DEFN CONJOIN-INEQUALITIES-WITH-0 (FACTORS PARITY) (COND ((LISTP (CDR FACTORS)) (IF PARITY (LIST 'OR (LIST 'AND (LIST 'ILESSP ''0 (CAR FACTORS)) (CONJOIN-INEQUALITIES-WITH-0 (CDR FACTORS) T)) (LIST 'AND (CONS 'ILESSP (CONS (CAR FACTORS) '('0))) (CONJOIN-INEQUALITIES-WITH-0 (CDR FACTORS) F))) (LIST 'OR (LIST 'AND (CONS 'ILESSP (CONS (CAR FACTORS) '('0))) (CONJOIN-INEQUALITIES-WITH-0 (CDR FACTORS) T)) (LIST 'AND (LIST 'ILESSP ''0 (CAR FACTORS)) (CONJOIN-INEQUALITIES-WITH-0 (CDR FACTORS) F))))) (PARITY (LIST 'ILESSP ''0 (CAR FACTORS))) (T (CONS 'ILESSP (CONS (CAR FACTORS) '('0)))))) (TOGGLE LESSP-COUNT-LISTP-CDR-OFF2 LESSP-COUNT-LISTP-CDR T) (DEFN CANCEL-FACTORS-ILESSP-0 (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'ILESSP) (COND ((EQUAL (CADR X) ''0) (IF (LISTP (CDR (ITIMES-FACTORS (CADDR X)))) (CONJOIN-INEQUALITIES-WITH-0 (ITIMES-FACTORS (CADDR X)) T) X)) ((EQUAL (CADDR X) ''0) (IF (LISTP (CDR (ITIMES-FACTORS (CADR X)))) (CONJOIN-INEQUALITIES-WITH-0 (ITIMES-FACTORS (CADR X)) F) X)) (T X)) X) X)) (PROVE-LEMMA CONJOIN-INEQUALITIES-WITH-0-ELIMINATOR (REWRITE) (IMPLIES (LISTP X) (EQUAL (EVAL$ T (CONJOIN-INEQUALITIES-WITH-0 X PARITY) A) (IF PARITY (ILESSP 0 (ITIMES-LIST (EVAL$ 'LIST X A))) (ILESSP (ITIMES-LIST (EVAL$ 'LIST X A)) 0))))) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-FACTORS-ILESSP-0 ((META ILESSP)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-FACTORS-ILESSP-0 X) A))) (TOGGLE EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE-NEW-1-OFF EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE-NEW-1 T) (TOGGLE EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE-NEW-2-OFF EQUAL-ITIMES-LIST-EVAL$-LIST-DELETE-NEW-2 T) (TOGGLE ITIMES-ITIMES-LIST-EVAL$-LIST-DELETE-OFF ITIMES-ITIMES-LIST-EVAL$-LIST-DELETE T) (TOGGLE EQUAL-ITIMES-LIST-EVAL$-LIST-BAGDIFF-OFF EQUAL-ITIMES-LIST-EVAL$-LIST-BAGDIFF T) (TOGGLE ITIMES-LIST-EVAL$-FACTORS-LEMMA-OFF ITIMES-LIST-EVAL$-FACTORS-LEMMA T) (TOGGLE ITIMES-LIST-EVAL$-FACTORS-LEMMA-PRIME-OFF ITIMES-LIST-EVAL$-FACTORS-LEMMA-PRIME T) (TOGGLE ITIMES-LIST-EVAL$-FACTORS-OFF ITIMES-LIST-EVAL$-FACTORS T) (TOGGLE IPLUS-OR-ITIMES-TERM-INTEGERP-EVAL$-OFF IPLUS-OR-ITIMES-TERM-INTEGERP-EVAL$ T) (TOGGLE EVAL$-LIST-BAGINT-0-OFF EVAL$-LIST-BAGINT-0 T) (TOGGLE EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-OFF EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL T) (TOGGLE IZEROP-ILESSP-0-RELATIONSHIP-OFF1 IZEROP-ILESSP-0-RELATIONSHIP T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-HELPER-1-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-HELPER-1 T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-HELPER-2-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-HELPER-2 T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME-HELPER-1-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME-HELPER-1 T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME-HELPER-2-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME-HELPER-2 T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-DELETE-PRIME T) (TOGGLE ILESSP-0-ITIMES-OFF ILESSP-0-ITIMES T) (TOGGLE ILESSP-ITIMES-0-OFF ILESSP-ITIMES-0 T) (TOGGLE LISTP-CDR-FACTORS-IMPLIES-INTEGERP-OFF LISTP-CDR-FACTORS-IMPLIES-INTEGERP T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-OFF CORRECTNESS-OF-CANCEL-ITIMES T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP T) (TOGGLE NOT-INTEGERP-IMPLIES-NOT-EQUAL-IPLUS-OFF NOT-INTEGERP-IMPLIES-NOT-EQUAL-IPLUS T) (TOGGLE NOT-INTEGERP-IMPLIES-NOT-EQUAL-ITIMES-OFF NOT-INTEGERP-IMPLIES-NOT-EQUAL-ITIMES T) (TOGGLE SUBBAGP-SUBSETP-OFF SUBBAGP-SUBSETP T) (TOGGLE EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP-OFF EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP T) (DEFN SPLIT-OUT-INEG-TERMS (X) (IF (LISTP X) (IF (LISTP (CAR X)) (COND ((EQUAL (CAAR X) 'INEG) (CONS (CAR (SPLIT-OUT-INEG-TERMS (CDR X))) (CONS (CADAR X) (CDR (SPLIT-OUT-INEG-TERMS (CDR X)))))) ((AND (EQUAL (CAAR X) 'QUOTE) (NEGATIVEP (CADAR X)) (NOT (EQUAL (NEGATIVE-GUTS (CADAR X)) 0))) (CONS (CAR (SPLIT-OUT-INEG-TERMS (CDR X))) (CONS (LIST 'QUOTE (NEGATIVE-GUTS (CADAR X))) (CDR (SPLIT-OUT-INEG-TERMS (CDR X)))))) (T (CONS (CONS (CAR X) (CAR (SPLIT-OUT-INEG-TERMS (CDR X)))) (CDR (SPLIT-OUT-INEG-TERMS (CDR X)))))) (CONS (CONS (CAR X) (CAR (SPLIT-OUT-INEG-TERMS (CDR X)))) (CDR (SPLIT-OUT-INEG-TERMS (CDR X))))) '(NIL))) (DEFN REMOVE-INEGS (X Y) (IF (OR (LISTP (CDR (SPLIT-OUT-INEG-TERMS X))) (LISTP (CDR (SPLIT-OUT-INEG-TERMS Y)))) (CONS (APPEND (CDR (SPLIT-OUT-INEG-TERMS Y)) (CAR (SPLIT-OUT-INEG-TERMS X))) (APPEND (CDR (SPLIT-OUT-INEG-TERMS X)) (CAR (SPLIT-OUT-INEG-TERMS Y)))) F)) (DEFN IPLUS-OR-INEG-TERM (X) (AND (LISTP X) (OR (EQUAL (CAR X) 'INEG) (EQUAL (CAR X) 'IPLUS)))) (DEFN MAKE-CANCEL-INEG-TERMS-EQUALITY (X) (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (COND ((IPLUS-OR-INEG-TERM (CADR X)) (IF (IPLUS-OR-INEG-TERM (CADDR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F)))) ((IPLUS-OR-INEG-TERM (CADDR X)) (LIST 'IF (LIST 'INTEGERP (CADR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F))) (T X)) X)) (DEFN CANCEL-INEG-TERMS-FROM-EQUALITY (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'EQUAL)) (MAKE-CANCEL-INEG-TERMS-EQUALITY X) X)) (DEFN CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'EQUAL) (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (COND ((LISTP (CADR X)) (CASE (CAADR X) (INEG (IF (LISTP (CADDR X)) (CASE (CAADDR X) (INEG (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))))) (IPLUS (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))))) (OTHERWISE (LIST 'IF (LIST 'INTEGERP (CADDR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F)))) (IPLUS (IF (LISTP (CADDR X)) (CASE (CAADDR X) (INEG (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))))) (IPLUS (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))))) (OTHERWISE (LIST 'IF (LIST 'INTEGERP (CADDR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F)))) (LIST 'IF (LIST 'INTEGERP (CADDR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F)))) (OTHERWISE (IF (LISTP (CADDR X)) (CASE (CAADDR X) (INEG (LIST 'IF (LIST 'INTEGERP (CADR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F))) (IPLUS (LIST 'IF (LIST 'INTEGERP (CADR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F))) (OTHERWISE X)) X)))) ((LISTP (CADDR X)) (CASE (CAADDR X) (INEG (LIST 'IF (LIST 'INTEGERP (CADR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F))) (IPLUS (LIST 'IF (LIST 'INTEGERP (CADR X)) (LIST 'EQUAL (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) (LIST 'QUOTE F))) (OTHERWISE X))) (T X)) X) X) X)) (PROVE-LEMMA CANCEL-INEG-TERMS-FROM-EQUALITY-CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED (REWRITE) (EQUAL (CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED X) (CANCEL-INEG-TERMS-FROM-EQUALITY X)) ((DISABLE-THEORY T) (ENABLE-THEORY GROUND-ZERO) (ENABLE MAKE-CANCEL-INEG-TERMS-EQUALITY IPLUS-OR-INEG-TERM CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED CANCEL-INEG-TERMS-FROM-EQUALITY))) (TOGGLE CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED-OFF CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED T) (PROVE-LEMMA INTEGERP-EVAL$-IPLUS-OR-INEG-TERM (REWRITE) (IMPLIES (IPLUS-OR-INEG-TERM X) (INTEGERP (EVAL$ T X A)))) (TOGGLE IPLUS-OR-INEG-TERM-OFF IPLUS-OR-INEG-TERM T) (PROVE-LEMMA EVAL$-IPLUS-LIST-CAR-REMOVE-INEGS (REWRITE) (IMPLIES (REMOVE-INEGS X Y) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (CAR (REMOVE-INEGS X Y)) A)) (IPLUS (IPLUS-LIST (EVAL$ 'LIST (CAR (SPLIT-OUT-INEG-TERMS X)) A)) (IPLUS-LIST (EVAL$ 'LIST (CDR (SPLIT-OUT-INEG-TERMS Y)) A)))))) (PROVE-LEMMA EVAL$-IPLUS-LIST-CDR-REMOVE-INEGS (REWRITE) (IMPLIES (REMOVE-INEGS X Y) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (CDR (REMOVE-INEGS X Y)) A)) (IPLUS (IPLUS-LIST (EVAL$ 'LIST (CAR (SPLIT-OUT-INEG-TERMS Y)) A)) (IPLUS-LIST (EVAL$ 'LIST (CDR (SPLIT-OUT-INEG-TERMS X)) A)))))) (PROVE-LEMMA MINUS-INEG (REWRITE) (IMPLIES (AND (NUMBERP X) (NOT (EQUAL X 0))) (EQUAL (MINUS X) (INEG X))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA IPLUS-LIST-EVAL$-CAR-SPLIT-OUT-INEG-TERMS (REWRITE) (EQUAL (IPLUS-LIST (EVAL$ 'LIST (CAR (SPLIT-OUT-INEG-TERMS X)) A)) (IPLUS (IPLUS-LIST (EVAL$ 'LIST X A)) (IPLUS-LIST (EVAL$ 'LIST (CDR (SPLIT-OUT-INEG-TERMS X)) A)))) ((INDUCT (SPLIT-OUT-INEG-TERMS X)) (ENABLE EVAL$-QUOTE))) (TOGGLE REMOVE-INEGS-OFF REMOVE-INEGS T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-EQUALITY ((META EQUAL)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED X) A)) ((ENABLE EVAL$-IPLUS-TREE IPLUS-LIST-EVAL$-FRINGE EVAL$-QUOTE) (DISABLE IPLUS-FRINGE))) (DEFN MAKE-CANCEL-INEG-TERMS-INEQUALITY (X) (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST 'ILESSP (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) (DEFN CANCEL-INEG-TERMS-FROM-INEQUALITY (X) (IF (AND (LISTP X) (EQUAL (CAR X) 'ILESSP)) (COND ((IPLUS-OR-INEG-TERM (CADR X)) (MAKE-CANCEL-INEG-TERMS-INEQUALITY X)) ((IPLUS-OR-INEG-TERM (CADDR X)) (MAKE-CANCEL-INEG-TERMS-INEQUALITY X)) (T X)) X)) (DEFN CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED (X) (IF (LISTP X) (IF (EQUAL (CAR X) 'ILESSP) (COND ((LISTP (CADR X)) (CASE (CAADR X) (INEG (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST 'ILESSP (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) (IPLUS (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST 'ILESSP (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) (OTHERWISE (IF (LISTP (CADDR X)) (CASE (CAADDR X) (INEG (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST 'ILESSP (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) (IPLUS (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST 'ILESSP (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) (OTHERWISE X)) X)))) ((LISTP (CADDR X)) (CASE (CAADDR X) (INEG (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST 'ILESSP (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) (IPLUS (IF (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))) (LIST 'ILESSP (IPLUS-TREE (CAR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X))))) (IPLUS-TREE (CDR (REMOVE-INEGS (IPLUS-FRINGE (CADR X)) (IPLUS-FRINGE (CADDR X)))))) X)) (OTHERWISE X))) (T X)) X) X)) (PROVE-LEMMA CANCEL-INEG-TERMS-FROM-INEQUALITY-CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED (REWRITE) (EQUAL (CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED X) (CANCEL-INEG-TERMS-FROM-INEQUALITY X)) ((DISABLE-THEORY T) (ENABLE-THEORY GROUND-ZERO) (ENABLE MAKE-CANCEL-INEG-TERMS-INEQUALITY IPLUS-OR-INEG-TERM CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED CANCEL-INEG-TERMS-FROM-INEQUALITY))) (TOGGLE CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED-OFF CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED T) (PROVE-LEMMA CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-INEQUALITY ((META ILESSP)) (EQUAL (EVAL$ T X A) (EVAL$ T (CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED X) A)) ((ENABLE EVAL$-IPLUS-TREE IPLUS-LIST-EVAL$-FRINGE EVAL$-QUOTE) (DISABLE IPLUS-FRINGE))) (TOGGLE MINUS-INEG-OFF MINUS-INEG T) (TOGGLE INTEGERP-EVAL$-IPLUS-OR-INEG-TERM-OFF INTEGERP-EVAL$-IPLUS-OR-INEG-TERM T) (PROVE-LEMMA PLUS-IPLUS (REWRITE) (IMPLIES (AND (NUMBERP I) (NUMBERP J)) (EQUAL (PLUS I J) (IPLUS I J))) ((ENABLE IPLUS))) (PROVE-LEMMA IPLUS-CONSTANTS (REWRITE) (EQUAL (IPLUS (ADD1 I) (IPLUS (ADD1 J) X)) (IPLUS (PLUS (ADD1 I) (ADD1 J)) X)) ((ENABLE FIX-INT INTEGERP) (DISABLE PLUS-ADD1-ARG1))) (PROVE-LEMMA NUMBERP-IS-INTEGERP (REWRITE) (IMPLIES (NUMBERP W) (INTEGERP W)) ((ENABLE INTEGERP))) (PROVE-LEMMA DIFFERENCE-IDIFFERENCE (REWRITE) (IMPLIES (AND (NUMBERP X) (NUMBERP Y) (IF (LESSP Y X) F T)) (EQUAL (DIFFERENCE Y X) (IDIFFERENCE Y X)))) (PROVE-LEMMA CANCEL-CONSTANTS-EQUAL-LEMMA NIL (IMPLIES (AND (NUMBERP M) (NUMBERP N)) (EQUAL (EQUAL (IPLUS M X) (IPLUS N Y)) (IF (LESSP M N) (EQUAL (FIX-INT X) (IPLUS (DIFFERENCE N M) Y)) (EQUAL (IPLUS (DIFFERENCE M N) X) (FIX-INT Y)))))) (PROVE-LEMMA CANCEL-CONSTANTS-EQUAL (REWRITE) (EQUAL (EQUAL (IPLUS (ADD1 I) X) (IPLUS (ADD1 J) Y)) (IF (LESSP I J) (EQUAL (FIX-INT X) (IPLUS (DIFFERENCE J I) Y)) (EQUAL (IPLUS (DIFFERENCE I J) X) (FIX-INT Y)))) ((USE (CANCEL-CONSTANTS-EQUAL-LEMMA (M (ADD1 I)) (N (ADD1 J)))) (EXPAND (DIFFERENCE (ADD1 I) (ADD1 J)) (DIFFERENCE (ADD1 J) (ADD1 I)) (LESSP (ADD1 I) (ADD1 J))) (DISABLE-THEORY T) (ENABLE-THEORY GROUND-ZERO))) (PROVE-LEMMA ILESSP-ADD1 (REWRITE) (IMPLIES (NUMBERP Y) (EQUAL (ILESSP X (ADD1 Y)) (NOT (ILESSP Y X)))) ((ENABLE-THEORY INTEGER-DEFNS))) (PROVE-LEMMA ILESSP-ADD1-IPLUS (REWRITE) (IMPLIES (NUMBERP Y) (EQUAL (ILESSP X (IPLUS (ADD1 Y) Z)) (NOT (ILESSP (IPLUS Y Z) X)))) ((ENABLE-THEORY INTEGER-DEFNS) (DISABLE PLUS-IPLUS DIFFERENCE-IDIFFERENCE))) (PROVE-LEMMA CANCEL-CONSTANTS-ILESSP-LEMMA-1 NIL (IMPLIES (AND (NUMBERP M) (NUMBERP N)) (EQUAL (ILESSP (IPLUS M X) (IPLUS N Y)) (IF (LESSP M N) (ILESSP X (IPLUS (DIFFERENCE N M) Y)) (ILESSP (IPLUS (DIFFERENCE M N) X) Y))))) (PROVE-LEMMA CANCEL-CONSTANTS-ILESSP-LEMMA-2 NIL (IMPLIES (AND (NUMBERP M) (NUMBERP N)) (EQUAL (ILESSP (IPLUS M X) (IPLUS N Y)) (IF (LESSP M N) (NOT (ILESSP (IPLUS (SUB1 (DIFFERENCE N M)) Y) X)) (ILESSP (IPLUS (DIFFERENCE M N) X) Y)))) ((USE (CANCEL-CONSTANTS-ILESSP-LEMMA-1) (ILESSP-ADD1-IPLUS (Y (SUB1 (DIFFERENCE N M))) (Z Y) (X X))) (DISABLE ILESSP-ADD1-IPLUS))) (PROVE-LEMMA CANCEL-CONSTANTS-ILESSP (REWRITE) (EQUAL (ILESSP (IPLUS (ADD1 I) X) (IPLUS (ADD1 J) Y)) (IF (LESSP I J) (NOT (ILESSP (IPLUS (SUB1 (DIFFERENCE J I)) Y) X)) (ILESSP (IPLUS (DIFFERENCE I J) X) Y))) ((USE (CANCEL-CONSTANTS-ILESSP-LEMMA-2 (M (ADD1 I)) (N (ADD1 J)))) (EXPAND (DIFFERENCE (ADD1 I) (ADD1 J)) (DIFFERENCE (ADD1 J) (ADD1 I)) (LESSP (ADD1 I) (ADD1 J))) (DISABLE-THEORY T) (ENABLE-THEORY GROUND-ZERO))) (TOGGLE PLUS-IPLUS-OFF PLUS-IPLUS T) (TOGGLE NUMBERP-IS-INTEGERP-OFF NUMBERP-IS-INTEGERP T) (TOGGLE DIFFERENCE-IDIFFERENCE-OFF DIFFERENCE-IDIFFERENCE T) (DEFTHEORY INTEGERS (ILEQ IDIFFERENCE INTEGERP-FIX-INT INTEGERP-IPLUS INTEGERP-IDIFFERENCE INTEGERP-INEG INTEGERP-IABS INTEGERP-ITIMES FIX-INT-REMOVER FIX-INT-FIX-INT FIX-INT-IPLUS FIX-INT-IDIFFERENCE FIX-INT-INEG FIX-INT-IABS FIX-INT-ITIMES INEG-IPLUS INEG-INEG INEG-FIX-INT INEG-OF-NON-INTEGERP INEG-0 IPLUS-LEFT-ID IPLUS-RIGHT-ID IPLUS-0-LEFT IPLUS-0-RIGHT COMMUTATIVITY2-OF-IPLUS COMMUTATIVITY-OF-IPLUS ASSOCIATIVITY-OF-IPLUS IPLUS-CANCELLATION-1 IPLUS-CANCELLATION-2 IPLUS-INEG1 IPLUS-INEG2 IPLUS-FIX-INT1 IPLUS-FIX-INT2 IDIFFERENCE-FIX-INT1 IDIFFERENCE-FIX-INT2 IPLUS-LIST EVAL$-LIST-APPEND IPLUS-LIST-APPEND IPLUS-INEG3 IPLUS-INEG4 CORRECTNESS-OF-CANCEL-IPLUS ILESSP-FIX-INT-1 ILESSP-FIX-INT-2 IPLUS-CANCELLATION-1-FOR-ILESSP IPLUS-CANCELLATION-2-FOR-ILESSP CORRECTNESS-OF-CANCEL-IPLUS-ILESSP ITIMES-0-LEFT ITIMES-0-RIGHT ITIMES-FIX-INT1 ITIMES-FIX-INT2 COMMUTATIVITY-OF-ITIMES ITIMES-DISTRIBUTES-OVER-IPLUS-PROOF ITIMES-DISTRIBUTES-OVER-IPLUS COMMUTATIVITY2-OF-ITIMES ASSOCIATIVITY-OF-ITIMES EQUAL-ITIMES-0 EQUAL-ITIMES-1 EQUAL-ITIMES-MINUS-1 ITIMES-1-ARG1 QUOTIENT-REMAINDER-UNIQUENESS DIVISION-THEOREM ITIMES-INEG-1 ITIMES-INEG-2 ITIMES-CANCELLATION-1 ITIMES-CANCELLATION-2 ITIMES-CANCELLATION-3 INTEGERP-IQUOTIENT INTEGERP-IREMAINDER INTEGERP-IDIV INTEGERP-IMOD INTEGERP-IQUO INTEGERP-IREM IQUOTIENT-FIX-INT1 IQUOTIENT-FIX-INT2 IREMAINDER-FIX-INT1 IREMAINDER-FIX-INT2 IDIV-FIX-INT1 IDIV-FIX-INT2 IMOD-FIX-INT1 IMOD-FIX-INT2 IQUO-FIX-INT1 IQUO-FIX-INT2 IREM-FIX-INT1 IREM-FIX-INT2 FIX-INT-IQUOTIENT FIX-INT-IREMAINDER FIX-INT-IDIV FIX-INT-IMOD FIX-INT-IQUO FIX-INT-IREM ITIMES-LIST ITIMES-LIST-APPEND MEMBER-APPEND EQUAL-FIX-INT SUBSETP CORRECTNESS-OF-CANCEL-ITIMES CORRECTNESS-OF-CANCEL-ITIMES-ILESSP ILESSP-STRICT EVAL$-LIST-CONS EVAL$-LIST-NLISTP EVAL$-LITATOM EVAL$-QUOTE EVAL$-OTHER IPLUS-X-Y-INEG-X CORRECTNESS-OF-CANCEL-INEG INTEGERP-IPLUS-LIST EVAL$-IPLUS-LIST-DELETE EVAL$-IPLUS-LIST-BAGDIFF ITIMES-TREE-INEG ITIMES-FACTORS ITIMES--1 EQUAL-INEG-INEG ILESSP-INEG-INEG FIX-INT-EVAL$-ITIMES-TREE-REC EVAL$-ITIMES-TREE-INEG INEG-EVAL$-ITIMES-TREE-INEG IPLUS-EVAL$-ITIMES-TREE-INEG ITIMES-EVAL$-ITIMES-TREE-INEG IPLUS-OR-ITIMES-TERM CANCEL-ITIMES-FACTORS CANCEL-ITIMES-FACTORS-EXPANDED CANCEL-ITIMES-FACTORS-EXPANDED-CANCEL-ITIMES-FACTORS MEMBERSHIP-OF-0-IMPLIES-ITIMES-LIST-IS-0 MEMBER-0-EVAL$-LIST CORRECTNESS-OF-CANCEL-ITIMES-FACTORS CANCEL-ITIMES-ILESSP-FACTORS BAGINT-SINGLETON ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-1 MEMBER-0-ITIMES-FACTORS-YIELDS-0 MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-1 MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-2 ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-2 CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-FACTORS DISJOIN-EQUALITIES-WITH-0 CANCEL-FACTORS-0 SOME-EVAL$S-TO-0 EVAL$-DISJOIN-EQUALITIES-WITH-0 SOME-EVAL$S-TO-0-APPEND SOME-EVAL$S-TO-0-ELIMINATOR CORRECTNESS-OF-CANCEL-FACTORS-0 CONJOIN-INEQUALITIES-WITH-0 CANCEL-FACTORS-ILESSP-0 SPLIT-OUT-INEG-TERMS CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-EQUALITY CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-INEQUALITY IPLUS-CONSTANTS CANCEL-CONSTANTS-EQUAL ILESSP-ADD1 ILESSP-ADD1-IPLUS CANCEL-CONSTANTS-ILESSP)) (TOGGLE EVAL$-ON EVAL$ NIL) (DEFTHEORY MATH-THEORY (CANCEL-CONSTANTS-ILESSP CANCEL-CONSTANTS-ILESSP-LEMMA-2 CANCEL-CONSTANTS-ILESSP-LEMMA-1 ILESSP-ADD1-IPLUS ILESSP-ADD1 CANCEL-CONSTANTS-EQUAL CANCEL-CONSTANTS-EQUAL-LEMMA IPLUS-CONSTANTS CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-INEQUALITY CANCEL-INEG-TERMS-FROM-INEQUALITY-CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED *1*CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED CANCEL-INEG-TERMS-FROM-INEQUALITY *1*CANCEL-INEG-TERMS-FROM-INEQUALITY MAKE-CANCEL-INEG-TERMS-INEQUALITY *1*MAKE-CANCEL-INEG-TERMS-INEQUALITY CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-EQUALITY IPLUS-LIST-EVAL$-CAR-SPLIT-OUT-INEG-TERMS EVAL$-IPLUS-LIST-CDR-REMOVE-INEGS EVAL$-IPLUS-LIST-CAR-REMOVE-INEGS CANCEL-INEG-TERMS-FROM-EQUALITY-CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED *1*CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED CANCEL-INEG-TERMS-FROM-EQUALITY *1*CANCEL-INEG-TERMS-FROM-EQUALITY MAKE-CANCEL-INEG-TERMS-EQUALITY *1*MAKE-CANCEL-INEG-TERMS-EQUALITY *1*IPLUS-OR-INEG-TERM *1*REMOVE-INEGS SPLIT-OUT-INEG-TERMS *1*SPLIT-OUT-INEG-TERMS CORRECTNESS-OF-CANCEL-FACTORS-ILESSP-0 CONJOIN-INEQUALITIES-WITH-0-ELIMINATOR CANCEL-FACTORS-ILESSP-0 *1*CANCEL-FACTORS-ILESSP-0 CONJOIN-INEQUALITIES-WITH-0 *1*CONJOIN-INEQUALITIES-WITH-0 CORRECTNESS-OF-CANCEL-FACTORS-0 SOME-EVAL$S-TO-0-ELIMINATOR SOME-EVAL$S-TO-0-APPEND EVAL$-DISJOIN-EQUALITIES-WITH-0 SOME-EVAL$S-TO-0 *1*SOME-EVAL$S-TO-0 CANCEL-FACTORS-0 *1*CANCEL-FACTORS-0 DISJOIN-EQUALITIES-WITH-0 *1*DISJOIN-EQUALITIES-WITH-0 CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-FACTORS EQUAL-FIX-INT-TO-ILESSP EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP-LEMMA EVAL$-LIST-BAGINT-0-FOR-ILESSP MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-2 MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-1 MEMBER-0-ITIMES-FACTORS-YIELDS-0 ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-2 ILESSP-ZERO-IMPLIES-NOT-EQUAL ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-1 ZERO-ILESSP-IMPLIES-NOT-EQUAL ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF BAGINT-SINGLETON CANCEL-ITIMES-ILESSP-FACTORS *1*CANCEL-ITIMES-ILESSP-FACTORS CORRECTNESS-OF-CANCEL-ITIMES-FACTORS MEMBER-0-EVAL$-LIST MEMBERSHIP-OF-0-IMPLIES-ITIMES-LIST-IS-0 CANCEL-ITIMES-FACTORS-EXPANDED-CANCEL-ITIMES-FACTORS *1*CANCEL-ITIMES-FACTORS-EXPANDED CANCEL-ITIMES-FACTORS *1*CANCEL-ITIMES-FACTORS *1*IPLUS-OR-ITIMES-TERM ITIMES-EVAL$-ITIMES-TREE-INEG IPLUS-EVAL$-ITIMES-TREE-INEG INEG-EVAL$-ITIMES-TREE-INEG EVAL$-ITIMES-TREE-INEG FIX-INT-EVAL$-ITIMES-TREE-REC ILESSP-INEG-INEG EQUAL-INEG-INEG ITIMES--1 ITIMES-FACTORS *1*ITIMES-FACTORS *1*ITIMES-TREE-INEG ILESSP-STRICT ILESSP-ITIMES-RIGHT-NEGATIVE ILESSP-ITIMES-RIGHT-POSITIVE CANCEL-ITIMES-ILESSP *1*CANCEL-ITIMES-ILESSP *1*MAKE-CANCEL-ITIMES-INEQUALITY *1*ITIMES-TREE-NO-FIX-INT SUBSETP *1*SUBSETP EQUAL-FIX-INT MEMBER-APPEND ITIMES-LIST-APPEND CANCEL-ITIMES *1*CANCEL-ITIMES *1*MAKE-CANCEL-ITIMES-EQUALITY INTEGERP-ITIMES-LIST ITIMES-LIST *1*ITIMES-LIST *1*ITIMES-TREE ITIMES-TREE-REC *1*ITIMES-TREE-REC ITIMES-FRINGE *1*ITIMES-FRINGE FIX-INT-IREM FIX-INT-IQUO FIX-INT-IMOD FIX-INT-IDIV FIX-INT-IREMAINDER FIX-INT-IQUOTIENT IREM-FIX-INT2 IREM-FIX-INT1 IQUO-FIX-INT2 IQUO-FIX-INT1 IMOD-FIX-INT2 IMOD-FIX-INT1 IDIV-FIX-INT2 IDIV-FIX-INT1 IREMAINDER-FIX-INT2 IREMAINDER-FIX-INT1 IQUOTIENT-FIX-INT2 IQUOTIENT-FIX-INT1 INTEGERP-IREM INTEGERP-IQUO INTEGERP-IMOD INTEGERP-IDIV INTEGERP-IREMAINDER INTEGERP-IQUOTIENT ITIMES-CANCELLATION-3 ITIMES-CANCELLATION-2 ITIMES-CANCELLATION-1 ITIMES-INEG-2 ITIMES-INEG-1 IQUO-IREM-UNIQUENESS DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART3 DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART2 DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART1 IDIV-IMOD-UNIQUENESS DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART3 DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART2 DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART1 IQUOTIENT-IREMAINDER-UNIQUENESS DIVISION-THEOREM DIVISION-THEOREM-PART3 DIVISION-THEOREM-PART2 DIVISION-THEOREM-PART1 QUOTIENT-REMAINDER-UNIQUENESS ITIMES-1-ARG1 EQUAL-ITIMES-MINUS-1 EQUAL-ITIMES-1 EQUAL-ITIMES-0 ASSOCIATIVITY-OF-ITIMES COMMUTATIVITY2-OF-ITIMES ITIMES-DISTRIBUTES-OVER-IPLUS ITIMES-DISTRIBUTES-OVER-IPLUS-PROOF COMMUTATIVITY-OF-ITIMES ITIMES-FIX-INT2 ITIMES-FIX-INT1 ITIMES-0-RIGHT ITIMES-0-LEFT CORRECTNESS-OF-CANCEL-IPLUS-ILESSP CANCEL-IPLUS-ILESSP *1*CANCEL-IPLUS-ILESSP *1*IPLUS-TREE-NO-FIX-INT IPLUS-CANCELLATION-2-FOR-ILESSP IPLUS-CANCELLATION-1-FOR-ILESSP CANCEL-IPLUS-ILESSP-1 *1*CANCEL-IPLUS-ILESSP-1 *1*MAKE-CANCEL-IPLUS-INEQUALITY-1 ILESSP-FIX-INT-2 ILESSP-FIX-INT-1 CORRECTNESS-OF-CANCEL-IPLUS IPLUS-INEG7 IPLUS-LIST-APPEND EVAL$-IPLUS-LIST-DELETE *1*CANCEL-IPLUS EVAL$-LIST-APPEND INTEGERP-IPLUS-LIST IPLUS-LIST *1*IPLUS-LIST *1*IPLUS-TREE IPLUS-TREE-REC *1*IPLUS-TREE-REC IPLUS-FRINGE *1*IPLUS-FRINGE CORRECTNESS-OF-CANCEL-INEG IPLUS-X-Y-INEG-X IPLUS-INEG4 IPLUS-INEG3 EVAL$-CANCEL-INEG-AUX-IS-ITS-FN EVAL$-CANCEL-INEG-AUX-FN *1*EVAL$-CANCEL-INEG-AUX-FN EVAL$-OTHER EVAL$-LITATOM EVAL$-LIST-NLISTP EVAL$-LIST-CONS CANCEL-INEG *1*CANCEL-INEG CANCEL-INEG-AUX *1*CANCEL-INEG-AUX IDIFFERENCE-FIX-INT2 IDIFFERENCE-FIX-INT1 IPLUS-FIX-INT2 IPLUS-FIX-INT1 IPLUS-INEG2 IPLUS-INEG1 IPLUS-CANCELLATION-2 IPLUS-CANCELLATION-1 ASSOCIATIVITY-OF-IPLUS COMMUTATIVITY-OF-IPLUS COMMUTATIVITY2-OF-IPLUS IPLUS-0-RIGHT IPLUS-0-LEFT INEG-0 INEG-FIX-INT INEG-INEG INEG-IPLUS FIX-INT-ITIMES FIX-INT-IABS FIX-INT-INEG FIX-INT-IDIFFERENCE FIX-INT-IPLUS FIX-INT-FIX-INT FIX-INT-REMOVER INTEGERP-ITIMES INTEGERP-IABS INTEGERP-INEG INTEGERP-IDIFFERENCE INTEGERP-IPLUS INTEGERP-FIX-INT *1*IREM *1*IQUO *1*IMOD *1*IDIV *1*IREMAINDER *1*IQUOTIENT *1*ITIMES *1*IABS IDIFFERENCE *1*IDIFFERENCE *1*INEG *1*IPLUS ILEQ *1*ILEQ *1*ILESSP IZEROP *1*IZEROP *1*FIX-INT *1*INTEGERP GCD-IDEMPOTENCE GCD-X-X COMMUTATIVITY2-OF-GCD COMMUTATIVITY2-OF-GCD-ZERO-CASE ASSOCIATIVITY-OF-GCD ASSOCIATIVITY-OF-GCD-ZERO-CASE COMMON-DIVISOR-DIVIDES-GCD GCD-IS-THE-GREATEST DISTRIBUTIVITY-OF-TIMES-OVER-GCD DISTRIBUTIVITY-OF-TIMES-OVER-GCD-PROOF REMAINDER-GCD GCD-PLUS-INSTANCE GCD-PLUS GCD-PLUS-PROOF GCD-PLUS-INSTANCE-TEMP GCD-PLUS-INSTANCE-TEMP-PROOF LESSP-GCD EQUAL-GCD-0 GCD-1 GCD-0 SINGLE-NUMBER-INDUCTION *1*SINGLE-NUMBER-INDUCTION COMMUTATIVITY-OF-GCD LOG-EXP LOG-TIMES-EXP LOG-TIMES-EXP-PROOF LOG-TIMES LOG-TIMES-PROOF LOG-QUOTIENT-EXP LOG-QUOTIENT-TIMES LOG-QUOTIENT-TIMES-PROOF LOG-QUOTIENT LEQ-LOG-LOG DOUBLE-LOG-INDUCTION *1*DOUBLE-LOG-INDUCTION LOG-1 LOG-0 EQUAL-LOG-0 EXP-DIFFERENCE EQUAL-EXP-1 EQUAL-EXP-0 EXP-EXP EXP-TIMES EXP-0-ARG2 EXP-1-ARG1 EXP-0-ARG1 EXP-PLUS EXP-ADD1 EXP-ZERO QUOTIENT-EXP REMAINDER-EXP-EXP DOUBLE-NUMBER-INDUCTION *1*DOUBLE-NUMBER-INDUCTION REMAINDER-EXP GCD *1*GCD LOG *1*LOG EXP *1*EXP CORRECTNESS-OF-CANCEL-QUOTIENT-TIMES CANCEL-QUOTIENT-TIMES *1*CANCEL-QUOTIENT-TIMES LESSP-QUOTIENT QUOTIENT-X-X QUOTIENT-1-ARG1 QUOTIENT-1-ARG1-CASESPLIT QUOTIENT-1-ARG2 LEQ-QUOTIENT QUOTIENT-QUOTIENT QUOTIENT-PLUS-TIMES-TIMES-INSTANCE QUOTIENT-PLUS-TIMES-TIMES QUOTIENT-PLUS-TIMES-TIMES-PROOF QUOTIENT-PLUS-FACT QUOTIENT-REMAINDER-INSTANCE QUOTIENT-REMAINDER QUOTIENT-REMAINDER-TIMES QUOTIENT-DIFFERENCE3 QUOTIENT-DIFFERENCE2 QUOTIENT-LESSP-ARG1 QUOTIENT-DIFFERENCE1 QUOTIENT-TIMES-TIMES-PROOF QUOTIENT-TIMES-INSTANCE QUOTIENT-TIMES QUOTIENT-TIMES-PROOF QUOTIENT-TIMES-INSTANCE-TEMP-PROOF QUOTIENT-PLUS QUOTIENT-PLUS-PROOF QUOTIENT-SUB1 EQUAL-QUOTIENT-0 QUOTIENT-ADD1 QUOTIENT-ZERO QUOTIENT-OF-NON-NUMBER QUOTIENT-NOOP TRANSITIVITY-OF-DIVIDES REMAINDER-X-X REMAINDER-1-ARG2 REMAINDER-1-ARG1 REMAINDER-REMAINDER REMAINDER-PLUS-TIMES-TIMES-INSTANCE REMAINDER-PLUS-TIMES-TIMES REMAINDER-PLUS-TIMES-TIMES-PROOF REMAINDER-PLUS-FACT REMAINDER-DIFFERENCE2 DOUBLE-REMAINDER-INDUCTION *1*DOUBLE-REMAINDER-INDUCTION REMAINDER-DIFFERENCE1 REMAINDER-TIMES2-INSTANCE REMAINDER-TIMES2 REMAINDER-TIMES2-PROOF REMAINDER-TIMES-TIMES-PROOF REMAINDER-TIMES1-INSTANCE REMAINDER-TIMES1-INSTANCE-PROOF REMAINDER-TIMES1 REMAINDER-TIMES1-PROOF EQUAL-REMAINDER-PLUS-REMAINDER-PROOF EQUAL-REMAINDER-PLUS-0 EQUAL-REMAINDER-PLUS-0-PROOF REMAINDER-PLUS REMAINDER-PLUS-PROOF REMAINDER-ADD1 REMAINDER-QUOTIENT-ELIM REMAINDER-ZERO REMAINDER-OF-NON-NUMBER REMAINDER-NOOP LESSP-REMAINDER CORRECTNESS-OF-CANCEL-EQUAL-TIMES CANCEL-EQUAL-TIMES *1*CANCEL-EQUAL-TIMES CORRECTNESS-OF-CANCEL-LESSP-TIMES CANCEL-LESSP-TIMES *1*CANCEL-LESSP-TIMES INFER-EQUALITY-FROM-NOT-LESSP LESSP-TIMES-ARG1 EVAL$-EQUAL AND-NOT-ZEROP-TREE *1*AND-NOT-ZEROP-TREE OR-ZEROP-TREE *1*OR-ZEROP-TREE TIMES-FRINGE *1*TIMES-FRINGE TIMES-TREE *1*TIMES-TREE LESSP-1-TIMES LESSP-PLUS-TIMES2 LESSP-PLUS-TIMES1 LESSP-PLUS-TIMES-PROOF LESSP-TIMES-CANCELLATION-PROOF LESSP-TIMES3 LESSP-TIMES3-PROOF2 LESSP-TIMES3-PROOF1 LESSP-TIMES2 LESSP-TIMES2-PROOF LESSP-TIMES1 LESSP-TIMES1-PROOF TIMES-1-ARG1 TIMES-QUOTIENT TIMES-QUOTIENT-PROOF TIMES-DISTRIBUTES-OVER-DIFFERENCE TIMES-DISTRIBUTES-OVER-DIFFERENCE-PROOF ASSOCIATIVITY-OF-TIMES COMMUTATIVITY2-OF-TIMES TIMES-DISTRIBUTES-OVER-PLUS TIMES-DISTRIBUTES-OVER-PLUS-PROOF COMMUTATIVITY-OF-TIMES TIMES-ADD1 TIMES-ZERO EQUAL-SUB1-0 EQUAL-TIMES-1 EQUAL-TIMES-0 CORRECTNESS-OF-CANCEL-LESSP-PLUS CANCEL-LESSP-PLUS *1*CANCEL-LESSP-PLUS DIFFERENCE-X-X DIFFERENCE-DIFFERENCE-ARG2 DIFFERENCE-DIFFERENCE-ARG1 DIFFERENCE-SUB1-ARG2 DIFFERENCE-ADD1-ARG2 DIFFERENCE-LEQ-ARG1 DIFFERENCE-ELIM CORRECTNESS-OF-CANCEL-DIFFERENCE-PLUS CANCEL-DIFFERENCE-PLUS *1*CANCEL-DIFFERENCE-PLUS CORRECTNESS-OF-CANCEL-EQUAL-PLUS CANCEL-EQUAL-PLUS *1*CANCEL-EQUAL-PLUS EVAL$-QUOTE PLUS-TREE *1*PLUS-TREE PLUS-FRINGE *1*PLUS-FRINGE DIFF-DIFF-ARG2 DIFF-DIFF-ARG1 DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF DIFFERENCE-PLUS-CANCELLATION-PROOF PLUS-DIFFERENCE-ARG2 PLUS-DIFFERENCE-ARG1 ASSOCIATIVITY-OF-PLUS PLUS-ADD1-ARG2 PLUS-ADD1-ARG1 PLUS-ZERO-ARG2 COMMUTATIVITY2-OF-PLUS COMMUTATIVITY-OF-PLUS EQUAL-DIFFERENCE-0 EQUAL-PLUS-0 MEMBER-BAGINT OCCURRENCES-BAGDIFF OCCURRENCES-BAGINT SUBBAGP-BAGINT2 SUBBAGP-BAGINT1 SUBBAGP-CDR2 SUBBAGP-CDR1 SUBBAGP-DELETE BAGDIFF-DELETE MEMBER-BAGDIFF OCCURRENCES-DELETE MEMBER-DELETE-IMPLIES-MEMBERSHIP MEMBER-DELETE MEMBER-NON-LIST EQUAL-OCCURRENCES-ZERO DELETE-DELETE DELETE-NON-MEMBER SUBBAGP *1*SUBBAGP OCCURRENCES *1*OCCURRENCES BAGINT *1*BAGINT BAGDIFF *1*BAGDIFF DELETE *1*DELETE)) (TOGGLE CANCEL-CONSTANTS-ILESSP-OFF CANCEL-CONSTANTS-ILESSP T) (TOGGLE CANCEL-CONSTANTS-ILESSP-LEMMA-2-OFF CANCEL-CONSTANTS-ILESSP-LEMMA-2 T) (TOGGLE CANCEL-CONSTANTS-ILESSP-LEMMA-1-OFF CANCEL-CONSTANTS-ILESSP-LEMMA-1 T) (TOGGLE ILESSP-ADD1-IPLUS-OFF ILESSP-ADD1-IPLUS T) (TOGGLE ILESSP-ADD1-OFF ILESSP-ADD1 T) (TOGGLE CANCEL-CONSTANTS-EQUAL-OFF CANCEL-CONSTANTS-EQUAL T) (TOGGLE CANCEL-CONSTANTS-EQUAL-LEMMA-OFF CANCEL-CONSTANTS-EQUAL-LEMMA T) (TOGGLE IPLUS-CONSTANTS-OFF IPLUS-CONSTANTS T) (TOGGLE CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-INEQUALITY-OFF CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-INEQUALITY T) (TOGGLE CANCEL-INEG-TERMS-FROM-INEQUALITY-CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED-OFF CANCEL-INEG-TERMS-FROM-INEQUALITY-CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED T) (TOGGLE G*1*CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED-OFF *1*CANCEL-INEG-TERMS-FROM-INEQUALITY-EXPANDED T) (TOGGLE CANCEL-INEG-TERMS-FROM-INEQUALITY-OFF CANCEL-INEG-TERMS-FROM-INEQUALITY T) (TOGGLE G*1*CANCEL-INEG-TERMS-FROM-INEQUALITY-OFF *1*CANCEL-INEG-TERMS-FROM-INEQUALITY T) (TOGGLE MAKE-CANCEL-INEG-TERMS-INEQUALITY-OFF MAKE-CANCEL-INEG-TERMS-INEQUALITY T) (TOGGLE G*1*MAKE-CANCEL-INEG-TERMS-INEQUALITY-OFF *1*MAKE-CANCEL-INEG-TERMS-INEQUALITY T) (TOGGLE CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-EQUALITY-OFF CORRECTNESS-OF-CANCEL-INEG-TERMS-FROM-EQUALITY T) (TOGGLE IPLUS-LIST-EVAL$-CAR-SPLIT-OUT-INEG-TERMS-OFF IPLUS-LIST-EVAL$-CAR-SPLIT-OUT-INEG-TERMS T) (TOGGLE EVAL$-IPLUS-LIST-CDR-REMOVE-INEGS-OFF EVAL$-IPLUS-LIST-CDR-REMOVE-INEGS T) (TOGGLE EVAL$-IPLUS-LIST-CAR-REMOVE-INEGS-OFF EVAL$-IPLUS-LIST-CAR-REMOVE-INEGS T) (TOGGLE CANCEL-INEG-TERMS-FROM-EQUALITY-CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED-OFF CANCEL-INEG-TERMS-FROM-EQUALITY-CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED T) (TOGGLE G*1*CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED-OFF *1*CANCEL-INEG-TERMS-FROM-EQUALITY-EXPANDED T) (TOGGLE CANCEL-INEG-TERMS-FROM-EQUALITY-OFF CANCEL-INEG-TERMS-FROM-EQUALITY T) (TOGGLE G*1*CANCEL-INEG-TERMS-FROM-EQUALITY-OFF *1*CANCEL-INEG-TERMS-FROM-EQUALITY T) (TOGGLE MAKE-CANCEL-INEG-TERMS-EQUALITY-OFF MAKE-CANCEL-INEG-TERMS-EQUALITY T) (TOGGLE G*1*MAKE-CANCEL-INEG-TERMS-EQUALITY-OFF *1*MAKE-CANCEL-INEG-TERMS-EQUALITY T) (TOGGLE G*1*IPLUS-OR-INEG-TERM-OFF *1*IPLUS-OR-INEG-TERM T) (TOGGLE G*1*REMOVE-INEGS-OFF *1*REMOVE-INEGS T) (TOGGLE SPLIT-OUT-INEG-TERMS-OFF SPLIT-OUT-INEG-TERMS T) (TOGGLE G*1*SPLIT-OUT-INEG-TERMS-OFF *1*SPLIT-OUT-INEG-TERMS T) (TOGGLE CORRECTNESS-OF-CANCEL-FACTORS-ILESSP-0-OFF CORRECTNESS-OF-CANCEL-FACTORS-ILESSP-0 T) (TOGGLE CONJOIN-INEQUALITIES-WITH-0-ELIMINATOR-OFF CONJOIN-INEQUALITIES-WITH-0-ELIMINATOR T) (TOGGLE CANCEL-FACTORS-ILESSP-0-OFF CANCEL-FACTORS-ILESSP-0 T) (TOGGLE G*1*CANCEL-FACTORS-ILESSP-0-OFF *1*CANCEL-FACTORS-ILESSP-0 T) (TOGGLE CONJOIN-INEQUALITIES-WITH-0-OFF CONJOIN-INEQUALITIES-WITH-0 T) (TOGGLE G*1*CONJOIN-INEQUALITIES-WITH-0-OFF *1*CONJOIN-INEQUALITIES-WITH-0 T) (TOGGLE CORRECTNESS-OF-CANCEL-FACTORS-0-OFF CORRECTNESS-OF-CANCEL-FACTORS-0 T) (TOGGLE SOME-EVAL$S-TO-0-ELIMINATOR-OFF SOME-EVAL$S-TO-0-ELIMINATOR T) (TOGGLE SOME-EVAL$S-TO-0-APPEND-OFF SOME-EVAL$S-TO-0-APPEND T) (TOGGLE EVAL$-DISJOIN-EQUALITIES-WITH-0-OFF EVAL$-DISJOIN-EQUALITIES-WITH-0 T) (TOGGLE SOME-EVAL$S-TO-0-OFF SOME-EVAL$S-TO-0 T) (TOGGLE G*1*SOME-EVAL$S-TO-0-OFF *1*SOME-EVAL$S-TO-0 T) (TOGGLE CANCEL-FACTORS-0-OFF CANCEL-FACTORS-0 T) (TOGGLE G*1*CANCEL-FACTORS-0-OFF *1*CANCEL-FACTORS-0 T) (TOGGLE DISJOIN-EQUALITIES-WITH-0-OFF DISJOIN-EQUALITIES-WITH-0 T) (TOGGLE G*1*DISJOIN-EQUALITIES-WITH-0-OFF *1*DISJOIN-EQUALITIES-WITH-0 T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-FACTORS-OFF CORRECTNESS-OF-CANCEL-ITIMES-ILESSP-FACTORS T) (TOGGLE EQUAL-FIX-INT-TO-ILESSP-OFF EQUAL-FIX-INT-TO-ILESSP T) (TOGGLE EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP-LEMMA-OFF EVAL$-LIST-BAGINT-0-IMPLIES-EQUAL-FOR-ILESSP-LEMMA T) (TOGGLE EVAL$-LIST-BAGINT-0-FOR-ILESSP-OFF EVAL$-LIST-BAGINT-0-FOR-ILESSP T) (TOGGLE MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-2-OFF MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-2 T) (TOGGLE MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-1-OFF MEMBER-0-ITIMES-FACTORS-YIELDS-0-ILESSP-CONSEQUENCE-1 T) (TOGGLE MEMBER-0-ITIMES-FACTORS-YIELDS-0-OFF MEMBER-0-ITIMES-FACTORS-YIELDS-0 T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-2-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-2 T) (TOGGLE ILESSP-ZERO-IMPLIES-NOT-EQUAL-OFF ILESSP-ZERO-IMPLIES-NOT-EQUAL T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-1-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-COROLLARY-1 T) (TOGGLE ZERO-ILESSP-IMPLIES-NOT-EQUAL-OFF ZERO-ILESSP-IMPLIES-NOT-EQUAL T) (TOGGLE ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF-OFF ILESSP-ITIMES-LIST-EVAL$-LIST-BAGDIFF T) (TOGGLE BAGINT-SINGLETON-OFF BAGINT-SINGLETON T) (TOGGLE CANCEL-ITIMES-ILESSP-FACTORS-OFF CANCEL-ITIMES-ILESSP-FACTORS T) (TOGGLE G*1*CANCEL-ITIMES-ILESSP-FACTORS-OFF *1*CANCEL-ITIMES-ILESSP-FACTORS T) (TOGGLE CORRECTNESS-OF-CANCEL-ITIMES-FACTORS-OFF CORRECTNESS-OF-CANCEL-ITIMES-FACTORS T) (TOGGLE MEMBER-0-EVAL$-LIST-OFF MEMBER-0-EVAL$-LIST T) (TOGGLE MEMBERSHIP-OF-0-IMPLIES-ITIMES-LIST-IS-0-OFF MEMBERSHIP-OF-0-IMPLIES-ITIMES-LIST-IS-0 T) (TOGGLE CANCEL-ITIMES-FACTORS-EXPANDED-CANCEL-ITIMES-FACTORS-OFF CANCEL-ITIMES-FACTORS-EXPANDED-CANCEL-ITIMES-FACTORS T) (TOGGLE G*1*CANCEL-ITIMES-FACTORS-EXPANDED-OFF *1*CANCEL-ITIMES-FACTORS-EXPANDED T) (TOGGLE CANCEL-ITIMES-FACTORS-OFF CANCEL-ITIMES-FACTORS T) (TOGGLE G*1*CANCEL-ITIMES-FACTORS-OFF *1*CANCEL-ITIMES-FACTORS T) (TOGGLE G*1*IPLUS-OR-ITIMES-TERM-OFF *1*IPLUS-OR-ITIMES-TERM T) (TOGGLE ITIMES-EVAL$-ITIMES-TREE-INEG-OFF ITIMES-EVAL$-ITIMES-TREE-INEG T) (TOGGLE IPLUS-EVAL$-ITIMES-TREE-INEG-OFF IPLUS-EVAL$-ITIMES-TREE-INEG T) (TOGGLE INEG-EVAL$-ITIMES-TREE-INEG-OFF INEG-EVAL$-ITIMES-TREE-INEG T) (TOGGLE EVAL$-ITIMES-TREE-INEG-OFF EVAL$-ITIMES-TREE-INEG T) (TOGGLE FIX-INT-EVAL$-ITIMES-TREE-REC-OFF FIX-INT-EVAL$-ITIMES-TREE-REC T) (TOGGLE ILESSP-INEG-INEG-OFF ILESSP-INEG-INEG T) (TOGGLE EQUAL-INEG-INEG-OFF EQUAL-INEG-INEG T) (TOGGLE ITIMES--1-OFF ITIMES--1 T) (TOGGLE ITIMES-FACTORS-OFF ITIMES-FACTORS T) (TOGGLE G*1*ITIMES-FACTORS-OFF *1*ITIMES-FACTORS T) (TOGGLE G*1*ITIMES-TREE-INEG-OFF *1*ITIMES-TREE-INEG T) (TOGGLE ILESSP-STRICT-OFF ILESSP-STRICT T) (TOGGLE ILESSP-ITIMES-RIGHT-NEGATIVE-OFF ILESSP-ITIMES-RIGHT-NEGATIVE T) (TOGGLE ILESSP-ITIMES-RIGHT-POSITIVE-OFF ILESSP-ITIMES-RIGHT-POSITIVE T) (TOGGLE CANCEL-ITIMES-ILESSP-OFF CANCEL-ITIMES-ILESSP T) (TOGGLE G*1*CANCEL-ITIMES-ILESSP-OFF *1*CANCEL-ITIMES-ILESSP T) (TOGGLE G*1*MAKE-CANCEL-ITIMES-INEQUALITY-OFF *1*MAKE-CANCEL-ITIMES-INEQUALITY T) (TOGGLE G*1*ITIMES-TREE-NO-FIX-INT-OFF *1*ITIMES-TREE-NO-FIX-INT T) (TOGGLE SUBSETP-OFF SUBSETP T) (TOGGLE G*1*SUBSETP-OFF *1*SUBSETP T) (TOGGLE EQUAL-FIX-INT-OFF EQUAL-FIX-INT T) (TOGGLE MEMBER-APPEND-OFF MEMBER-APPEND T) (TOGGLE ITIMES-LIST-APPEND-OFF ITIMES-LIST-APPEND T) (TOGGLE CANCEL-ITIMES-OFF CANCEL-ITIMES T) (TOGGLE G*1*CANCEL-ITIMES-OFF *1*CANCEL-ITIMES T) (TOGGLE G*1*MAKE-CANCEL-ITIMES-EQUALITY-OFF *1*MAKE-CANCEL-ITIMES-EQUALITY T) (TOGGLE INTEGERP-ITIMES-LIST-OFF INTEGERP-ITIMES-LIST T) (TOGGLE ITIMES-LIST-OFF ITIMES-LIST T) (TOGGLE G*1*ITIMES-LIST-OFF *1*ITIMES-LIST T) (TOGGLE G*1*ITIMES-TREE-OFF *1*ITIMES-TREE T) (TOGGLE ITIMES-TREE-REC-OFF ITIMES-TREE-REC T) (TOGGLE G*1*ITIMES-TREE-REC-OFF *1*ITIMES-TREE-REC T) (TOGGLE ITIMES-FRINGE-OFF ITIMES-FRINGE T) (TOGGLE G*1*ITIMES-FRINGE-OFF *1*ITIMES-FRINGE T) (TOGGLE FIX-INT-IREM-OFF FIX-INT-IREM T) (TOGGLE FIX-INT-IQUO-OFF FIX-INT-IQUO T) (TOGGLE FIX-INT-IMOD-OFF FIX-INT-IMOD T) (TOGGLE FIX-INT-IDIV-OFF FIX-INT-IDIV T) (TOGGLE FIX-INT-IREMAINDER-OFF FIX-INT-IREMAINDER T) (TOGGLE FIX-INT-IQUOTIENT-OFF FIX-INT-IQUOTIENT T) (TOGGLE IREM-FIX-INT2-OFF IREM-FIX-INT2 T) (TOGGLE IREM-FIX-INT1-OFF IREM-FIX-INT1 T) (TOGGLE IQUO-FIX-INT2-OFF IQUO-FIX-INT2 T) (TOGGLE IQUO-FIX-INT1-OFF IQUO-FIX-INT1 T) (TOGGLE IMOD-FIX-INT2-OFF IMOD-FIX-INT2 T) (TOGGLE IMOD-FIX-INT1-OFF IMOD-FIX-INT1 T) (TOGGLE IDIV-FIX-INT2-OFF IDIV-FIX-INT2 T) (TOGGLE IDIV-FIX-INT1-OFF IDIV-FIX-INT1 T) (TOGGLE IREMAINDER-FIX-INT2-OFF IREMAINDER-FIX-INT2 T) (TOGGLE IREMAINDER-FIX-INT1-OFF IREMAINDER-FIX-INT1 T) (TOGGLE IQUOTIENT-FIX-INT2-OFF IQUOTIENT-FIX-INT2 T) (TOGGLE IQUOTIENT-FIX-INT1-OFF IQUOTIENT-FIX-INT1 T) (TOGGLE INTEGERP-IREM-OFF INTEGERP-IREM T) (TOGGLE INTEGERP-IQUO-OFF INTEGERP-IQUO T) (TOGGLE INTEGERP-IMOD-OFF INTEGERP-IMOD T) (TOGGLE INTEGERP-IDIV-OFF INTEGERP-IDIV T) (TOGGLE INTEGERP-IREMAINDER-OFF INTEGERP-IREMAINDER T) (TOGGLE INTEGERP-IQUOTIENT-OFF INTEGERP-IQUOTIENT T) (TOGGLE ITIMES-CANCELLATION-3-OFF ITIMES-CANCELLATION-3 T) (TOGGLE ITIMES-CANCELLATION-2-OFF ITIMES-CANCELLATION-2 T) (TOGGLE ITIMES-CANCELLATION-1-OFF ITIMES-CANCELLATION-1 T) (TOGGLE ITIMES-INEG-2-OFF ITIMES-INEG-2 T) (TOGGLE ITIMES-INEG-1-OFF ITIMES-INEG-1 T) (TOGGLE IQUO-IREM-UNIQUENESS-OFF IQUO-IREM-UNIQUENESS T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART3-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART3 T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART2-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART2 T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART1-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-ZERO-PART1 T) (TOGGLE IDIV-IMOD-UNIQUENESS-OFF IDIV-IMOD-UNIQUENESS T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART3-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART3 T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART2-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART2 T) (TOGGLE DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART1-OFF DIVISION-THEOREM-FOR-TRUNCATE-TO-NEGINF-PART1 T) (TOGGLE IQUOTIENT-IREMAINDER-UNIQUENESS-OFF IQUOTIENT-IREMAINDER-UNIQUENESS T) (TOGGLE DIVISION-THEOREM-OFF DIVISION-THEOREM T) (TOGGLE DIVISION-THEOREM-PART3-OFF DIVISION-THEOREM-PART3 T) (TOGGLE DIVISION-THEOREM-PART2-OFF DIVISION-THEOREM-PART2 T) (TOGGLE DIVISION-THEOREM-PART1-OFF DIVISION-THEOREM-PART1 T) (TOGGLE QUOTIENT-REMAINDER-UNIQUENESS-OFF QUOTIENT-REMAINDER-UNIQUENESS T) (TOGGLE ITIMES-1-ARG1-OFF ITIMES-1-ARG1 T) (TOGGLE EQUAL-ITIMES-MINUS-1-OFF EQUAL-ITIMES-MINUS-1 T) (TOGGLE EQUAL-ITIMES-1-OFF EQUAL-ITIMES-1 T) (TOGGLE EQUAL-ITIMES-0-OFF EQUAL-ITIMES-0 T) (TOGGLE ASSOCIATIVITY-OF-ITIMES-OFF ASSOCIATIVITY-OF-ITIMES T) (TOGGLE COMMUTATIVITY2-OF-ITIMES-OFF COMMUTATIVITY2-OF-ITIMES T) (TOGGLE ITIMES-DISTRIBUTES-OVER-IPLUS-OFF ITIMES-DISTRIBUTES-OVER-IPLUS T) (TOGGLE ITIMES-DISTRIBUTES-OVER-IPLUS-PROOF-OFF ITIMES-DISTRIBUTES-OVER-IPLUS-PROOF T) (TOGGLE COMMUTATIVITY-OF-ITIMES-OFF COMMUTATIVITY-OF-ITIMES T) (TOGGLE ITIMES-FIX-INT2-OFF ITIMES-FIX-INT2 T) (TOGGLE ITIMES-FIX-INT1-OFF ITIMES-FIX-INT1 T) (TOGGLE ITIMES-0-RIGHT-OFF ITIMES-0-RIGHT T) (TOGGLE ITIMES-0-LEFT-OFF ITIMES-0-LEFT T) (TOGGLE CORRECTNESS-OF-CANCEL-IPLUS-ILESSP-OFF CORRECTNESS-OF-CANCEL-IPLUS-ILESSP T) (TOGGLE CANCEL-IPLUS-ILESSP-OFF CANCEL-IPLUS-ILESSP T) (TOGGLE G*1*CANCEL-IPLUS-ILESSP-OFF *1*CANCEL-IPLUS-ILESSP T) (TOGGLE G*1*IPLUS-TREE-NO-FIX-INT-OFF *1*IPLUS-TREE-NO-FIX-INT T) (TOGGLE IPLUS-CANCELLATION-2-FOR-ILESSP-OFF IPLUS-CANCELLATION-2-FOR-ILESSP T) (TOGGLE IPLUS-CANCELLATION-1-FOR-ILESSP-OFF IPLUS-CANCELLATION-1-FOR-ILESSP T) (TOGGLE CANCEL-IPLUS-ILESSP-1-OFF CANCEL-IPLUS-ILESSP-1 T) (TOGGLE G*1*CANCEL-IPLUS-ILESSP-1-OFF *1*CANCEL-IPLUS-ILESSP-1 T) (TOGGLE G*1*MAKE-CANCEL-IPLUS-INEQUALITY-1-OFF *1*MAKE-CANCEL-IPLUS-INEQUALITY-1 T) (TOGGLE ILESSP-FIX-INT-2-OFF ILESSP-FIX-INT-2 T) (TOGGLE ILESSP-FIX-INT-1-OFF ILESSP-FIX-INT-1 T) (TOGGLE CORRECTNESS-OF-CANCEL-IPLUS-OFF CORRECTNESS-OF-CANCEL-IPLUS T) (TOGGLE IPLUS-INEG7-OFF IPLUS-INEG7 T) (TOGGLE IPLUS-LIST-APPEND-OFF IPLUS-LIST-APPEND T) (TOGGLE EVAL$-IPLUS-LIST-DELETE-OFF EVAL$-IPLUS-LIST-DELETE T) (TOGGLE G*1*CANCEL-IPLUS-OFF *1*CANCEL-IPLUS T) (TOGGLE EVAL$-LIST-APPEND-OFF EVAL$-LIST-APPEND T) (TOGGLE INTEGERP-IPLUS-LIST-OFF INTEGERP-IPLUS-LIST T) (TOGGLE IPLUS-LIST-OFF IPLUS-LIST T) (TOGGLE G*1*IPLUS-LIST-OFF *1*IPLUS-LIST T) (TOGGLE G*1*IPLUS-TREE-OFF *1*IPLUS-TREE T) (TOGGLE IPLUS-TREE-REC-OFF IPLUS-TREE-REC T) (TOGGLE G*1*IPLUS-TREE-REC-OFF *1*IPLUS-TREE-REC T) (TOGGLE IPLUS-FRINGE-OFF IPLUS-FRINGE T) (TOGGLE G*1*IPLUS-FRINGE-OFF *1*IPLUS-FRINGE T) (TOGGLE CORRECTNESS-OF-CANCEL-INEG-OFF CORRECTNESS-OF-CANCEL-INEG T) (TOGGLE IPLUS-X-Y-INEG-X-OFF IPLUS-X-Y-INEG-X T) (TOGGLE IPLUS-INEG4-OFF IPLUS-INEG4 T) (TOGGLE IPLUS-INEG3-OFF IPLUS-INEG3 T) (TOGGLE EVAL$-CANCEL-INEG-AUX-IS-ITS-FN-OFF EVAL$-CANCEL-INEG-AUX-IS-ITS-FN T) (TOGGLE EVAL$-CANCEL-INEG-AUX-FN-OFF EVAL$-CANCEL-INEG-AUX-FN T) (TOGGLE G*1*EVAL$-CANCEL-INEG-AUX-FN-OFF *1*EVAL$-CANCEL-INEG-AUX-FN T) (TOGGLE EVAL$-OTHER-OFF EVAL$-OTHER T) (TOGGLE EVAL$-LITATOM-OFF EVAL$-LITATOM T) (TOGGLE EVAL$-LIST-NLISTP-OFF EVAL$-LIST-NLISTP T) (TOGGLE EVAL$-LIST-CONS-OFF EVAL$-LIST-CONS T) (TOGGLE CANCEL-INEG-OFF CANCEL-INEG T) (TOGGLE G*1*CANCEL-INEG-OFF *1*CANCEL-INEG T) (TOGGLE CANCEL-INEG-AUX-OFF CANCEL-INEG-AUX T) (TOGGLE G*1*CANCEL-INEG-AUX-OFF *1*CANCEL-INEG-AUX T) (TOGGLE IDIFFERENCE-FIX-INT2-OFF IDIFFERENCE-FIX-INT2 T) (TOGGLE IDIFFERENCE-FIX-INT1-OFF IDIFFERENCE-FIX-INT1 T) (TOGGLE IPLUS-FIX-INT2-OFF IPLUS-FIX-INT2 T) (TOGGLE IPLUS-FIX-INT1-OFF IPLUS-FIX-INT1 T) (TOGGLE IPLUS-INEG2-OFF IPLUS-INEG2 T) (TOGGLE IPLUS-INEG1-OFF IPLUS-INEG1 T) (TOGGLE IPLUS-CANCELLATION-2-OFF IPLUS-CANCELLATION-2 T) (TOGGLE IPLUS-CANCELLATION-1-OFF IPLUS-CANCELLATION-1 T) (TOGGLE ASSOCIATIVITY-OF-IPLUS-OFF ASSOCIATIVITY-OF-IPLUS T) (TOGGLE COMMUTATIVITY-OF-IPLUS-OFF COMMUTATIVITY-OF-IPLUS T) (TOGGLE COMMUTATIVITY2-OF-IPLUS-OFF COMMUTATIVITY2-OF-IPLUS T) (TOGGLE IPLUS-0-RIGHT-OFF IPLUS-0-RIGHT T) (TOGGLE IPLUS-0-LEFT-OFF IPLUS-0-LEFT T) (TOGGLE INEG-0-OFF INEG-0 T) (TOGGLE INEG-FIX-INT-OFF INEG-FIX-INT T) (TOGGLE INEG-INEG-OFF INEG-INEG T) (TOGGLE INEG-IPLUS-OFF INEG-IPLUS T) (TOGGLE FIX-INT-ITIMES-OFF FIX-INT-ITIMES T) (TOGGLE FIX-INT-IABS-OFF FIX-INT-IABS T) (TOGGLE FIX-INT-INEG-OFF FIX-INT-INEG T) (TOGGLE FIX-INT-IDIFFERENCE-OFF FIX-INT-IDIFFERENCE T) (TOGGLE FIX-INT-IPLUS-OFF FIX-INT-IPLUS T) (TOGGLE FIX-INT-FIX-INT-OFF FIX-INT-FIX-INT T) (TOGGLE FIX-INT-REMOVER-OFF FIX-INT-REMOVER T) (TOGGLE INTEGERP-ITIMES-OFF INTEGERP-ITIMES T) (TOGGLE INTEGERP-IABS-OFF INTEGERP-IABS T) (TOGGLE INTEGERP-INEG-OFF INTEGERP-INEG T) (TOGGLE INTEGERP-IDIFFERENCE-OFF INTEGERP-IDIFFERENCE T) (TOGGLE INTEGERP-IPLUS-OFF INTEGERP-IPLUS T) (TOGGLE INTEGERP-FIX-INT-OFF INTEGERP-FIX-INT T) (TOGGLE G*1*IREM-OFF *1*IREM T) (TOGGLE G*1*IQUO-OFF *1*IQUO T) (TOGGLE G*1*IMOD-OFF *1*IMOD T) (TOGGLE G*1*IDIV-OFF *1*IDIV T) (TOGGLE G*1*IREMAINDER-OFF *1*IREMAINDER T) (TOGGLE G*1*IQUOTIENT-OFF *1*IQUOTIENT T) (TOGGLE G*1*ITIMES-OFF *1*ITIMES T) (TOGGLE G*1*IABS-OFF *1*IABS T) (TOGGLE IDIFFERENCE-OFF IDIFFERENCE T) (TOGGLE G*1*IDIFFERENCE-OFF *1*IDIFFERENCE T) (TOGGLE G*1*INEG-OFF *1*INEG T) (TOGGLE G*1*IPLUS-OFF *1*IPLUS T) (TOGGLE ILEQ-OFF ILEQ T) (TOGGLE G*1*ILEQ-OFF *1*ILEQ T) (TOGGLE G*1*ILESSP-OFF *1*ILESSP T) (TOGGLE IZEROP-OFF IZEROP T) (TOGGLE G*1*IZEROP-OFF *1*IZEROP T) (TOGGLE G*1*FIX-INT-OFF *1*FIX-INT T) (TOGGLE G*1*INTEGERP-OFF *1*INTEGERP T) (TOGGLE GCD-IDEMPOTENCE-OFF GCD-IDEMPOTENCE T) (TOGGLE GCD-X-X-OFF GCD-X-X T) (TOGGLE COMMUTATIVITY2-OF-GCD-OFF COMMUTATIVITY2-OF-GCD T) (TOGGLE COMMUTATIVITY2-OF-GCD-ZERO-CASE-OFF COMMUTATIVITY2-OF-GCD-ZERO-CASE T) (TOGGLE ASSOCIATIVITY-OF-GCD-OFF ASSOCIATIVITY-OF-GCD T) (TOGGLE ASSOCIATIVITY-OF-GCD-ZERO-CASE-OFF ASSOCIATIVITY-OF-GCD-ZERO-CASE T) (TOGGLE COMMON-DIVISOR-DIVIDES-GCD-OFF COMMON-DIVISOR-DIVIDES-GCD T) (TOGGLE GCD-IS-THE-GREATEST-OFF GCD-IS-THE-GREATEST T) (TOGGLE DISTRIBUTIVITY-OF-TIMES-OVER-GCD-OFF DISTRIBUTIVITY-OF-TIMES-OVER-GCD T) (TOGGLE DISTRIBUTIVITY-OF-TIMES-OVER-GCD-PROOF-OFF DISTRIBUTIVITY-OF-TIMES-OVER-GCD-PROOF T) (TOGGLE REMAINDER-GCD-OFF REMAINDER-GCD T) (TOGGLE GCD-PLUS-INSTANCE-OFF GCD-PLUS-INSTANCE T) (TOGGLE GCD-PLUS-OFF GCD-PLUS T) (TOGGLE GCD-PLUS-PROOF-OFF GCD-PLUS-PROOF T) (TOGGLE GCD-PLUS-INSTANCE-TEMP-OFF GCD-PLUS-INSTANCE-TEMP T) (TOGGLE GCD-PLUS-INSTANCE-TEMP-PROOF-OFF GCD-PLUS-INSTANCE-TEMP-PROOF T) (TOGGLE LESSP-GCD-OFF LESSP-GCD T) (TOGGLE EQUAL-GCD-0-OFF EQUAL-GCD-0 T) (TOGGLE GCD-1-OFF GCD-1 T) (TOGGLE GCD-0-OFF GCD-0 T) (TOGGLE SINGLE-NUMBER-INDUCTION-OFF SINGLE-NUMBER-INDUCTION T) (TOGGLE G*1*SINGLE-NUMBER-INDUCTION-OFF *1*SINGLE-NUMBER-INDUCTION T) (TOGGLE COMMUTATIVITY-OF-GCD-OFF COMMUTATIVITY-OF-GCD T) (TOGGLE LOG-EXP-OFF LOG-EXP T) (TOGGLE LOG-TIMES-EXP-OFF LOG-TIMES-EXP T) (TOGGLE LOG-TIMES-EXP-PROOF-OFF LOG-TIMES-EXP-PROOF T) (TOGGLE LOG-TIMES-OFF LOG-TIMES T) (TOGGLE LOG-TIMES-PROOF-OFF LOG-TIMES-PROOF T) (TOGGLE LOG-QUOTIENT-EXP-OFF LOG-QUOTIENT-EXP T) (TOGGLE LOG-QUOTIENT-TIMES-OFF LOG-QUOTIENT-TIMES T) (TOGGLE LOG-QUOTIENT-TIMES-PROOF-OFF LOG-QUOTIENT-TIMES-PROOF T) (TOGGLE LOG-QUOTIENT-OFF LOG-QUOTIENT T) (TOGGLE LEQ-LOG-LOG-OFF LEQ-LOG-LOG T) (TOGGLE DOUBLE-LOG-INDUCTION-OFF DOUBLE-LOG-INDUCTION T) (TOGGLE G*1*DOUBLE-LOG-INDUCTION-OFF *1*DOUBLE-LOG-INDUCTION T) (TOGGLE LOG-1-OFF LOG-1 T) (TOGGLE LOG-0-OFF LOG-0 T) (TOGGLE EQUAL-LOG-0-OFF EQUAL-LOG-0 T) (TOGGLE EXP-DIFFERENCE-OFF EXP-DIFFERENCE T) (TOGGLE EQUAL-EXP-1-OFF EQUAL-EXP-1 T) (TOGGLE EQUAL-EXP-0-OFF EQUAL-EXP-0 T) (TOGGLE EXP-EXP-OFF EXP-EXP T) (TOGGLE EXP-TIMES-OFF EXP-TIMES T) (TOGGLE EXP-0-ARG2-OFF EXP-0-ARG2 T) (TOGGLE EXP-1-ARG1-OFF EXP-1-ARG1 T) (TOGGLE EXP-0-ARG1-OFF EXP-0-ARG1 T) (TOGGLE EXP-PLUS-OFF EXP-PLUS T) (TOGGLE EXP-ADD1-OFF EXP-ADD1 T) (TOGGLE EXP-ZERO-OFF EXP-ZERO T) (TOGGLE QUOTIENT-EXP-OFF QUOTIENT-EXP T) (TOGGLE REMAINDER-EXP-EXP-OFF REMAINDER-EXP-EXP T) (TOGGLE DOUBLE-NUMBER-INDUCTION-OFF DOUBLE-NUMBER-INDUCTION T) (TOGGLE G*1*DOUBLE-NUMBER-INDUCTION-OFF *1*DOUBLE-NUMBER-INDUCTION T) (TOGGLE REMAINDER-EXP-OFF REMAINDER-EXP T) (TOGGLE GCD-OFF GCD T) (TOGGLE G*1*GCD-OFF *1*GCD T) (TOGGLE LOG-OFF LOG T) (TOGGLE G*1*LOG-OFF *1*LOG T) (TOGGLE EXP-OFF EXP T) (TOGGLE G*1*EXP-OFF *1*EXP T) (TOGGLE CORRECTNESS-OF-CANCEL-QUOTIENT-TIMES-OFF CORRECTNESS-OF-CANCEL-QUOTIENT-TIMES T) (TOGGLE CANCEL-QUOTIENT-TIMES-OFF CANCEL-QUOTIENT-TIMES T) (TOGGLE G*1*CANCEL-QUOTIENT-TIMES-OFF *1*CANCEL-QUOTIENT-TIMES T) (TOGGLE LESSP-QUOTIENT-OFF LESSP-QUOTIENT T) (TOGGLE QUOTIENT-X-X-OFF QUOTIENT-X-X T) (TOGGLE QUOTIENT-1-ARG1-OFF QUOTIENT-1-ARG1 T) (TOGGLE QUOTIENT-1-ARG1-CASESPLIT-OFF QUOTIENT-1-ARG1-CASESPLIT T) (TOGGLE QUOTIENT-1-ARG2-OFF QUOTIENT-1-ARG2 T) (TOGGLE LEQ-QUOTIENT-OFF LEQ-QUOTIENT T) (TOGGLE QUOTIENT-QUOTIENT-OFF QUOTIENT-QUOTIENT T) (TOGGLE QUOTIENT-PLUS-TIMES-TIMES-INSTANCE-OFF QUOTIENT-PLUS-TIMES-TIMES-INSTANCE T) (TOGGLE QUOTIENT-PLUS-TIMES-TIMES-OFF QUOTIENT-PLUS-TIMES-TIMES T) (TOGGLE QUOTIENT-PLUS-TIMES-TIMES-PROOF-OFF QUOTIENT-PLUS-TIMES-TIMES-PROOF T) (TOGGLE QUOTIENT-PLUS-FACT-OFF QUOTIENT-PLUS-FACT T) (TOGGLE QUOTIENT-REMAINDER-INSTANCE-OFF QUOTIENT-REMAINDER-INSTANCE T) (TOGGLE QUOTIENT-REMAINDER-OFF QUOTIENT-REMAINDER T) (TOGGLE QUOTIENT-REMAINDER-TIMES-OFF QUOTIENT-REMAINDER-TIMES T) (TOGGLE QUOTIENT-DIFFERENCE3-OFF QUOTIENT-DIFFERENCE3 T) (TOGGLE QUOTIENT-DIFFERENCE2-OFF QUOTIENT-DIFFERENCE2 T) (TOGGLE QUOTIENT-LESSP-ARG1-OFF QUOTIENT-LESSP-ARG1 T) (TOGGLE QUOTIENT-DIFFERENCE1-OFF QUOTIENT-DIFFERENCE1 T) (TOGGLE QUOTIENT-TIMES-TIMES-PROOF-OFF QUOTIENT-TIMES-TIMES-PROOF T) (TOGGLE QUOTIENT-TIMES-INSTANCE-OFF QUOTIENT-TIMES-INSTANCE T) (TOGGLE QUOTIENT-TIMES-OFF QUOTIENT-TIMES T) (TOGGLE QUOTIENT-TIMES-PROOF-OFF QUOTIENT-TIMES-PROOF T) (TOGGLE QUOTIENT-TIMES-INSTANCE-TEMP-PROOF-OFF QUOTIENT-TIMES-INSTANCE-TEMP-PROOF T) (TOGGLE QUOTIENT-PLUS-OFF QUOTIENT-PLUS T) (TOGGLE QUOTIENT-PLUS-PROOF-OFF QUOTIENT-PLUS-PROOF T) (TOGGLE QUOTIENT-SUB1-OFF QUOTIENT-SUB1 T) (TOGGLE EQUAL-QUOTIENT-0-OFF EQUAL-QUOTIENT-0 T) (TOGGLE QUOTIENT-ADD1-OFF QUOTIENT-ADD1 T) (TOGGLE QUOTIENT-ZERO-OFF QUOTIENT-ZERO T) (TOGGLE QUOTIENT-OF-NON-NUMBER-OFF QUOTIENT-OF-NON-NUMBER T) (TOGGLE QUOTIENT-NOOP-OFF QUOTIENT-NOOP T) (TOGGLE TRANSITIVITY-OF-DIVIDES-OFF TRANSITIVITY-OF-DIVIDES T) (TOGGLE REMAINDER-X-X-OFF REMAINDER-X-X T) (TOGGLE REMAINDER-1-ARG2-OFF REMAINDER-1-ARG2 T) (TOGGLE REMAINDER-1-ARG1-OFF REMAINDER-1-ARG1 T) (TOGGLE REMAINDER-REMAINDER-OFF REMAINDER-REMAINDER T) (TOGGLE REMAINDER-PLUS-TIMES-TIMES-INSTANCE-OFF REMAINDER-PLUS-TIMES-TIMES-INSTANCE T) (TOGGLE REMAINDER-PLUS-TIMES-TIMES-OFF REMAINDER-PLUS-TIMES-TIMES T) (TOGGLE REMAINDER-PLUS-TIMES-TIMES-PROOF-OFF REMAINDER-PLUS-TIMES-TIMES-PROOF T) (TOGGLE REMAINDER-PLUS-FACT-OFF REMAINDER-PLUS-FACT T) (TOGGLE REMAINDER-DIFFERENCE2-OFF REMAINDER-DIFFERENCE2 T) (TOGGLE DOUBLE-REMAINDER-INDUCTION-OFF DOUBLE-REMAINDER-INDUCTION T) (TOGGLE G*1*DOUBLE-REMAINDER-INDUCTION-OFF *1*DOUBLE-REMAINDER-INDUCTION T) (TOGGLE REMAINDER-DIFFERENCE1-OFF REMAINDER-DIFFERENCE1 T) (TOGGLE REMAINDER-TIMES2-INSTANCE-OFF REMAINDER-TIMES2-INSTANCE T) (TOGGLE REMAINDER-TIMES2-OFF REMAINDER-TIMES2 T) (TOGGLE REMAINDER-TIMES2-PROOF-OFF REMAINDER-TIMES2-PROOF T) (TOGGLE REMAINDER-TIMES-TIMES-PROOF-OFF REMAINDER-TIMES-TIMES-PROOF T) (TOGGLE REMAINDER-TIMES1-INSTANCE-OFF REMAINDER-TIMES1-INSTANCE T) (TOGGLE REMAINDER-TIMES1-INSTANCE-PROOF-OFF REMAINDER-TIMES1-INSTANCE-PROOF T) (TOGGLE REMAINDER-TIMES1-OFF REMAINDER-TIMES1 T) (TOGGLE REMAINDER-TIMES1-PROOF-OFF REMAINDER-TIMES1-PROOF T) (TOGGLE EQUAL-REMAINDER-PLUS-REMAINDER-PROOF-OFF EQUAL-REMAINDER-PLUS-REMAINDER-PROOF T) (TOGGLE EQUAL-REMAINDER-PLUS-0-OFF EQUAL-REMAINDER-PLUS-0 T) (TOGGLE EQUAL-REMAINDER-PLUS-0-PROOF-OFF EQUAL-REMAINDER-PLUS-0-PROOF T) (TOGGLE REMAINDER-PLUS-OFF REMAINDER-PLUS T) (TOGGLE REMAINDER-PLUS-PROOF-OFF REMAINDER-PLUS-PROOF T) (TOGGLE REMAINDER-ADD1-OFF REMAINDER-ADD1 T) (TOGGLE REMAINDER-QUOTIENT-ELIM-OFF REMAINDER-QUOTIENT-ELIM T) (TOGGLE REMAINDER-ZERO-OFF REMAINDER-ZERO T) (TOGGLE REMAINDER-OF-NON-NUMBER-OFF REMAINDER-OF-NON-NUMBER T) (TOGGLE REMAINDER-NOOP-OFF REMAINDER-NOOP T) (TOGGLE LESSP-REMAINDER-OFF LESSP-REMAINDER T) (TOGGLE CORRECTNESS-OF-CANCEL-EQUAL-TIMES-OFF CORRECTNESS-OF-CANCEL-EQUAL-TIMES T) (TOGGLE CANCEL-EQUAL-TIMES-OFF CANCEL-EQUAL-TIMES T) (TOGGLE G*1*CANCEL-EQUAL-TIMES-OFF *1*CANCEL-EQUAL-TIMES T) (TOGGLE CORRECTNESS-OF-CANCEL-LESSP-TIMES-OFF CORRECTNESS-OF-CANCEL-LESSP-TIMES T) (TOGGLE CANCEL-LESSP-TIMES-OFF CANCEL-LESSP-TIMES T) (TOGGLE G*1*CANCEL-LESSP-TIMES-OFF *1*CANCEL-LESSP-TIMES T) (TOGGLE INFER-EQUALITY-FROM-NOT-LESSP-OFF INFER-EQUALITY-FROM-NOT-LESSP T) (TOGGLE LESSP-TIMES-ARG1-OFF LESSP-TIMES-ARG1 T) (TOGGLE EVAL$-EQUAL-OFF1 EVAL$-EQUAL T) (TOGGLE AND-NOT-ZEROP-TREE-OFF AND-NOT-ZEROP-TREE T) (TOGGLE G*1*AND-NOT-ZEROP-TREE-OFF *1*AND-NOT-ZEROP-TREE T) (TOGGLE OR-ZEROP-TREE-OFF OR-ZEROP-TREE T) (TOGGLE G*1*OR-ZEROP-TREE-OFF *1*OR-ZEROP-TREE T) (TOGGLE TIMES-FRINGE-OFF TIMES-FRINGE T) (TOGGLE G*1*TIMES-FRINGE-OFF *1*TIMES-FRINGE T) (TOGGLE TIMES-TREE-OFF TIMES-TREE T) (TOGGLE G*1*TIMES-TREE-OFF *1*TIMES-TREE T) (TOGGLE LESSP-1-TIMES-OFF LESSP-1-TIMES T) (TOGGLE LESSP-PLUS-TIMES2-OFF LESSP-PLUS-TIMES2 T) (TOGGLE LESSP-PLUS-TIMES1-OFF LESSP-PLUS-TIMES1 T) (TOGGLE LESSP-PLUS-TIMES-PROOF-OFF LESSP-PLUS-TIMES-PROOF T) (TOGGLE LESSP-TIMES-CANCELLATION-PROOF-OFF LESSP-TIMES-CANCELLATION-PROOF T) (TOGGLE LESSP-TIMES3-OFF LESSP-TIMES3 T) (TOGGLE LESSP-TIMES3-PROOF2-OFF LESSP-TIMES3-PROOF2 T) (TOGGLE LESSP-TIMES3-PROOF1-OFF LESSP-TIMES3-PROOF1 T) (TOGGLE LESSP-TIMES2-OFF LESSP-TIMES2 T) (TOGGLE LESSP-TIMES2-PROOF-OFF LESSP-TIMES2-PROOF T) (TOGGLE LESSP-TIMES1-OFF LESSP-TIMES1 T) (TOGGLE LESSP-TIMES1-PROOF-OFF LESSP-TIMES1-PROOF T) (TOGGLE TIMES-1-ARG1-OFF TIMES-1-ARG1 T) (TOGGLE TIMES-QUOTIENT-OFF TIMES-QUOTIENT T) (TOGGLE TIMES-QUOTIENT-PROOF-OFF TIMES-QUOTIENT-PROOF T) (TOGGLE TIMES-DISTRIBUTES-OVER-DIFFERENCE-OFF TIMES-DISTRIBUTES-OVER-DIFFERENCE T) (TOGGLE TIMES-DISTRIBUTES-OVER-DIFFERENCE-PROOF-OFF TIMES-DISTRIBUTES-OVER-DIFFERENCE-PROOF T) (TOGGLE ASSOCIATIVITY-OF-TIMES-OFF ASSOCIATIVITY-OF-TIMES T) (TOGGLE COMMUTATIVITY2-OF-TIMES-OFF COMMUTATIVITY2-OF-TIMES T) (TOGGLE TIMES-DISTRIBUTES-OVER-PLUS-OFF TIMES-DISTRIBUTES-OVER-PLUS T) (TOGGLE TIMES-DISTRIBUTES-OVER-PLUS-PROOF-OFF TIMES-DISTRIBUTES-OVER-PLUS-PROOF T) (TOGGLE COMMUTATIVITY-OF-TIMES-OFF COMMUTATIVITY-OF-TIMES T) (TOGGLE TIMES-ADD1-OFF TIMES-ADD1 T) (TOGGLE TIMES-ZERO-OFF TIMES-ZERO T) (TOGGLE EQUAL-SUB1-0-OFF EQUAL-SUB1-0 T) (TOGGLE EQUAL-TIMES-1-OFF EQUAL-TIMES-1 T) (TOGGLE EQUAL-TIMES-0-OFF EQUAL-TIMES-0 T) (TOGGLE CORRECTNESS-OF-CANCEL-LESSP-PLUS-OFF CORRECTNESS-OF-CANCEL-LESSP-PLUS T) (TOGGLE CANCEL-LESSP-PLUS-OFF CANCEL-LESSP-PLUS T) (TOGGLE G*1*CANCEL-LESSP-PLUS-OFF *1*CANCEL-LESSP-PLUS T) (TOGGLE DIFFERENCE-X-X-OFF DIFFERENCE-X-X T) (TOGGLE DIFFERENCE-DIFFERENCE-ARG2-OFF DIFFERENCE-DIFFERENCE-ARG2 T) (TOGGLE DIFFERENCE-DIFFERENCE-ARG1-OFF DIFFERENCE-DIFFERENCE-ARG1 T) (TOGGLE DIFFERENCE-SUB1-ARG2-OFF DIFFERENCE-SUB1-ARG2 T) (TOGGLE DIFFERENCE-ADD1-ARG2-OFF DIFFERENCE-ADD1-ARG2 T) (TOGGLE DIFFERENCE-LEQ-ARG1-OFF DIFFERENCE-LEQ-ARG1 T) (TOGGLE DIFFERENCE-ELIM-OFF DIFFERENCE-ELIM T) (TOGGLE CORRECTNESS-OF-CANCEL-DIFFERENCE-PLUS-OFF CORRECTNESS-OF-CANCEL-DIFFERENCE-PLUS T) (TOGGLE CANCEL-DIFFERENCE-PLUS-OFF CANCEL-DIFFERENCE-PLUS T) (TOGGLE G*1*CANCEL-DIFFERENCE-PLUS-OFF *1*CANCEL-DIFFERENCE-PLUS T) (TOGGLE CORRECTNESS-OF-CANCEL-EQUAL-PLUS-OFF CORRECTNESS-OF-CANCEL-EQUAL-PLUS T) (TOGGLE CANCEL-EQUAL-PLUS-OFF CANCEL-EQUAL-PLUS T) (TOGGLE G*1*CANCEL-EQUAL-PLUS-OFF *1*CANCEL-EQUAL-PLUS T) (TOGGLE EVAL$-QUOTE-OFF1 EVAL$-QUOTE T) (TOGGLE PLUS-TREE-OFF PLUS-TREE T) (TOGGLE G*1*PLUS-TREE-OFF *1*PLUS-TREE T) (TOGGLE PLUS-FRINGE-OFF PLUS-FRINGE T) (TOGGLE G*1*PLUS-FRINGE-OFF *1*PLUS-FRINGE T) (TOGGLE DIFF-DIFF-ARG2-OFF DIFF-DIFF-ARG2 T) (TOGGLE DIFF-DIFF-ARG1-OFF DIFF-DIFF-ARG1 T) (TOGGLE DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF-OFF DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF T) (TOGGLE DIFFERENCE-PLUS-CANCELLATION-PROOF-OFF DIFFERENCE-PLUS-CANCELLATION-PROOF T) (TOGGLE PLUS-DIFFERENCE-ARG2-OFF PLUS-DIFFERENCE-ARG2 T) (TOGGLE PLUS-DIFFERENCE-ARG1-OFF PLUS-DIFFERENCE-ARG1 T) (TOGGLE ASSOCIATIVITY-OF-PLUS-OFF ASSOCIATIVITY-OF-PLUS T) (TOGGLE PLUS-ADD1-ARG2-OFF PLUS-ADD1-ARG2 T) (TOGGLE PLUS-ADD1-ARG1-OFF PLUS-ADD1-ARG1 T) (TOGGLE PLUS-ZERO-ARG2-OFF PLUS-ZERO-ARG2 T) (TOGGLE COMMUTATIVITY2-OF-PLUS-OFF COMMUTATIVITY2-OF-PLUS T) (TOGGLE COMMUTATIVITY-OF-PLUS-OFF COMMUTATIVITY-OF-PLUS T) (TOGGLE EQUAL-DIFFERENCE-0-OFF EQUAL-DIFFERENCE-0 T) (TOGGLE EQUAL-PLUS-0-OFF EQUAL-PLUS-0 T) (TOGGLE MEMBER-BAGINT-OFF MEMBER-BAGINT T) (TOGGLE OCCURRENCES-BAGDIFF-OFF OCCURRENCES-BAGDIFF T) (TOGGLE OCCURRENCES-BAGINT-OFF OCCURRENCES-BAGINT T) (TOGGLE SUBBAGP-BAGINT2-OFF SUBBAGP-BAGINT2 T) (TOGGLE SUBBAGP-BAGINT1-OFF SUBBAGP-BAGINT1 T) (TOGGLE SUBBAGP-CDR2-OFF SUBBAGP-CDR2 T) (TOGGLE SUBBAGP-CDR1-OFF SUBBAGP-CDR1 T) (TOGGLE SUBBAGP-DELETE-OFF SUBBAGP-DELETE T) (TOGGLE BAGDIFF-DELETE-OFF BAGDIFF-DELETE T) (TOGGLE MEMBER-BAGDIFF-OFF MEMBER-BAGDIFF T) (TOGGLE OCCURRENCES-DELETE-OFF OCCURRENCES-DELETE T) (TOGGLE MEMBER-DELETE-IMPLIES-MEMBERSHIP-OFF MEMBER-DELETE-IMPLIES-MEMBERSHIP T) (TOGGLE MEMBER-DELETE-OFF MEMBER-DELETE T) (TOGGLE MEMBER-NON-LIST-OFF MEMBER-NON-LIST T) (TOGGLE EQUAL-OCCURRENCES-ZERO-OFF EQUAL-OCCURRENCES-ZERO T) (TOGGLE DELETE-DELETE-OFF DELETE-DELETE T) (TOGGLE DELETE-NON-MEMBER-OFF DELETE-NON-MEMBER T) (TOGGLE SUBBAGP-OFF SUBBAGP T) (TOGGLE G*1*SUBBAGP-OFF *1*SUBBAGP T) (TOGGLE OCCURRENCES-OFF OCCURRENCES T) (TOGGLE G*1*OCCURRENCES-OFF *1*OCCURRENCES T) (TOGGLE BAGINT-OFF BAGINT T) (TOGGLE G*1*BAGINT-OFF *1*BAGINT T) (TOGGLE BAGDIFF-OFF BAGDIFF T) (TOGGLE G*1*BAGDIFF-OFF *1*BAGDIFF T) (TOGGLE DELETE-OFF DELETE T) (TOGGLE G*1*DELETE-OFF *1*DELETE T) (DEFN IF* (A B C) (IF A B C)) (TOGGLE IF*-OFF IF* T) (DEFN OR* (A B) (IF* A T (IF* B T F))) (TOGGLE OR*-OFF OR* T) (DEFN AND* (A B) (IF* A (IF* B T F) F)) (TOGGLE AND*-OFF AND* T) (DEFN NOT* (A) (IF* A F T)) (TOGGLE NOT*-OFF NOT* T) (DEFTHEORY PROP*-THEORY (OR* AND* NOT*)) (PROVE-LEMMA SIMPLIFY-IF* (REWRITE) (AND (IMPLIES C (EQUAL (IF* C A B) A)) (IMPLIES (NOT C) (EQUAL (IF* C A B) B))) ((ENABLE IF*))) (PROVE-LEMMA IF*-C-X-X (REWRITE) (EQUAL (IF* C X X) X) ((ENABLE IF*))) (PROVE-LEMMA IF*-CONS (REWRITE) (EQUAL (IF* A (CONS B C) (CONS D E)) (CONS (IF* A B D) (IF* A C E))) ((ENABLE IF*))) (PROVE-LEMMA REWRITE-NOT* (REWRITE) (AND (IMPLIES X (EQUAL (NOT* X) F)) (IMPLIES (NOT X) (EQUAL (NOT* X) T))) ((ENABLE IF* NOT*))) (PROVE-LEMMA REWRITE-AND* (REWRITE) (AND (EQUAL (AND* F X) F) (EQUAL (AND* X F) F) (IMPLIES Y (AND (EQUAL (AND* Y X) (IF* X T F)) (EQUAL (AND* X Y) (IF* X T F))))) ((ENABLE IF* AND*))) (PROVE-LEMMA REWRITE-OR* (REWRITE) (AND (EQUAL (OR* F X) (IF* X T F)) (EQUAL (OR* X F) (IF* X T F)) (IMPLIES Y (AND (EQUAL (OR* Y X) T) (EQUAL (OR* X Y) T)))) ((ENABLE IF* OR*))) (PROVE-LEMMA EXPAND-*-CONNECTIVES (REWRITE) (AND (EQUAL (IF* C A B) (IF C A B)) (EQUAL (OR* A B) (COND (A T) (B T) (T F))) (EQUAL (AND* A B) (IF A (IF B T F) F)) (EQUAL (NOT* A) (NOT A))) ((ENABLE IF* AND* OR* NOT*))) (TOGGLE EXPAND-*-CONNECTIVES-OFF EXPAND-*-CONNECTIVES T) (PROVE-LEMMA CAR-CDR-IF-CONS (REWRITE) (AND (EQUAL (CAR (IF X (CONS A B) (CONS C D))) (IF X A C)) (EQUAL (CDR (IF X (CONS A B) (CONS C D))) (IF X B D)))) (PROVE-LEMMA OUR-CAR-CDR-ELIM (REWRITE) (EQUAL (EQUAL L (CONS (CAR L) X)) (AND (LISTP L) (EQUAL X (CDR L))))) (TOGGLE OUR-CAR-CDR-ELIM-OFF OUR-CAR-CDR-ELIM T) (TOGGLE PLUS-OFF PLUS T) (PROVE-LEMMA PLUS-0 (REWRITE) (AND (IMPLIES (ZEROP ZERO) (EQUAL (PLUS X ZERO) (FIX X))) (IMPLIES (ZEROP ZERO) (EQUAL (PLUS ZERO X) (FIX X)))) ((ENABLE PLUS))) (PROVE-LEMMA PLUS-ADD1 (REWRITE) (AND (EQUAL (PLUS (ADD1 X) Y) (ADD1 (PLUS X Y))) (EQUAL (PLUS X (ADD1 Y)) (ADD1 (PLUS X Y))))) (PROVE-LEMMA PLUS-BOTTOM (REWRITE) (EQUAL (EQUAL (PLUS A B) 0) (AND (ZEROP A) (ZEROP B)))) (PROVE-LEMMA PLUS-ADD1-SUB1 (REWRITE) (AND (IMPLIES (NOT (ZEROP N)) (EQUAL (PLUS (SUB1 N) (ADD1 M)) (PLUS N M))) (IMPLIES (NOT (ZEROP N)) (EQUAL (PLUS (ADD1 M) (SUB1 N)) (PLUS M N))))) (TOGGLE DIFFERENCE-OFF DIFFERENCE T) (PROVE-LEMMA DIFFERENCE-X-1 (REWRITE) (EQUAL (DIFFERENCE X 1) (SUB1 X)) ((ENABLE DIFFERENCE))) (PROVE-LEMMA OUR-DIFFERENCE-X-X (REWRITE) (EQUAL (DIFFERENCE X X) 0) ((ENABLE DIFFERENCE))) (PROVE-LEMMA OUR-EQUAL-DIFFERENCE-0 (REWRITE) (EQUAL (EQUAL (DIFFERENCE X Y) 0) (IF (LESSP Y X) F T)) ((ENABLE DIFFERENCE))) (PROVE-LEMMA DIFFERENCE-0 (REWRITE) (IMPLIES (ZEROP Z) (EQUAL (DIFFERENCE X Z) (FIX X))) ((ENABLE DIFFERENCE))) (PROVE-LEMMA DIFFERENCE-ADD1-ADD1 (REWRITE) (EQUAL (DIFFERENCE (ADD1 X) (ADD1 Y)) (DIFFERENCE X Y)) ((ENABLE DIFFERENCE))) (PROVE-LEMMA NOT-LESSP-DIFFERENCE (REWRITE) (EQUAL (LESSP X (DIFFERENCE X Y)) F)) (PROVE-LEMMA LESSP-DIFFERENCE=0 (REWRITE) (IMPLIES (IF (LESSP Y X) F T) (EQUAL (DIFFERENCE X Y) 0))) (PROVE-LEMMA TIMES-BOTTOM (REWRITE) (EQUAL (EQUAL (TIMES X Y) 0) (OR (ZEROP X) (ZEROP Y)))) (PROVE-LEMMA TIMES-1 (REWRITE) (AND (EQUAL (TIMES A 1) (FIX A)) (EQUAL (TIMES 1 A) (FIX A)))) (PROVE-LEMMA TIMES-ADD1-AGAIN (REWRITE) (EQUAL (TIMES A (ADD1 B)) (PLUS A (TIMES A B)))) (PROVE-LEMMA TIMES-COMMUTES (REWRITE) (EQUAL (TIMES A B) (TIMES B A)) ((ENABLE PLUS))) (PROVE-LEMMA QUOTIENT-LESSP (REWRITE) (IMPLIES (AND (LESSP 1 BASE) (NOT (ZEROP N))) (LESSP (QUOTIENT N BASE) N))) (PROVE-LEMMA ZEROP-QUOTIENT (REWRITE) (EQUAL (EQUAL (QUOTIENT N M) 0) (OR (ZEROP N) (ZEROP M) (LESSP N M)))) (PROVE-LEMMA LESSP-X-X (REWRITE) (EQUAL (LESSP X X) F) ((ENABLE LESSP))) (PROVE-LEMMA LESSP-SUB1-X-Y-CROCK (REWRITE) (IMPLIES (EQUAL X Y) (EQUAL (LESSP (SUB1 X) Y) (NOT (ZEROP X)))) ((ENABLE LESSP))) (PROVE-LEMMA LESSP-SUB1-X-X (REWRITE) (EQUAL (LESSP (SUB1 X) X) (NOT (ZEROP X))) ((ENABLE LESSP))) (PROVE-LEMMA LESSP-X-1 (REWRITE) (EQUAL (LESSP X 1) (ZEROP X)) ((ENABLE LESSP))) (PROVE-LEMMA LEQ-LESSP-DIFFERENCE (REWRITE) (IMPLIES (AND (IF (LESSP Y X) F T) (NOT (ZEROP Z)) (NOT (ZEROP Y))) (EQUAL (LESSP (DIFFERENCE X Z) Y) T)) ((ENABLE DIFFERENCE))) (TOGGLE APPEND-OFF APPEND T) (DEFN APPEND5 (A B C D E) (APPEND A (APPEND B (APPEND C (APPEND D E))))) (DEFN APPEND6 (A B C D E G) (APPEND A (APPEND B (APPEND C (APPEND D (APPEND E G)))))) (DEFN APPEND7 (A B C D E G H) (APPEND A (APPEND B (APPEND C (APPEND D (APPEND E (APPEND G H))))))) (DEFN APPEND8 (A B C D E G H I) (APPEND A (APPEND B (APPEND C (APPEND D (APPEND E (APPEND G (APPEND H I)))))))) (PROVE-LEMMA APPEND-NLISTP (REWRITE) (IMPLIES (NLISTP A) (EQUAL (APPEND A B) B)) ((ENABLE APPEND))) (PROVE-LEMMA APPEND-CONS (REWRITE) (EQUAL (APPEND (CONS A B) C) (CONS A (APPEND B C))) ((ENABLE APPEND))) (PROVE-LEMMA OUR-MEMBER-APPEND (REWRITE) (EQUAL (MEMBER A (APPEND B C)) (OR (MEMBER A B) (MEMBER A C))) ((ENABLE APPEND))) (PROVE-LEMMA ASSOCIATIVITY-OF-APPEND (REWRITE) (EQUAL (APPEND (APPEND A B) C) (APPEND A (APPEND B C))) ((ENABLE APPEND))) (PROVE-LEMMA EQUAL-APPEND-X-X (REWRITE) (EQUAL (EQUAL (APPEND A B) (APPEND A C)) (EQUAL B C)) ((ENABLE APPEND))) (DEFN PROPERP (L) (IF (LISTP L) (PROPERP (CDR L)) (EQUAL L NIL))) (TOGGLE PROPERP-OFF PROPERP T) (PROVE-LEMMA PROPERP-IF (REWRITE) (IMPLIES (AND (PROPERP A) (PROPERP B)) (PROPERP (IF C A B)))) (PROVE-LEMMA PROPERP-NLISTP (REWRITE) (IMPLIES (NLISTP L) (EQUAL (PROPERP L) (EQUAL L NIL))) ((ENABLE PROPERP))) (PROVE-LEMMA PROPERP-CONS (REWRITE) (EQUAL (PROPERP (CONS X Y)) (PROPERP Y)) ((ENABLE PROPERP))) (PROVE-LEMMA PROPERP-APPEND (REWRITE) (EQUAL (PROPERP (APPEND A B)) (PROPERP B)) ((ENABLE PROPERP APPEND))) (PROVE-LEMMA PROPERP-APPEND-NIL (REWRITE) (IMPLIES (PROPERP A) (EQUAL (APPEND A NIL) A)) ((ENABLE APPEND))) (PROVE-LEMMA PROPERP-IF* (REWRITE) (IMPLIES (AND (PROPERP A) (PROPERP B)) (PROPERP (IF* C A B))) ((ENABLE IF*))) (DEFN POSITION (X L) (COND ((NLISTP L) F) ((EQUAL X (CAR L)) 0) ((POSITION X (CDR L)) (ADD1 (POSITION X (CDR L)))) (T F))) (TOGGLE POSITION-OFF POSITION T) (PROVE-LEMMA MEMBER==>POSITION (REWRITE) (IMPLIES (MEMBER X L) (POSITION X L)) ((ENABLE MEMBER POSITION))) (DEFN LENGTH (L) (IF (LISTP L) (ADD1 (LENGTH (CDR L))) 0)) (TOGGLE LENGTH-OFF LENGTH T) (PROVE-LEMMA LENGTH-NLISTP (REWRITE) (IMPLIES (NLISTP L) (EQUAL (LENGTH L) 0)) ((ENABLE LENGTH))) (PROVE-LEMMA LENGTH-BOTTOM (REWRITE) (EQUAL (EQUAL (LENGTH X) 0) (NLISTP X)) ((ENABLE LENGTH))) (PROVE-LEMMA LENGTH-1 (REWRITE) (EQUAL (EQUAL (LENGTH A) 1) (AND (LISTP A) (NLISTP (CDR A)))) ((ENABLE LENGTH))) (PROVE-LEMMA LENGTH-CONS (REWRITE) (EQUAL (LENGTH (CONS X Y)) (ADD1 (LENGTH Y))) ((ENABLE LENGTH))) (PROVE-LEMMA LENGTH-APPEND (REWRITE) (EQUAL (LENGTH (APPEND A B)) (PLUS (LENGTH A) (LENGTH B))) ((ENABLE LENGTH PLUS APPEND))) (PROVE-LEMMA LENGTH-CDR-LEMMAS (REWRITE) (AND (EQUAL (EQUAL (LENGTH (CDR X)) (LENGTH X)) (NLISTP X)) (EQUAL (LESSP (LENGTH (CDR X)) (LENGTH X)) (LISTP X))) ((ENABLE LESSP LENGTH))) (PROVE-LEMMA EQUAL-LENGTH-ADD1 (REWRITE) (EQUAL (EQUAL (LENGTH X) (ADD1 Y)) (AND (LISTP X) (EQUAL (LENGTH (CDR X)) (FIX Y)))) ((ENABLE LENGTH))) (TOGGLE EQUAL-LENGTH-ADD1-OFF EQUAL-LENGTH-ADD1 T) (PROVE-LEMMA LENGTH-CDR (REWRITE) (EQUAL (EQUAL (LENGTH (CDR V)) (SUB1 (LENGTH V))) T)) (PROVE-LEMMA EQUAL-LENGTH-CDR (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) T)) ((ENABLE LENGTH))) (PROVE-LEMMA LENGTH-IF (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (LENGTH (IF C A B)) (LENGTH A)))) (PROVE-LEMMA LENGTH-IF* (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (LENGTH (IF* C A B)) (LENGTH A))) ((ENABLE IF*))) (DEFN REV1 (X SPONGE) (IF (NLISTP X) SPONGE (REV1 (CDR X) (CONS (CAR X) SPONGE)))) (TOGGLE REV1-OFF REV1 T) (DEFN REVERSE (X) (REV1 X NIL)) (TOGGLE REVERSE-OFF REVERSE T) (PROVE-LEMMA LENGTH-REV1 (REWRITE) (EQUAL (LENGTH (REV1 X SPONGE)) (PLUS (LENGTH X) (LENGTH SPONGE))) ((ENABLE REV1))) (PROVE-LEMMA LENGTH-REVERSE (REWRITE) (EQUAL (LENGTH (REVERSE X)) (LENGTH X)) ((ENABLE REVERSE))) (DEFN DELETE* (X L) (COND ((NLISTP L) L) ((EQUAL X (CAR L)) (DELETE* X (CDR L))) (T (CONS (CAR L) (DELETE* X (CDR L)))))) (TOGGLE DELETE*-OFF DELETE* T) (DEFN SUBSET (L1 L2) (IF (NLISTP L1) T (AND (MEMBER (CAR L1) L2) (SUBSET (CDR L1) L2)))) (TOGGLE SUBSET-OFF SUBSET T) (PROVE-LEMMA SUBSET-NLISTP (REWRITE) (IMPLIES (NLISTP X) (SUBSET X Y)) ((ENABLE SUBSET))) (PROVE-LEMMA SUBSET-CONS (REWRITE) (EQUAL (SUBSET (CONS X Y) Z) (AND (MEMBER X Z) (SUBSET Y Z))) ((ENABLE SUBSET))) (PROVE-LEMMA SUBSET-X-CONS-Y-Z (REWRITE) (EQUAL (SUBSET X (CONS Y Z)) (OR (SUBSET X Z) (AND (MEMBER Y X) (SUBSET (DELETE* Y X) Z)))) ((ENABLE SUBSET DELETE*))) (PROVE-LEMMA SUBSET-APPEND (REWRITE) (IMPLIES (OR (SUBSET A B) (SUBSET A C)) (SUBSET A (APPEND B C))) ((ENABLE SUBSET APPEND))) (PROVE-LEMMA SUBSET-X-X (REWRITE) (SUBSET X X) ((ENABLE SUBSET))) (DEFN DISJOINT (L1 L2) (IF (NLISTP L1) T (AND (NOT (MEMBER (CAR L1) L2)) (DISJOINT (CDR L1) L2)))) (TOGGLE DISJOINT-OFF DISJOINT T) (PROVE-LEMMA DISJOINT-NLISTP (REWRITE) (IMPLIES (OR (NLISTP X) (NLISTP Y)) (DISJOINT X Y)) ((ENABLE DISJOINT))) (PROVE-LEMMA DISJOINT-CONS (REWRITE) (AND (EQUAL (DISJOINT (CONS X Y) Z) (AND (NOT (MEMBER X Z)) (DISJOINT Y Z))) (EQUAL (DISJOINT Z (CONS X Y)) (AND (NOT (MEMBER X Z)) (DISJOINT Z Y)))) ((ENABLE DISJOINT))) (PROVE-LEMMA DISJOINT-APPEND (REWRITE) (AND (EQUAL (DISJOINT X (APPEND Y Z)) (AND (DISJOINT X Y) (DISJOINT X Z))) (EQUAL (DISJOINT (APPEND Y Z) X) (AND (DISJOINT Y X) (DISJOINT Z X)))) ((ENABLE DISJOINT))) (DEFN DUPLICATES? (L) (IF (NLISTP L) F (OR (MEMBER (CAR L) (CDR L)) (DUPLICATES? (CDR L))))) (TOGGLE DUPLICATES?-OFF DUPLICATES? T) (PROVE-LEMMA DUPLICATES?-CONS (REWRITE) (EQUAL (DUPLICATES? (CONS X Y)) (OR (MEMBER X Y) (DUPLICATES? Y))) ((ENABLE DUPLICATES?))) (PROVE-LEMMA DUPLICATES-APPEND (REWRITE) (EQUAL (DUPLICATES? (APPEND A B)) (OR (DUPLICATES? A) (DUPLICATES? B) (NOT (DISJOINT A B)))) ((ENABLE DUPLICATES? DISJOINT APPEND))) (DEFN FIRSTN (N L) (IF (LISTP L) (IF (ZEROP N) NIL (CONS (CAR L) (FIRSTN (SUB1 N) (CDR L)))) NIL)) (TOGGLE FIRSTN-OFF FIRSTN T) (PROVE-LEMMA LENGTH-FIRSTN (REWRITE) (EQUAL (LENGTH (FIRSTN N L)) (IF (IF (LESSP (LENGTH L) N) F T) (FIX N) (LENGTH L))) ((ENABLE FIRSTN LENGTH LESSP))) (PROVE-LEMMA LENGTH-FIRSTN1 (REWRITE) (IMPLIES (IF (LESSP (LENGTH L) N) F T) (EQUAL (LENGTH (FIRSTN N L)) (FIX N))) ((ENABLE LENGTH-FIRSTN))) (PROVE-LEMMA LENGTH-FIRSTN2 (REWRITE) (IMPLIES (NOT (IF (LESSP (LENGTH L) N) F T)) (EQUAL (LENGTH (FIRSTN N L)) (LENGTH L))) ((ENABLE LENGTH-FIRSTN))) (PROVE-LEMMA CAR-FIRSTN (REWRITE) (EQUAL (CAR (FIRSTN N A)) (IF (AND (LISTP A) (NOT (ZEROP N))) (CAR A) 0)) ((ENABLE FIRSTN))) (PROVE-LEMMA NOT-MEMBER-FIRSTN (REWRITE) (IMPLIES (NOT (MEMBER X Y)) (NOT (MEMBER X (FIRSTN N Y)))) ((ENABLE FIRSTN))) (PROVE-LEMMA NOT-DUPLICATES?-FIRSTN (REWRITE) (IMPLIES (NOT (DUPLICATES? X)) (NOT (DUPLICATES? (FIRSTN N X)))) ((ENABLE DUPLICATES? FIRSTN))) (PROVE-LEMMA SUBSET-FIRSTN (REWRITE) (SUBSET (FIRSTN N L) L) ((ENABLE SUBSET FIRSTN))) (PROVE-LEMMA FIRSTN-BOTTOM (REWRITE) (EQUAL (EQUAL (FIRSTN N L) NIL) (OR (NLISTP L) (ZEROP N))) ((ENABLE FIRSTN))) (PROVE-LEMMA DISJOINT-FIRSTN (REWRITE) (IMPLIES (DISJOINT X Y) (DISJOINT (FIRSTN N X) Y)) ((ENABLE DISJOINT FIRSTN))) (PROVE-LEMMA DISJOINT-FIRSTN1 (REWRITE) (IMPLIES (DISJOINT Y X) (DISJOINT Y (FIRSTN N X))) ((ENABLE DISJOINT FIRSTN))) (PROVE-LEMMA PROPERP-FIRSTN (REWRITE) (PROPERP (FIRSTN N L)) ((ENABLE PROPERP FIRSTN))) (PROVE-LEMMA FIRSTN-APPEND (REWRITE) (EQUAL (FIRSTN N (APPEND A B)) (APPEND (FIRSTN N A) (FIRSTN (DIFFERENCE N (LENGTH A)) B))) ((INDUCT (FIRSTN N A)) (ENABLE FIRSTN APPEND LENGTH))) (DEFN RESTN (N L) (IF (LISTP L) (IF (ZEROP N) L (RESTN (SUB1 N) (CDR L))) L)) (TOGGLE RESTN-OFF RESTN T) (PROVE-LEMMA LENGTH-RESTN (REWRITE) (EQUAL (LENGTH (RESTN N L)) (DIFFERENCE (LENGTH L) N)) ((ENABLE RESTN LENGTH DIFFERENCE))) (PROVE-LEMMA NOT-DUPLICATES?-RESTN (REWRITE) (IMPLIES (NOT (DUPLICATES? X)) (NOT (DUPLICATES? (RESTN N X)))) ((ENABLE DUPLICATES? RESTN))) (PROVE-LEMMA NOT-MEMBER-RESTN (REWRITE) (IMPLIES (NOT (MEMBER X Y)) (NOT (MEMBER X (RESTN N Y)))) ((ENABLE RESTN))) (PROVE-LEMMA SUBSET-RESTN (REWRITE) (SUBSET (RESTN N L) L) ((ENABLE SUBSET RESTN))) (PROVE-LEMMA DISJOINT-RESTN (REWRITE) (IMPLIES (DISJOINT X Y) (DISJOINT (RESTN N X) Y)) ((ENABLE DISJOINT RESTN))) (PROVE-LEMMA DISJOINT-RESTN1 (REWRITE) (IMPLIES (DISJOINT Y X) (DISJOINT Y (RESTN N X))) ((ENABLE DISJOINT RESTN))) (PROVE-LEMMA PROPERP-RESTN (REWRITE) (EQUAL (PROPERP (RESTN N L)) (PROPERP L)) ((ENABLE PROPERP RESTN))) (PROVE-LEMMA RESTN-APPEND (REWRITE) (EQUAL (RESTN N (APPEND A B)) (APPEND (RESTN N A) (RESTN (DIFFERENCE N (LENGTH A)) B))) ((INDUCT (RESTN N A)) (ENABLE RESTN APPEND))) (PROVE-LEMMA TOO-MANY-RESTNS (REWRITE) (IMPLIES (AND (PROPERP L) (IF (LESSP N (LENGTH L)) F T)) (EQUAL (RESTN N L) NIL)) ((INDUCT (RESTN N L)) (ENABLE RESTN PROPERP))) (PROVE-LEMMA CDR-RESTN (REWRITE) (IMPLIES (LESSP N (LENGTH V)) (EQUAL (CDR (RESTN N V)) (RESTN (ADD1 N) V))) ((ENABLE RESTN LENGTH))) (TOGGLE CDR-RESTN-OFF CDR-RESTN T) (PROVE-LEMMA DISJOINT-FIRSTN-RESTN-LEMMAS (REWRITE) (AND (IMPLIES (DISJOINT X Y) (DISJOINT (FIRSTN N X) (FIRSTN M Y))) (IMPLIES (DISJOINT X Y) (DISJOINT (FIRSTN N X) (RESTN M Y))) (IMPLIES (DISJOINT X Y) (DISJOINT (RESTN N X) (FIRSTN M Y))) (IMPLIES (DISJOINT X Y) (DISJOINT (RESTN N X) (RESTN M Y)))) ((ENABLE DISJOINT FIRSTN RESTN))) (PROVE-LEMMA NO-DUPLICATES-DISJOINT-FIRSTN-RESTN (REWRITE) (AND (IMPLIES (NOT (DUPLICATES? X)) (DISJOINT (FIRSTN N X) (RESTN N X))) (IMPLIES (NOT (DUPLICATES? X)) (DISJOINT (RESTN N X) (FIRSTN N X)))) ((ENABLE DUPLICATES? DISJOINT RESTN FIRSTN))) (PROVE-LEMMA APPEND-FIRSTN-RESTN (REWRITE) (EQUAL (APPEND (FIRSTN N L) (RESTN N L)) L) ((ENABLE APPEND FIRSTN RESTN))) (TOGGLE PAIRLIST-OFF PAIRLIST T) (PROVE-LEMMA PAIRLIST-NLISTP (REWRITE) (IMPLIES (NLISTP A) (EQUAL (PAIRLIST A B) NIL)) ((ENABLE PAIRLIST))) (PROVE-LEMMA PAIRLIST-CONS (REWRITE) (EQUAL (PAIRLIST (CONS X Y) Z) (CONS (CONS X (CAR Z)) (PAIRLIST Y (CDR Z)))) ((ENABLE PAIRLIST))) (PROVE-LEMMA PAIRLIST-APPEND (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH C)) (EQUAL (PAIRLIST (APPEND A B) (APPEND C D)) (APPEND (PAIRLIST A C) (PAIRLIST B D)))) ((ENABLE PAIRLIST APPEND LENGTH))) (PROVE-LEMMA PROPERP-PAIRLIST (REWRITE) (PROPERP (PAIRLIST X Y)) ((ENABLE PAIRLIST))) (PROVE-LEMMA PAIRLISTS-ARE-EQUAL-WHEN-THEIR-2ND-LISTS-ARE-NLISTP (REWRITE) (IMPLIES (AND (NLISTP L1) (NLISTP L2)) (EQUAL (EQUAL (PAIRLIST A L1) (PAIRLIST A L2)) T)) ((ENABLE PAIRLIST))) (DEFN NTH (N LIST) (IF (ZEROP N) (CAR LIST) (NTH (SUB1 N) (CDR LIST)))) (TOGGLE NTH-OFF NTH T) (PROVE-LEMMA OPEN-NTH (REWRITE) (AND (IMPLIES (ZEROP N) (EQUAL (NTH N LIST) (CAR LIST))) (IMPLIES (NOT (ZEROP N)) (EQUAL (NTH N LIST) (NTH (SUB1 N) (CDR LIST))))) ((ENABLE NTH))) (TOGGLE OPEN-NTH-OFF OPEN-NTH T) (PROVE-LEMMA NTH-IF (REWRITE) (EQUAL (NTH N (IF A B C)) (IF A (NTH N B) (NTH N C)))) (TOGGLE NTH-IF-OFF NTH-IF T) (PROVE-LEMMA NTH-RESTN (REWRITE) (EQUAL (NTH N V) (CAR (RESTN N V))) ((ENABLE LENGTH NTH RESTN))) (TOGGLE NTH-RESTN-OFF NTH-RESTN T) (PROVE-LEMMA NTH-APPEND (REWRITE) (IMPLIES (LESSP N (LENGTH A)) (EQUAL (NTH N (APPEND A B)) (NTH N A))) ((INDUCT (NTH N A)) (ENABLE NTH APPEND))) (PROVE-LEMMA NTH-APPEND-TOO (REWRITE) (IMPLIES (IF (LESSP N (LENGTH A)) F T) (EQUAL (NTH N (APPEND A B)) (NTH (DIFFERENCE N (LENGTH A)) B))) ((INDUCT (NTH N A)) (ENABLE NTH APPEND))) (DEFN NTHCDR (N L) (IF (ZEROP N) L (NTHCDR (SUB1 N) (CDR L)))) (TOGGLE NTHCDR-OFF NTHCDR T) (PROVE-LEMMA OPEN-NTHCDR (REWRITE) (AND (IMPLIES (ZEROP N) (EQUAL (NTHCDR N L) L)) (IMPLIES (NOT (ZEROP N)) (EQUAL (NTHCDR N L) (NTHCDR (SUB1 N) (CDR L))))) ((ENABLE NTHCDR))) (PROVE-LEMMA PROPERP-AS-NULL-NTHCDR (REWRITE) (EQUAL (PROPERP L) (EQUAL (NTHCDR (LENGTH L) L) NIL)) ((ENABLE PROPERP LENGTH NTHCDR))) (TOGGLE PROPERP-AS-NULL-NTHCDR-OFF PROPERP-AS-NULL-NTHCDR T) (PROVE-LEMMA CDR-NTHCDR (REWRITE) (EQUAL (CDR (NTHCDR N L)) (NTHCDR (ADD1 N) L)) ((ENABLE NTHCDR))) (TOGGLE CDR-NTHCDR-OFF CDR-NTHCDR T) (PROVE-LEMMA LISTP-NTHCDR (REWRITE) (EQUAL (LISTP (NTHCDR N L)) (LESSP N (LENGTH L))) ((ENABLE NTHCDR LENGTH))) (DEFN SUBRANGE (L N M) (COND ((LESSP M N) NIL) ((ZEROP N) (IF (ZEROP M) (LIST (CAR L)) (CONS (CAR L) (SUBRANGE (CDR L) 0 (SUB1 M))))) (T (SUBRANGE (CDR L) (SUB1 N) (SUB1 M))))) (TOGGLE SUBRANGE-OFF SUBRANGE T) (PROVE-LEMMA PROPERP-SUBRANGE (REWRITE) (PROPERP (SUBRANGE V N M)) ((ENABLE SUBRANGE))) (PROVE-LEMMA SUBRANGE-CONS (REWRITE) (EQUAL (SUBRANGE (CONS CAR CDR) N M) (COND ((LESSP M N) NIL) ((ZEROP N) (IF (ZEROP M) (LIST CAR) (CONS CAR (SUBRANGE CDR 0 (SUB1 M))))) (T (SUBRANGE CDR (SUB1 N) (SUB1 M))))) ((ENABLE SUBRANGE))) (TOGGLE SUBRANGE-CONS-OFF SUBRANGE-CONS T) (PROVE-LEMMA LENGTH-SUBRANGE (REWRITE) (EQUAL (LENGTH (SUBRANGE L N M)) (IF (LESSP M N) 0 (ADD1 (DIFFERENCE M N)))) ((ENABLE SUBRANGE))) (PROVE-LEMMA SUBRANGE-APPEND-RIGHT (REWRITE) (IMPLIES (AND (NOT (LESSP M N)) (IF (LESSP N (LENGTH A)) F T)) (EQUAL (SUBRANGE (APPEND A B) N M) (SUBRANGE B (DIFFERENCE N (LENGTH A)) (DIFFERENCE M (LENGTH A))))) ((INDUCT (SUBRANGE A N M)) (ENABLE SUBRANGE APPEND LENGTH) (EXPAND (DIFFERENCE N (LENGTH A)) (DIFFERENCE M (LENGTH A))))) (PROVE-LEMMA SUBRANGE-APPEND-LEFT (REWRITE) (IMPLIES (AND (NOT (LESSP M N)) (LESSP N (LENGTH A)) (LESSP M (LENGTH A))) (EQUAL (SUBRANGE (APPEND A B) N M) (SUBRANGE A N M))) ((INDUCT (SUBRANGE A N M)) (ENABLE SUBRANGE APPEND LENGTH))) (PROVE-LEMMA SUBRANGE-0 (REWRITE) (IMPLIES (AND (EQUAL M (SUB1 (LENGTH A))) (PROPERP A) (NOT (ZEROP (LENGTH A)))) (EQUAL (SUBRANGE A 0 M) A)) ((ENABLE SUBRANGE PROPERP))) (PROVE-LEMMA LISTP-SUBRANGE (REWRITE) (EQUAL (LISTP (SUBRANGE L N M)) (NOT (LESSP M N))) ((ENABLE SUBRANGE))) (PROVE-LEMMA SUBSET-SUBRANGE (REWRITE) (IMPLIES (LESSP N (LENGTH V)) (SUBSET (SUBRANGE V M N) V)) ((ENABLE LENGTH SUBSET SUBRANGE) (EXPAND (SUBRANGE V M 0)))) (PROVE-LEMMA NOT-MEMBER-SUBRANGE (REWRITE) (IMPLIES (AND (LESSP N (LENGTH V)) (NOT (MEMBER X V))) (NOT (MEMBER X (SUBRANGE V M N)))) ((ENABLE LENGTH MEMBER SUBRANGE))) (PROVE-LEMMA DISJOINT-SUBRANGE (REWRITE) (IMPLIES (AND (DISJOINT X Y) (LESSP M (LENGTH Y))) (AND (DISJOINT X (SUBRANGE Y N M)) (DISJOINT (SUBRANGE Y N M) X))) ((ENABLE DISJOINT SUBRANGE))) (PROVE-LEMMA OPEN-SUBRANGE (REWRITE) (AND (IMPLIES (LESSP M N) (EQUAL (SUBRANGE L N M) NIL)) (IMPLIES (AND (NOT (LESSP M N)) (ZEROP N) (ZEROP M)) (EQUAL (SUBRANGE L N M) (LIST (CAR L)))) (IMPLIES (AND (NOT (LESSP M N)) (ZEROP N) (NOT (ZEROP M))) (EQUAL (SUBRANGE L N M) (CONS (CAR L) (SUBRANGE (CDR L) 0 (SUB1 M))))) (IMPLIES (AND (NOT (LESSP M N)) (NOT (ZEROP N))) (EQUAL (SUBRANGE L N M) (SUBRANGE (CDR L) (SUB1 N) (SUB1 M))))) ((ENABLE SUBRANGE))) (TOGGLE OPEN-SUBRANGE-OFF OPEN-SUBRANGE T) (DEFN UPDATE-NTH (N LST VALUE) (IF (LISTP LST) (IF (ZEROP N) (CONS VALUE (CDR LST)) (CONS (CAR LST) (UPDATE-NTH (SUB1 N) (CDR LST) VALUE))) LST)) (TOGGLE UPDATE-NTH-OFF UPDATE-NTH T) (DEFN MAKE-LIST (N VALUE) (IF (ZEROP N) NIL (CONS VALUE (MAKE-LIST (SUB1 N) VALUE)))) (TOGGLE MAKE-LIST-OFF MAKE-LIST T) (PROVE-LEMMA OPEN-MAKE-LIST (REWRITE) (AND (IMPLIES (ZEROP N) (EQUAL (MAKE-LIST N X) NIL)) (IMPLIES (NOT (ZEROP N)) (EQUAL (MAKE-LIST N X) (CONS X (MAKE-LIST (SUB1 N) X))))) ((ENABLE MAKE-LIST))) (TOGGLE OPEN-MAKE-LIST-OFF OPEN-MAKE-LIST T) (PROVE-LEMMA LENGTH-MAKE-LIST (REWRITE) (EQUAL (LENGTH (MAKE-LIST N VALUE)) (FIX N)) ((ENABLE MAKE-LIST))) (PROVE-LEMMA MAKE-LIST-APPEND (REWRITE) (EQUAL (APPEND (MAKE-LIST N VALUE) (MAKE-LIST M VALUE)) (MAKE-LIST (PLUS N M) VALUE)) ((ENABLE MAKE-LIST))) (PROVE-LEMMA PROPERP-MAKE-LIST (REWRITE) (PROPERP (MAKE-LIST N VALUE)) ((ENABLE MAKE-LIST))) (PROVE-LEMMA FIRSTN-MAKE-LIST (REWRITE) (IMPLIES (IF (LESSP M N) F T) (EQUAL (FIRSTN N (MAKE-LIST M V)) (MAKE-LIST N V))) ((ENABLE FIRSTN MAKE-LIST))) (DEFN TREE-SIZE (TREE) (IF (NLISTP TREE) 1 (PLUS (TREE-SIZE (CAR TREE)) (TREE-SIZE (CDR TREE))))) (TOGGLE TREE-SIZE-OFF TREE-SIZE T) (PROVE-LEMMA TREE-SIZE-NLISTP (REWRITE) (IMPLIES (NLISTP TREE) (EQUAL (TREE-SIZE TREE) 1)) ((ENABLE TREE-SIZE))) (PROVE-LEMMA NOT-EQUAL-TREE-SIZE-TREE-0 (REWRITE) (NOT (EQUAL (TREE-SIZE TREE) 0)) ((ENABLE TREE-SIZE))) (PROVE-LEMMA TREE-SIZE-1-CROCK (REWRITE) (NOT (EQUAL 1 (TREE-SIZE (CONS A B)))) ((ENABLE TREE-SIZE))) (PROVE-LEMMA A-HELPFUL-LEMMA-FOR-TREE-INDUCTIONS (REWRITE) (IMPLIES (EQUAL (LENGTH A) (TREE-SIZE TREE)) (EQUAL (LESSP (LENGTH A) (TREE-SIZE (CAR TREE))) F)) ((ENABLE TREE-SIZE LESSP))) (PROVE-LEMMA TREE-SIZE-LEMMAS (REWRITE) (AND (IMPLIES (AND (LISTP TREE) (EQUAL SIZE (TREE-SIZE TREE))) (EQUAL (DIFFERENCE SIZE (TREE-SIZE (CAR TREE))) (TREE-SIZE (CDR TREE)))) (IMPLIES (AND (LISTP TREE) (EQUAL SIZE (TREE-SIZE TREE))) (EQUAL (DIFFERENCE SIZE (TREE-SIZE (CDR TREE))) (TREE-SIZE (CAR TREE))))) ((EXPAND (TREE-SIZE TREE)))) (PROVE-LEMMA MAKE-LIST-APPEND-TREE-CROCK (REWRITE) (IMPLIES (LISTP TREE) (EQUAL (MAKE-LIST (PLUS (TREE-SIZE (CAR TREE)) (TREE-SIZE (CDR TREE))) VALUE) (MAKE-LIST (TREE-SIZE TREE) VALUE))) ((ENABLE TREE-SIZE))) (TOGGLE MAKE-LIST-APPEND-TREE-CROCK-OFF MAKE-LIST-APPEND-TREE-CROCK T) (DEFN TFIRSTN (LIST TREE) (FIRSTN (TREE-SIZE (CAR TREE)) LIST)) (DEFN TRESTN (LIST TREE) (RESTN (TREE-SIZE (CAR TREE)) LIST)) (DEFN TREE-HEIGHT (TREE) (IF (NLISTP TREE) 1 (ADD1 (MAX (TREE-HEIGHT (CAR TREE)) (TREE-HEIGHT (CDR TREE)))))) (TOGGLE TREE-HEIGHT-OFF TREE-HEIGHT T) (DEFN MAKE-TREE (N) (COND ((ZEROP N) 0) ((EQUAL N 1) 0) (T (CONS (MAKE-TREE (QUOTIENT N 2)) (MAKE-TREE (DIFFERENCE N (QUOTIENT N 2))))))) (TOGGLE MAKE-TREE-OFF MAKE-TREE T) (PROVE-LEMMA TREE-SIZE-MAKE-TREE (REWRITE) (IMPLIES (NOT (ZEROP N)) (EQUAL (TREE-SIZE (MAKE-TREE N)) N)) ((ENABLE TREE-SIZE MAKE-TREE))) (PROVE-LEMMA LISTP-MAKE-TREE (REWRITE) (EQUAL (LISTP (MAKE-TREE N)) (IF (LESSP N 2) F T)) ((DISABLE DIFFERENCE-0) (ENABLE MAKE-TREE))) (PROVE-LEMMA LIST-REWRITE-4 (REWRITE) (IMPLIES (AND (PROPERP A) (EQUAL (LENGTH A) 4)) (EQUAL (LIST (CAR A) (CADR A) (CADDR A) (CADDDR A)) A)) ((ENABLE EQUAL-LENGTH-ADD1))) (TOGGLE LIST-REWRITE-4-OFF LIST-REWRITE-4 T) (PROVE-LEMMA LIST-ELIM-4 (REWRITE) (EQUAL (EQUAL L (LIST A B C D)) (AND (EQUAL (CAR L) A) (EQUAL (CADR L) B) (EQUAL (CADDR L) C) (EQUAL (CADDDR L) D) (EQUAL (CDDDDR L) NIL)))) (TOGGLE LIST-ELIM-4-OFF LIST-ELIM-4 T) (DEFN LIST-AS-COLLECTED-NTH (L LENGTH N) (IF (ZEROP LENGTH) NIL (CONS (NTH N L) (LIST-AS-COLLECTED-NTH L (SUB1 LENGTH) (ADD1 N))))) (TOGGLE LIST-AS-COLLECTED-NTH-OFF LIST-AS-COLLECTED-NTH T) (PROVE-LEMMA OPEN-LIST-AS-COLLECTED-NTH (REWRITE) (AND (IMPLIES (ZEROP LENGTH) (EQUAL (LIST-AS-COLLECTED-NTH L LENGTH N) NIL)) (IMPLIES (NOT (ZEROP LENGTH)) (EQUAL (LIST-AS-COLLECTED-NTH L LENGTH N) (CONS (NTH N L) (LIST-AS-COLLECTED-NTH L (SUB1 LENGTH) (ADD1 N)))))) ((ENABLE LIST-AS-COLLECTED-NTH))) (PROVE-LEMMA EQUAL-LENGTH-4-AS-COLLECTED-NTH NIL (IMPLIES (AND (EQUAL (LENGTH L) 4) (PROPERP L)) (EQUAL L (LIST-AS-COLLECTED-NTH L 4 0))) ((ENABLE OPEN-NTH PROPERP-AS-NULL-NTHCDR OUR-CAR-CDR-ELIM) (DISABLE CAR-CDR-ELIM))) (PROVE-LEMMA EQUAL-LENGTH-32-AS-COLLECTED-NTH NIL (IMPLIES (AND (EQUAL (LENGTH L) 32) (PROPERP L)) (EQUAL L (LIST-AS-COLLECTED-NTH L 32 0))) ((ENABLE OPEN-NTH PROPERP-AS-NULL-NTHCDR OUR-CAR-CDR-ELIM) (DISABLE CAR-CDR-ELIM))) (ADD-SHELL INDEX NIL INDEXP ((I-NAME (ONE-OF NUMBERP LITATOM) ZERO) (I-NUM (ONE-OF NUMBERP) ZERO))) (DEFN LNFIX (X) (IF (OR (NUMBERP X) (LITATOM X)) X 0)) (DEFN INDICES (NAME FROM N) (IF (ZEROP N) NIL (CONS (INDEX NAME FROM) (INDICES NAME (ADD1 FROM) (SUB1 N))))) (TOGGLE INDICES-OFF INDICES T) (PROVE-LEMMA INDICES-ZEROP (REWRITE) (IMPLIES (ZEROP N) (EQUAL (INDICES NAME FROM N) NIL)) ((ENABLE INDICES))) (PROVE-LEMMA OPEN-INDICES (REWRITE) (IMPLIES (NOT (ZEROP N)) (EQUAL (INDICES NAME FROM N) (CONS (INDEX NAME FROM) (INDICES NAME (ADD1 FROM) (SUB1 N))))) ((ENABLE INDICES))) (PROVE-LEMMA INDICES-AS-APPEND (REWRITE) (IMPLIES (NOT (ZEROP N)) (EQUAL (INDICES NAME FROM N) (APPEND (INDICES NAME FROM (SUB1 N)) (LIST (INDEX NAME (PLUS (SUB1 N) FROM)))))) ((ENABLE INDICES))) (TOGGLE INDICES-AS-APPEND-OFF INDICES-AS-APPEND T) (PROVE-LEMMA LENGTH-INDICES (REWRITE) (EQUAL (LENGTH (INDICES NAME FROM N)) (FIX N)) ((ENABLE LENGTH INDICES))) (PROVE-LEMMA LISTP-INDICES (REWRITE) (EQUAL (LISTP (INDICES NAME FROM N)) (NOT (ZEROP N))) ((ENABLE INDICES))) (PROVE-LEMMA PROPERP-INDICES (REWRITE) (PROPERP (INDICES NAME FROM N)) ((ENABLE PROPERP INDICES))) (PROVE-LEMMA MEMBER-INDICES (REWRITE) (EQUAL (MEMBER X (INDICES NAME FROM N)) (AND (NOT (ZEROP N)) (INDEXP X) (EQUAL (I-NAME X) (LNFIX NAME)) (IF (LESSP (I-NUM X) FROM) F T) (LESSP (I-NUM X) (PLUS FROM N)))) ((ENABLE MEMBER INDICES LESSP))) (PROVE-LEMMA DISJOINT-INDICES-DIFFERENT-NAMES (REWRITE) (IMPLIES (NOT (EQUAL (LNFIX NAME1) (LNFIX NAME2))) (DISJOINT (INDICES NAME1 FROM1 N1) (INDICES NAME2 FROM2 N2))) ((ENABLE DISJOINT INDICES))) (PROVE-LEMMA NO-DUPLICATES-IN-INDICES (REWRITE) (NOT (DUPLICATES? (INDICES NAME FROM N))) ((ENABLE DUPLICATES? INDICES))) (PROVE-LEMMA POSITION-NAME-INDICES (REWRITE) (IMPLIES (MEMBER INDEX (INDICES NAME FROM N)) (EQUAL (POSITION INDEX (INDICES NAME FROM N)) (DIFFERENCE (I-NUM INDEX) FROM))) ((INDUCT (INDICES NAME FROM N)) (ENABLE POSITION INDICES) (DISABLE OPEN-INDICES))) (PROVE-LEMMA NTH-INDICES (REWRITE) (IMPLIES (LESSP N M) (EQUAL (NTH N (INDICES NAME FROM M)) (INDEX NAME (PLUS N FROM)))) ((ENABLE NTH INDICES))) (TOGGLE NTH-INDICES-OFF NTH-INDICES T) (ADD-SHELL X NIL XP NIL) (ADD-SHELL Z NIL ZP NIL) (DEFN BOOLP (X) (OR (EQUAL X T) (EQUAL X F))) (TOGGLE BOOLP-OFF BOOLP T) (PROVE-LEMMA PROVE-BOOLP (REWRITE) (IMPLIES (OR (TRUEP X) (FALSEP X)) (BOOLP X)) ((ENABLE BOOLP))) (PROVE-LEMMA BOOLP-LEMMAS (REWRITE) (AND (BOOLP T) (BOOLP F) (IMPLIES (BOOLP B) (EQUAL (EQUAL B T) B)) (IMPLIES (BOOLP B) (EQUAL (EQUAL B F) (NOT B)))) ((ENABLE BOOLP))) (PROVE-LEMMA BOOLP-IMPLIES-NOT-EQUAL-Z (REWRITE) (IMPLIES (BOOLP X) (NOT (EQUAL X (Z))))) (TOGGLE BOOLP-IMPLIES-NOT-EQUAL-Z-OFF BOOLP-IMPLIES-NOT-EQUAL-Z T) (DEFN BOOLFIX (X) (IF X T F)) (DEFN THREEP (X) (OR (EQUAL X T) (EQUAL X F) (EQUAL X (X)))) (DEFN THREEFIX (X) (IF (BOOLP X) X (X))) (PROVE-LEMMA THREEFIX-IDEMPOTENT (REWRITE) (EQUAL (THREEFIX (THREEFIX X)) (THREEFIX X)) ((ENABLE THREEFIX))) (PROVE-LEMMA THREEFIX=X (REWRITE) (EQUAL (EQUAL (X) (THREEFIX X)) (NOT (BOOLP X)))) (TOGGLE THREEFIX=X-OFF THREEFIX=X T) (DEFN FOURP (X) (OR (EQUAL X T) (EQUAL F X) (EQUAL X (X)) (EQUAL X (Z)))) (DEFN FOURFIX (X) (IF (FOURP X) X (X))) (DEFN BVP (X) (IF (NLISTP X) (EQUAL X NIL) (AND (BOOLP (CAR X)) (BVP (CDR X))))) (TOGGLE BVP-OFF BVP T) (PROVE-LEMMA BVP-NLISTP (REWRITE) (IMPLIES (NLISTP X) (EQUAL (BVP X) (EQUAL X NIL))) ((ENABLE BVP))) (PROVE-LEMMA BVP-CONS (REWRITE) (EQUAL (BVP (CONS X Y)) (AND (BOOLP X) (BVP Y))) ((ENABLE BVP))) (PROVE-LEMMA BVP-FIRSTN (REWRITE) (IMPLIES (BVP X) (BVP (FIRSTN N X))) ((ENABLE BVP FIRSTN))) (PROVE-LEMMA BVP-RESTN (REWRITE) (IMPLIES (BVP X) (BVP (RESTN N X))) ((ENABLE BVP RESTN))) (PROVE-LEMMA BVP-APPEND (REWRITE) (IMPLIES (BVP A) (EQUAL (BVP (APPEND A B)) (BVP B))) ((ENABLE BVP APPEND))) (PROVE-LEMMA BVP-IS-PROPERP (REWRITE) (IMPLIES (BVP V) (PROPERP V)) ((ENABLE BVP PROPERP))) (PROVE-LEMMA BVP-MAKE-LIST (REWRITE) (EQUAL (BVP (MAKE-LIST N V)) (OR (ZEROP N) (BOOLP V))) ((ENABLE BVP MAKE-LIST))) (PROVE-LEMMA BVP-NTHCDR (REWRITE) (IMPLIES (AND (BVP L) (IF (LESSP (LENGTH L) N) F T)) (BVP (NTHCDR N L))) ((ENABLE BVP NTHCDR LENGTH))) (PROVE-LEMMA BVP-IF (REWRITE) (IMPLIES (AND (BVP A) (BVP B)) (BVP (IF C A B)))) (PROVE-LEMMA BVP-IF* (REWRITE) (IMPLIES (AND (BVP A) (BVP B)) (BVP (IF* C A B))) ((ENABLE IF*))) (DEFN BV2P (X Y) (AND (BVP X) (BVP Y) (EQUAL (LENGTH X) (LENGTH Y)))) (DEFN BVP-LENGTH (BVP N) (AND (BVP BVP) (IF (LESSP (LENGTH BVP) N) F T))) (TOGGLE BVP-LENGTH-OFF BVP-LENGTH T) (PROVE-LEMMA BVP-LENGTH-CDR (REWRITE) (IMPLIES (BVP-LENGTH X (ADD1 N)) (BVP-LENGTH (CDR X) N)) ((INDUCT (FIRSTN N X)) (ENABLE BVP-LENGTH BVP LENGTH))) (PROVE-LEMMA BOOLFIX-CAR-X=X (REWRITE) (IMPLIES (BVP-LENGTH X 1) (EQUAL (BOOLFIX (CAR X)) (CAR X))) ((ENABLE BOOLFIX BVP-LENGTH))) (PROVE-LEMMA BOOLP-CAR-X (REWRITE) (IMPLIES (BVP-LENGTH X 1) (BOOLP (CAR X))) ((ENABLE BOOLP BVP-LENGTH))) (PROVE-LEMMA BVP-LENGTH-RESTN (REWRITE) (IMPLIES (BVP BVP) (EQUAL (BVP-LENGTH (RESTN N BVP) M) (IF (LESSP (DIFFERENCE (LENGTH BVP) N) M) F T))) ((ENABLE BVP-LENGTH))) (PROVE-LEMMA SHOW-THAT-NTH=T (REWRITE) (IMPLIES (AND (NTH N A) (BVP A) (LESSP N (LENGTH A))) (EQUAL (NTH N A) T)) ((INDUCT (NTH N A)) (ENABLE BVP NTH))) (TOGGLE SHOW-THAT-NTH=T-OFF SHOW-THAT-NTH=T T) (PROVE-LEMMA BOOLP-NTH (REWRITE) (IMPLIES (BVP A) (EQUAL (BOOLP (NTH N A)) (LESSP N (LENGTH A)))) ((INDUCT (NTH N A)) (ENABLE NTH BVP))) (PROVE-LEMMA ANOTHER-WAY-TO-LOOK-AT-BOOLP-NTH (REWRITE) (IMPLIES (AND (BVP V) (LESSP N (LENGTH V))) (EQUAL (EQUAL (IF (NTH N V) T F) (NTH N V)) T))) (DEFN XOR (A B) (COND (A (IF B F T)) (B T) (T F))) (DEFN B-BUF (X) (IF X T F)) (DEFN B-NOT (X) (NOT X)) (DEFN B-NAND (A B) (NOT (AND A B))) (DEFN B-NAND3 (A B C) (NOT (AND A B C))) (DEFN B-NAND4 (A B C D) (NOT (AND A B C D))) (DEFN B-NAND5 (A B C D E) (NOT (AND A B C D E))) (DEFN B-NAND6 (A B C D E G) (NOT (AND A B C D E G))) (DEFN B-NAND8 (A B C D E G H I) (NOT (AND A B C D E G H I))) (DEFN B-OR (A B) (OR A B)) (DEFN B-OR3 (A B C) (OR A B C)) (DEFN B-OR4 (A B C D) (OR A B C D)) (DEFN B-XOR (X Y) (COND (X (IF Y F T)) (Y T) (T F))) (DEFN B-XOR3 (A B C) (B-XOR (B-XOR A B) C)) (DEFN B-EQUV (X Y) (COND (X (IF Y T F)) (Y F) (T T))) (DEFN B-EQUV3 (A B C) (B-EQUV A (B-XOR B C))) (DEFN B-AND (A B) (AND A B)) (DEFN B-AND3 (A B C) (AND A B C)) (DEFN B-AND4 (A B C D) (AND A B C D)) (DEFN B-NOR (A B) (NOT (OR A B))) (DEFN B-NOR3 (A B C) (NOT (OR A B C))) (DEFN B-NOR4 (A B C D) (NOT (OR A B C D))) (DEFN B-NOR5 (A B C D E) (NOT (OR A B C D E))) (DEFN B-NOR6 (A B C D E G) (NOT (OR A B C D E G))) (DEFN B-NOR8 (A B C D E G H I) (NOT (OR A B C D E G H I))) (DEFN B-IF (C A B) (COND (C (IF A T F)) (B T) (T F))) (PROVE-LEMMA OPEN-B-XOR (REWRITE) (EQUAL (B-XOR A B) (COND (A (IF B F T)) (B T) (T F)))) (PROVE-LEMMA OPEN-B-XOR3 (REWRITE) (EQUAL (B-XOR3 A B C) (B-XOR A (B-XOR B C)))) (PROVE-LEMMA OPEN-B-EQUV (REWRITE) (EQUAL (B-EQUV A B) (COND (A (IF B T F)) (B F) (T T)))) (PROVE-LEMMA OPEN-B-EQUV3 (REWRITE) (EQUAL (B-EQUV3 A B C) (B-EQUV A (B-XOR B C)))) (PROVE-LEMMA B-AND-REWRITE (REWRITE) (AND (NOT (B-AND F X)) (NOT (B-AND X F)) (IMPLIES (AND X Y) (B-AND X Y)))) (PROVE-LEMMA B-BUF-X=X (REWRITE) (IMPLIES (BOOLP X) (EQUAL (B-BUF X) X))) (DEFTHEORY B-GATES (B-BUF B-NOT B-NAND B-NAND3 B-NAND4 B-NAND5 B-NAND6 B-NAND8 B-OR B-OR3 B-OR4 B-XOR B-XOR3 B-EQUV B-EQUV3 B-AND B-AND3 B-AND4 B-NOR B-NOR3 B-NOR4 B-NOR5 B-NOR6 B-NOR8 B-IF OPEN-B-XOR OPEN-B-XOR3 OPEN-B-EQUV OPEN-B-EQUV3 B-AND-REWRITE B-BUF-X=X)) (PROVE-LEMMA BOOLP-B-GATES (REWRITE) (AND (BOOLP (B-BUF X)) (BOOLP (B-NOT X)) (BOOLP (B-NAND A B)) (BOOLP (B-NAND3 A B C)) (BOOLP (B-NAND4 A B C D)) (BOOLP (B-NAND5 A B C D E)) (BOOLP (B-NAND6 A B C D E G)) (BOOLP (B-NAND8 A B C D E G H I)) (BOOLP (B-OR A B)) (BOOLP (B-OR3 A B C)) (BOOLP (B-OR4 A B C D)) (BOOLP (B-XOR X Y)) (BOOLP (B-XOR3 A B C)) (BOOLP (B-EQUV X Y)) (BOOLP (B-EQUV3 A B C)) (BOOLP (B-AND A B)) (BOOLP (B-AND3 A B C)) (BOOLP (B-AND4 A B C D)) (BOOLP (B-NOR A B)) (BOOLP (B-NOR3 A B C)) (BOOLP (B-NOR4 A B C D)) (BOOLP (B-NOR5 A B C D E)) (BOOLP (B-NOR6 A B C D E G)) (BOOLP (B-NOR8 A B C D E G H I)) (BOOLP (B-IF C A B))) ((ENABLE BOOLP))) (TOGGLE BOOLP-B-GATES-OFF BOOLP-B-GATES T) (DEFN ID (X) X) (DEFN AO2 (A B C D) (B-NOR (B-AND A B) (B-AND C D))) (DEFN AO4 (A B C D) (B-NAND (B-OR A B) (B-OR C D))) (DEFN AO6 (A B C) (B-NOR (B-AND A B) C)) (DEFN AO7 (A B C) (B-NAND (B-OR A B) C)) (DEFN VSS NIL F) (DEFN VDD NIL T) (DEFN V-BUF (X) (IF (NLISTP X) NIL (CONS (B-BUF (CAR X)) (V-BUF (CDR X))))) (TOGGLE V-BUF-OFF V-BUF T) (DEFN V-NOT (X) (IF (NLISTP X) NIL (CONS (B-NOT (CAR X)) (V-NOT (CDR X))))) (TOGGLE V-NOT-OFF V-NOT T) (DEFN V-AND (X Y) (IF (NLISTP X) NIL (CONS (B-AND (CAR X) (CAR Y)) (V-AND (CDR X) (CDR Y))))) (TOGGLE V-AND-OFF V-AND T) (DEFN V-OR (X Y) (IF (NLISTP X) NIL (CONS (B-OR (CAR X) (CAR Y)) (V-OR (CDR X) (CDR Y))))) (TOGGLE V-OR-OFF V-OR T) (DEFN V-XOR (X Y) (IF (NLISTP X) NIL (CONS (B-XOR (CAR X) (CAR Y)) (V-XOR (CDR X) (CDR Y))))) (TOGGLE V-XOR-OFF V-XOR T) (DEFN V-SHIFT-RIGHT (A SI) (IF (NLISTP A) NIL (APPEND (V-BUF (CDR A)) (LIST (BOOLFIX SI))))) (TOGGLE V-SHIFT-RIGHT-OFF V-SHIFT-RIGHT T) (DEFN V-LSR (A) (V-SHIFT-RIGHT A F)) (DEFN V-ROR (A SI) (V-SHIFT-RIGHT A SI)) (DEFN V-ASR (A) (V-SHIFT-RIGHT A (NTH (SUB1 (LENGTH A)) A))) (DEFN V-IF (C A B) (IF (NLISTP A) NIL (CONS (IF (IF C (CAR A) (CAR B)) T F) (V-IF C (CDR A) (CDR B))))) (TOGGLE V-IF-OFF V-IF T) (PROVE-LEMMA BVP-V-BUF (REWRITE) (BVP (V-BUF A)) ((ENABLE V-BUF))) (PROVE-LEMMA BVP-V-NOT (REWRITE) (BVP (V-NOT A)) ((ENABLE V-NOT))) (PROVE-LEMMA BVP-V-AND (REWRITE) (BVP (V-AND A B)) ((ENABLE V-AND))) (PROVE-LEMMA BVP-V-OR (REWRITE) (BVP (V-OR A B)) ((ENABLE V-OR))) (PROVE-LEMMA BVP-V-XOR (REWRITE) (BVP (V-XOR A B)) ((ENABLE V-XOR))) (PROVE-LEMMA BVP-V-SHIFT-RIGHT (REWRITE) (BVP (V-SHIFT-RIGHT A SI)) ((ENABLE V-SHIFT-RIGHT))) (PROVE-LEMMA BVP-V-LSR (REWRITE) (BVP (V-LSR A)) ((ENABLE V-LSR))) (PROVE-LEMMA BVP-V-ASR (REWRITE) (BVP (V-ASR A)) ((ENABLE V-ASR))) (PROVE-LEMMA BVP-V-ROR (REWRITE) (BVP (V-ROR A C)) ((ENABLE V-ROR))) (PROVE-LEMMA BVP-V-IF (REWRITE) (BVP (V-IF C A B)) ((ENABLE V-IF))) (PROVE-LEMMA LENGTH-V-BUF (REWRITE) (EQUAL (LENGTH (V-BUF A)) (LENGTH A)) ((ENABLE LENGTH V-BUF))) (PROVE-LEMMA LENGTH-V-NOT (REWRITE) (EQUAL (LENGTH (V-NOT A)) (LENGTH A)) ((ENABLE LENGTH V-NOT))) (PROVE-LEMMA LENGTH-V-AND (REWRITE) (EQUAL (LENGTH (V-AND A B)) (LENGTH A)) ((ENABLE LENGTH V-AND))) (PROVE-LEMMA LENGTH-V-OR (REWRITE) (EQUAL (LENGTH (V-OR A B)) (LENGTH A)) ((ENABLE LENGTH V-OR))) (PROVE-LEMMA LENGTH-V-XOR (REWRITE) (EQUAL (LENGTH (V-XOR A B)) (LENGTH A)) ((ENABLE LENGTH V-XOR))) (PROVE-LEMMA LENGTH-V-SHIFT-RIGHT (REWRITE) (EQUAL (LENGTH (V-SHIFT-RIGHT A B)) (LENGTH A)) ((ENABLE LENGTH V-SHIFT-RIGHT))) (PROVE-LEMMA LENGTH-V-LSR (REWRITE) (EQUAL (LENGTH (V-LSR A)) (LENGTH A)) ((ENABLE LENGTH V-LSR))) (PROVE-LEMMA LENGTH-V-ASR (REWRITE) (EQUAL (LENGTH (V-ASR A)) (LENGTH A)) ((ENABLE LENGTH V-ASR))) (PROVE-LEMMA LENGTH-V-ROR (REWRITE) (EQUAL (LENGTH (V-ROR A B)) (LENGTH A)) ((ENABLE LENGTH V-ROR))) (PROVE-LEMMA LENGTH-V-IF (REWRITE) (EQUAL (LENGTH (V-IF C A B)) (LENGTH A)) ((ENABLE LENGTH V-IF))) (PROVE-LEMMA V-AND-APPEND-HELP (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (APPEND (V-AND A B) (V-AND D E)) (V-AND (APPEND A D) (APPEND B E)))) ((ENABLE APPEND LENGTH V-AND))) (PROVE-LEMMA V-OR-APPEND-HELP (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (APPEND (V-OR A B) (V-OR D E)) (V-OR (APPEND A D) (APPEND B E)))) ((ENABLE APPEND LENGTH V-OR))) (PROVE-LEMMA V-XOR-APPEND-HELP (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (APPEND (V-XOR A B) (V-XOR D E)) (V-XOR (APPEND A D) (APPEND B E)))) ((ENABLE APPEND LENGTH V-XOR))) (PROVE-LEMMA V-NOT-APPEND-HELP (REWRITE) (EQUAL (APPEND (V-NOT A) (V-NOT B)) (V-NOT (APPEND A B))) ((ENABLE APPEND LENGTH V-NOT))) (PROVE-LEMMA V-BUF-APPEND-HELP (REWRITE) (EQUAL (APPEND (V-BUF A) (V-BUF B)) (V-BUF (APPEND A B))) ((ENABLE APPEND LENGTH V-BUF))) (PROVE-LEMMA V-IF-APPEND-HELP (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (APPEND (V-IF C A B) (V-IF C D E)) (V-IF C (APPEND A D) (APPEND B E)))) ((ENABLE APPEND LENGTH V-IF))) (PROVE-LEMMA V-IF-C-CONGRUENCE (REWRITE) (IMPLIES C (EQUAL (EQUAL (V-IF C A B) (V-IF T A B)) T)) ((ENABLE V-IF))) (PROVE-LEMMA V-NOT-FIRSTN (REWRITE) (EQUAL (V-NOT (FIRSTN N L)) (FIRSTN N (V-NOT L))) ((ENABLE FIRSTN RESTN V-NOT))) (PROVE-LEMMA V-NOT-RESTN (REWRITE) (EQUAL (V-NOT (RESTN N L)) (RESTN N (V-NOT L))) ((ENABLE FIRSTN RESTN V-NOT))) (PROVE-LEMMA FIRSTN-V-NOT (REWRITE) (EQUAL (FIRSTN N (V-NOT L)) (V-NOT (FIRSTN N L)))) (TOGGLE FIRSTN-V-NOT-OFF FIRSTN-V-NOT T) (PROVE-LEMMA RESTN-V-NOT (REWRITE) (EQUAL (RESTN N (V-NOT L)) (V-NOT (RESTN N L)))) (TOGGLE RESTN-V-NOT-OFF RESTN-V-NOT T) (PROVE-LEMMA V-NOT-INVERTS-ALL (REWRITE) (IMPLIES (LESSP N (LENGTH BVP)) (EQUAL (NTH N (V-NOT BVP)) (B-NOT (NTH N BVP)))) ((ENABLE NTH V-NOT LENGTH BOOLFIX SHOW-THAT-NTH=T))) (PROVE-LEMMA V-OR-MAKE-LIST-F (REWRITE) (IMPLIES (AND (BVP A) (EQUAL (LENGTH A) N)) (EQUAL (V-OR (MAKE-LIST N F) A) A)) ((ENABLE LENGTH MAKE-LIST V-OR))) (DEFN V-TO-NAT (V) (IF (NLISTP V) 0 (PLUS (IF (CAR V) 1 0) (TIMES 2 (V-TO-NAT (CDR V)))))) (TOGGLE V-TO-NAT-OFF V-TO-NAT T) (DEFN NAT-TO-V (X N) (IF (ZEROP N) NIL (CONS (NOT (ZEROP (REMAINDER X 2))) (NAT-TO-V (QUOTIENT X 2) (SUB1 N))))) (TOGGLE NAT-TO-V-OFF NAT-TO-V T) (PROVE-LEMMA FIRSTN-NAT-TO-V (REWRITE) (IMPLIES (IF (LESSP M N) F T) (EQUAL (FIRSTN N (NAT-TO-V NAT M)) (NAT-TO-V NAT N))) ((ENABLE FIRSTN NAT-TO-V))) (PROVE-LEMMA RESTN-NAT-TO-V-0-HACK (REWRITE) (IMPLIES (IF (LESSP M N) F T) (EQUAL (RESTN N (NAT-TO-V 0 M)) (NAT-TO-V 0 (DIFFERENCE M N)))) ((ENABLE RESTN NAT-TO-V DIFFERENCE))) (PROVE-LEMMA LENGTH-NAT-TO-V (REWRITE) (EQUAL (LENGTH (NAT-TO-V N LENGTH)) (FIX LENGTH)) ((ENABLE LENGTH NAT-TO-V))) (PROVE-LEMMA BVP-NAT-TO-V (REWRITE) (BVP (NAT-TO-V N LENGTH)) ((ENABLE BVP NAT-TO-V))) (PROVE-LEMMA CAR-NAT-TO-V-0-IS-F (REWRITE) (IMPLIES (NOT (ZEROP N)) (NOT (CAR (NAT-TO-V 0 N)))) ((ENABLE NAT-TO-V))) (PROVE-LEMMA ANY-OF-NAT-TO-V-0-IS-F (REWRITE) (IMPLIES (LESSP N M) (NOT (NTH N (NAT-TO-V 0 M)))) ((ENABLE NTH NAT-TO-V))) (DEFN V-NTH (V-N LST) (NTH (V-TO-NAT V-N) LST)) (TOGGLE V-NTH-OFF V-NTH T) (DEFN UPDATE-V-NTH (V-N LST VALUE) (UPDATE-NTH (V-TO-NAT V-N) LST VALUE)) (TOGGLE UPDATE-V-NTH-OFF UPDATE-V-NTH T) (DEFN V-NZEROP (X) (IF (NLISTP X) F (OR (CAR X) (V-NZEROP (CDR X))))) (TOGGLE V-NZEROP-OFF V-NZEROP T) (DEFN V-ZEROP (X) (NOT (V-NZEROP X))) (PROVE-LEMMA V-NZEROP-AS-OR-CROCK (REWRITE) (AND (IMPLIES (V-NZEROP (FIRSTN N A)) (V-NZEROP A)) (IMPLIES (V-NZEROP (RESTN N A)) (V-NZEROP A))) ((ENABLE V-NZEROP FIRSTN RESTN))) (PROVE-LEMMA NOT-V-NZEROP-AS-AND-CROCK (REWRITE) (IMPLIES (AND (NOT (V-NZEROP (FIRSTN N A))) (NOT (V-NZEROP (RESTN N A)))) (NOT (V-NZEROP A))) ((ENABLE V-NZEROP FIRSTN RESTN))) (PROVE-LEMMA NOT-V-NZEROP-V-XOR-X-X (REWRITE) (NOT (V-NZEROP (V-XOR X X))) ((ENABLE V-XOR V-NZEROP))) (PROVE-LEMMA V-XOR-NZEROP=NOT-EQUAL (REWRITE) (IMPLIES (BV2P A B) (EQUAL (V-NZEROP (V-XOR A B)) (NOT (EQUAL A B)))) ((ENABLE V-NZEROP V-XOR LENGTH BVP BOOLP))) (PROVE-LEMMA V-ZEROP-MAKE-LIST-F (REWRITE) (EQUAL (V-ZEROP (MAKE-LIST N F)) T) ((ENABLE V-ZEROP V-NZEROP MAKE-LIST))) (PROVE-LEMMA NOT-V-NZEROP-ALL-F (REWRITE) (NOT (V-NZEROP (MAKE-LIST N F))) ((ENABLE V-NZEROP MAKE-LIST))) (DEFN V-NEGP (X) (COND ((NLISTP X) F) ((NLISTP (CDR X)) (CAR X)) (T (V-NEGP (CDR X))))) (TOGGLE V-NEGP-OFF V-NEGP T) (PROVE-LEMMA BOOLP-V-NEGP (REWRITE) (IMPLIES (BVP V) (BOOLP (V-NEGP V))) ((ENABLE BOOLP BVP V-NEGP))) (PROVE-LEMMA V-NEGP-AS-NTH (REWRITE) (IMPLIES (NOT (EQUAL (LENGTH BV) 0)) (EQUAL (V-NEGP BV) (NTH (SUB1 (LENGTH BV)) BV))) ((ENABLE V-NEGP NTH))) (TOGGLE V-NEGP-AS-NTH-OFF V-NEGP-AS-NTH T) (DEFN SIGN-EXTEND (V N) (COND ((ZEROP N) NIL) ((NLISTP V) (MAKE-LIST N F)) ((NLISTP (CDR V)) (CONS (BOOLFIX (CAR V)) (MAKE-LIST (SUB1 N) (BOOLFIX (CAR V))))) (T (CONS (BOOLFIX (CAR V)) (SIGN-EXTEND (CDR V) (SUB1 N)))))) (TOGGLE SIGN-EXTEND-OFF SIGN-EXTEND T) (PROVE-LEMMA LENGTH-SIGN-EXTEND (REWRITE) (EQUAL (LENGTH (SIGN-EXTEND V N)) (FIX N)) ((ENABLE SIGN-EXTEND LENGTH))) (PROVE-LEMMA BVP-SIGN-EXTEND (REWRITE) (BVP (SIGN-EXTEND V N)) ((ENABLE BVP SIGN-EXTEND))) (PROVE-LEMMA SIGN-EXTEND-AS-APPEND (REWRITE) (IMPLIES (AND (BVP V) (IF (LESSP N (LENGTH V)) F T) (NOT (EQUAL (LENGTH V) 0))) (EQUAL (SIGN-EXTEND V N) (APPEND V (MAKE-LIST (DIFFERENCE N (LENGTH V)) (NTH (SUB1 (LENGTH V)) V))))) ((INDUCT (SIGN-EXTEND V N)) (ENABLE APPEND SIGN-EXTEND MAKE-LIST NTH DIFFERENCE))) (TOGGLE SIGN-EXTEND-AS-APPEND-OFF SIGN-EXTEND-AS-APPEND T) (DEFN V-ADDER (C A B) (IF (NLISTP A) (LIST (BOOLFIX C)) (CONS (B-XOR3 C (CAR A) (CAR B)) (V-ADDER (B-OR (B-AND (CAR A) (CAR B)) (B-OR (B-AND (CAR A) C) (B-AND (CAR B) C))) (CDR A) (CDR B))))) (TOGGLE V-ADDER-OFF V-ADDER T) (DEFN V-ADDER-OUTPUT (C A B) (FIRSTN (LENGTH A) (V-ADDER C A B))) (DEFN V-ADDER-CARRY-OUT (C A B) (NTH (LENGTH A) (V-ADDER C A B))) (DEFN V-ADDER-OVERFLOWP (C A B) (B-AND (B-EQUV (NTH (SUB1 (LENGTH A)) A) (NTH (SUB1 (LENGTH B)) B)) (B-XOR (NTH (SUB1 (LENGTH A)) A) (NTH (SUB1 (LENGTH A)) (V-ADDER-OUTPUT C A B))))) (DEFN V-SUBTRACTER-OUTPUT (C A B) (V-ADDER-OUTPUT (B-NOT C) (V-NOT A) B)) (DEFN V-SUBTRACTER-CARRY-OUT (C A B) (B-NOT (V-ADDER-CARRY-OUT (B-NOT C) (V-NOT A) B))) (DEFN V-SUBTRACTER-OVERFLOWP (C A B) (V-ADDER-OVERFLOWP (B-NOT C) (V-NOT A) B)) (DEFN V-INC (X) (V-ADDER-OUTPUT T X (NAT-TO-V 0 (LENGTH X)))) (TOGGLE V-INC-OFF V-INC T) (DEFN V-DEC (X) (V-SUBTRACTER-OUTPUT T (NAT-TO-V 0 (LENGTH X)) X)) (TOGGLE V-DEC-OFF V-DEC T) (PROVE-LEMMA LENGTH-OF-V-ADDER (REWRITE) (EQUAL (LENGTH (V-ADDER C A B)) (ADD1 (LENGTH A))) ((ENABLE LENGTH V-ADDER))) (PROVE-LEMMA BVP-V-ADDER (REWRITE) (BVP (V-ADDER C A B)) ((ENABLE BVP V-ADDER))) (PROVE-LEMMA LENGTH-OF-V-ADDER-OUTPUT (REWRITE) (EQUAL (LENGTH (V-ADDER-OUTPUT C A B)) (LENGTH A))) (PROVE-LEMMA LENGTH-OF-V-SUBTRACTER-OUTPUT (REWRITE) (EQUAL (LENGTH (V-SUBTRACTER-OUTPUT C A B)) (LENGTH A))) (PROVE-LEMMA BVP-LENGTH-V-INC-V-DEC (REWRITE) (AND (BVP (V-INC X)) (BVP (V-DEC X)) (EQUAL (LENGTH (V-INC X)) (LENGTH X)) (EQUAL (LENGTH (V-DEC X)) (LENGTH X))) ((ENABLE V-INC V-DEC))) (PROVE-LEMMA V-BUF-WORKS (REWRITE) (IMPLIES (BVP X) (EQUAL (V-BUF X) X)) ((ENABLE BVP V-BUF))) (PROVE-LEMMA V-IF-WORKS (REWRITE) (IMPLIES (BV2P X Y) (EQUAL (V-IF C X Y) (IF C X Y))) ((ENABLE BVP V-IF LENGTH))) (PROVE-LEMMA V-ADDER-WORKS (REWRITE) (IMPLIES (BV2P X Y) (EQUAL (V-TO-NAT (V-ADDER C X Y)) (PLUS (IF C 1 0) (V-TO-NAT X) (V-TO-NAT Y)))) ((ENABLE BOOLFIX BVP LENGTH V-TO-NAT V-ADDER PLUS))) (DEFN V-THREEFIX (V) (IF (NLISTP V) NIL (CONS (THREEFIX (CAR V)) (V-THREEFIX (CDR V))))) (TOGGLE V-THREEFIX-OFF V-THREEFIX T) (PROVE-LEMMA OPEN-V-THREEFIX (REWRITE) (AND (IMPLIES (NLISTP V) (EQUAL (V-THREEFIX V) NIL)) (IMPLIES (LISTP V) (EQUAL (V-THREEFIX V) (CONS (THREEFIX (CAR V)) (V-THREEFIX (CDR V)))))) ((ENABLE V-THREEFIX))) (PROVE-LEMMA V-THREEFIX-BVP (REWRITE) (IMPLIES (BVP V) (EQUAL (V-THREEFIX V) V)) ((ENABLE BVP V-THREEFIX))) (PROVE-LEMMA PROPERP-V-THREEFIX (REWRITE) (PROPERP (V-THREEFIX X)) ((ENABLE PROPERP V-THREEFIX))) (PROVE-LEMMA LENGTH-V-THREEFIX (REWRITE) (EQUAL (LENGTH (V-THREEFIX X)) (LENGTH X)) ((ENABLE LENGTH V-THREEFIX))) (PROVE-LEMMA APPEND-V-THREEFIX (REWRITE) (EQUAL (APPEND (V-THREEFIX A) (V-THREEFIX B)) (V-THREEFIX (APPEND A B))) ((ENABLE APPEND V-THREEFIX))) (PROVE-LEMMA V-THREEFIX-APPEND (REWRITE) (EQUAL (V-THREEFIX (APPEND A B)) (APPEND (V-THREEFIX A) (V-THREEFIX B)))) (TOGGLE V-THREEFIX-APPEND-OFF V-THREEFIX-APPEND T) (PROVE-LEMMA V-THREEFIX-IDEMPOTENCE (REWRITE) (EQUAL (V-THREEFIX (V-THREEFIX X)) (V-THREEFIX X)) ((ENABLE V-THREEFIX))) (PROVE-LEMMA BVP-V-THREEFIX (REWRITE) (IMPLIES (PROPERP V) (EQUAL (BVP (V-THREEFIX V)) (BVP V))) ((ENABLE PROPERP BVP V-THREEFIX))) (PROVE-LEMMA V-THREEFIX-MAKE-LIST-X (REWRITE) (EQUAL (V-THREEFIX (MAKE-LIST N (X))) (MAKE-LIST N (X))) ((ENABLE V-THREEFIX MAKE-LIST))) (DEFN V-FOURFIX (V) (IF (NLISTP V) NIL (CONS (FOURFIX (CAR V)) (V-FOURFIX (CDR V))))) (TOGGLE V-FOURFIX-OFF V-FOURFIX T) (PROVE-LEMMA BVP-V-FOURFIX (REWRITE) (IMPLIES (BVP V) (EQUAL (V-FOURFIX V) V)) ((ENABLE V-FOURFIX BVP))) (PROVE-LEMMA V-FOURFIX-MAKE-LIST (REWRITE) (IMPLIES (OR (EQUAL X T) (EQUAL X F) (EQUAL X (X)) (EQUAL X (Z))) (EQUAL (V-FOURFIX (MAKE-LIST N X)) (MAKE-LIST N X))) ((ENABLE V-FOURFIX MAKE-LIST FOURFIX))) (PROVE-LEMMA V-THREEFIX-V-FOURFIX (REWRITE) (EQUAL (V-THREEFIX (V-FOURFIX V)) (V-THREEFIX V)) ((ENABLE V-THREEFIX V-FOURFIX))) (DEFN V-IFF (A B) (IF (NLISTP A) T (AND (IFF (CAR A) (CAR B)) (V-IFF (CDR A) (CDR B))))) (TOGGLE V-IFF-OFF V-IFF T) (PROVE-LEMMA V-IFF-X-X (REWRITE) (V-IFF X X) ((ENABLE V-IFF))) (PROVE-LEMMA V-IFF-REV1 (REWRITE) (IMPLIES (AND (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (LENGTH X) (LENGTH Y))) (EQUAL (V-IFF (REV1 A X) (REV1 B Y)) (AND (V-IFF A B) (V-IFF X Y)))) ((ENABLE V-IFF REV1))) (PROVE-LEMMA V-IFF-REVERSE (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (V-IFF (REVERSE A) (REVERSE B)) (V-IFF A B))) ((ENABLE REVERSE))) (PROVE-LEMMA V-IFF=EQUAL (REWRITE) (IMPLIES (BV2P A B) (EQUAL (V-IFF A B) (EQUAL A B))) ((ENABLE V-IFF BOOLP))) (PROVE-LEMMA BVP-SUBRANGE (REWRITE) (IMPLIES (AND (BVP V) (LESSP N (LENGTH V))) (BVP (SUBRANGE V M N))) ((ENABLE SUBRANGE BVP LENGTH))) (PROVE-LEMMA BOOLP-IF* (REWRITE) (IMPLIES (AND (BOOLP A) (BOOLP B)) (BOOLP (IF* C A B))) ((ENABLE IF*))) (DEFN VALUE (NAME ALIST) (COND ((NLISTP ALIST) 0) ((LISTP (CAR ALIST)) (IF (EQUAL (CAAR ALIST) NAME) (CDAR ALIST) (VALUE NAME (CDR ALIST)))) (T (VALUE NAME (CDR ALIST))))) (TOGGLE VALUE-OFF VALUE T) (DEFN COLLECT-VALUE (ARGS ALIST) (IF (NLISTP ARGS) NIL (CONS (VALUE (CAR ARGS) ALIST) (COLLECT-VALUE (CDR ARGS) ALIST)))) (TOGGLE COLLECT-VALUE-OFF COLLECT-VALUE T) (PROVE-LEMMA REWRITE-VALUE (REWRITE) (EQUAL (VALUE A (CONS (CONS B C) D)) (IF (EQUAL A B) C (VALUE A D))) ((ENABLE VALUE))) (PROVE-LEMMA REWRITE-VALUE-4X (REWRITE) (EQUAL (VALUE A (CONS (CONS B C) (CONS (CONS D E) (CONS (CONS G H) (CONS (CONS I J) K))))) (COND ((EQUAL A B) C) ((EQUAL A D) E) ((EQUAL A G) H) ((EQUAL A I) J) (T (VALUE A K)))) ((ENABLE VALUE))) (PROVE-LEMMA VALUE-APPEND-PAIRLIST (REWRITE) (EQUAL (VALUE A (APPEND (PAIRLIST B C) D)) (IF (MEMBER A B) (VALUE A (PAIRLIST B C)) (VALUE A D))) ((ENABLE VALUE APPEND PAIRLIST))) (PROVE-LEMMA VALUE-PAIRLIST (REWRITE) (IMPLIES (MEMBER NAME NAMES) (EQUAL (VALUE NAME (PAIRLIST NAMES VALUES)) (CAR (RESTN (POSITION NAME NAMES) VALUES)))) ((ENABLE VALUE PAIRLIST RESTN POSITION))) (TOGGLE VALUE-PAIRLIST-OFF VALUE-PAIRLIST T) (PROVE-LEMMA VALUE-INDICES-HACK (REWRITE) (IMPLIES (AND (MEMBER THE-NAME (INDICES NAME N M)) (IF (LESSP (LENGTH VALUES) M) F T)) (EQUAL (VALUE THE-NAME (PAIRLIST (INDICES NAME N M) VALUES)) (NTH (DIFFERENCE (I-NUM THE-NAME) N) VALUES))) ((ENABLE VALUE-PAIRLIST NTH-RESTN) (DISABLE OPEN-INDICES))) (PROVE-LEMMA COLLECT-VALUE-NLISTP (REWRITE) (IMPLIES (NLISTP ARGS) (EQUAL (COLLECT-VALUE ARGS ALIST) NIL)) ((ENABLE COLLECT-VALUE))) (PROVE-LEMMA LISTP-COLLECT-VALUE (REWRITE) (EQUAL (LISTP (COLLECT-VALUE ARGS ALIST)) (LISTP ARGS)) ((ENABLE COLLECT-VALUE))) (PROVE-LEMMA COLLECT-VALUE-APPEND (REWRITE) (EQUAL (COLLECT-VALUE (APPEND A B) ALIST) (APPEND (COLLECT-VALUE A ALIST) (COLLECT-VALUE B ALIST))) ((ENABLE COLLECT-VALUE APPEND))) (PROVE-LEMMA LENGTH-COLLECT-VALUE (REWRITE) (EQUAL (LENGTH (COLLECT-VALUE ARGS ALIST)) (LENGTH ARGS)) ((ENABLE LENGTH COLLECT-VALUE))) (PROVE-LEMMA COLLECT-VALUE-APPEND-PAIRLIST-WHEN-SUBSET (REWRITE) (IMPLIES (SUBSET ARGS1 ARGS2) (EQUAL (COLLECT-VALUE ARGS1 (APPEND (PAIRLIST ARGS2 ANSWER) X)) (COLLECT-VALUE ARGS1 (PAIRLIST ARGS2 ANSWER)))) ((ENABLE SUBSET COLLECT-VALUE APPEND PAIRLIST))) (PROVE-LEMMA COLLECT-VALUE-APPEND-PAIRLIST-WHEN-DISJOINT (REWRITE) (IMPLIES (DISJOINT ARGS1 ARGS2) (EQUAL (COLLECT-VALUE ARGS1 (APPEND (PAIRLIST ARGS2 A) B)) (COLLECT-VALUE ARGS1 B))) ((ENABLE DISJOINT COLLECT-VALUE APPEND PAIRLIST))) (PROVE-LEMMA COLLECT-VALUE-DISJOINT-PAIRLIST (REWRITE) (IMPLIES (NOT (MEMBER A ARGS)) (EQUAL (COLLECT-VALUE ARGS (CONS (CONS A B) C)) (COLLECT-VALUE ARGS C))) ((ENABLE COLLECT-VALUE))) (PROVE-LEMMA COLLECT-VALUE-LITATOM-INDICES-SPEEDUP (REWRITE) (IMPLIES (LITATOM A) (EQUAL (COLLECT-VALUE (INDICES NAME FROM TO) (CONS (CONS A B) C)) (COLLECT-VALUE (INDICES NAME FROM TO) C))) ((ENABLE COLLECT-VALUE))) (PROVE-LEMMA EQUAL-COLLECT-VALUE-PROMOTE-ALISTS (REWRITE) (IMPLIES (EQUAL ALIST1 ALIST2) (EQUAL (EQUAL (COLLECT-VALUE ARGS ALIST1) (COLLECT-VALUE ARGS ALIST2)) T))) (PROVE-LEMMA COLLECT-VALUE-FIRSTN (REWRITE) (IMPLIES (NOT (DUPLICATES? ARGS)) (EQUAL (COLLECT-VALUE (FIRSTN N ARGS) (PAIRLIST ARGS ANSWER)) (COLLECT-VALUE (FIRSTN N ARGS) (PAIRLIST (FIRSTN N ARGS) (FIRSTN N ANSWER))))) ((ENABLE DUPLICATES? COLLECT-VALUE FIRSTN PAIRLIST))) (PROVE-LEMMA COLLECT-VALUE-RESTN (REWRITE) (IMPLIES (NOT (DUPLICATES? ARGS)) (EQUAL (COLLECT-VALUE (RESTN N ARGS) (PAIRLIST ARGS ANSWER)) (COLLECT-VALUE (RESTN N ARGS) (PAIRLIST (RESTN N ARGS) (RESTN N ANSWER))))) ((ENABLE DUPLICATES? COLLECT-VALUE RESTN PAIRLIST))) (PROVE-LEMMA COLLECT-VALUE-CONS (REWRITE) (EQUAL (COLLECT-VALUE (CONS A B) ALIST) (CONS (VALUE A ALIST) (COLLECT-VALUE B ALIST))) ((ENABLE COLLECT-VALUE))) (PROVE-LEMMA SINGLETON-COLLECT-VALUE (REWRITE) (IMPLIES (EQUAL (LENGTH A) 1) (EQUAL (COLLECT-VALUE A ALIST) (LIST (VALUE (CAR A) ALIST)))) ((ENABLE COLLECT-VALUE))) (PROVE-LEMMA PROPERP-COLLECT-VALUE (REWRITE) (PROPERP (COLLECT-VALUE ARGS ALIST)) ((ENABLE COLLECT-VALUE PROPERP))) (PROVE-LEMMA COLLECT-VALUE-ARGS-PAIRLIST-ARGS (REWRITE) (IMPLIES (AND (NOT (DUPLICATES? ARGS)) (EQUAL (LENGTH ARGS) (LENGTH LIST)) (PROPERP LIST)) (EQUAL (COLLECT-VALUE ARGS (PAIRLIST ARGS LIST)) LIST)) ((ENABLE COLLECT-VALUE PAIRLIST))) (PROVE-LEMMA COLLECT-VALUE-SPLITTING-CROCK-HELPER NIL (EQUAL (COLLECT-VALUE (APPEND (FIRSTN N L) (RESTN N L)) ALIST) (APPEND (COLLECT-VALUE (FIRSTN N L) ALIST) (COLLECT-VALUE (RESTN N L) ALIST))) ((DISABLE APPEND-FIRSTN-RESTN))) (PROVE-LEMMA COLLECT-VALUE-SPLITTING-CROCK NIL (EQUAL (COLLECT-VALUE L ALIST) (APPEND (COLLECT-VALUE (FIRSTN N L) ALIST) (COLLECT-VALUE (RESTN N L) ALIST))) ((USE (COLLECT-VALUE-SPLITTING-CROCK-HELPER)))) (PROVE-LEMMA COLLECT-VALUE-MAKE-LIST (REWRITE) (EQUAL (COLLECT-VALUE (MAKE-LIST N NAME) ALIST) (MAKE-LIST N (VALUE NAME ALIST))) ((ENABLE COLLECT-VALUE MAKE-LIST))) (DEFN CDR-CDR-SUB1-SUB1-INDUCTION (L1 N M L2) (COND ((LESSP M N) T) ((ZEROP N) (IF (ZEROP M) T (CDR-CDR-SUB1-SUB1-INDUCTION (CDR L1) 0 (SUB1 M) (CDR L2)))) (T (CDR-CDR-SUB1-SUB1-INDUCTION (CDR L1) (SUB1 N) (SUB1 M) (CDR L2))))) (PROVE-LEMMA COLLECT-VALUE-SUBRANGE-ARGS-PAIRLIST-ARGS (REWRITE) (IMPLIES (AND (NOT (DUPLICATES? ARGS)) (EQUAL (LENGTH ARGS) (LENGTH LIST)) (PROPERP LIST) (LESSP N (LENGTH ARGS))) (EQUAL (COLLECT-VALUE (SUBRANGE ARGS M N) (PAIRLIST ARGS LIST)) (SUBRANGE LIST M N))) ((ENABLE COLLECT-VALUE PAIRLIST SUBRANGE) (INDUCT (CDR-CDR-SUB1-SUB1-INDUCTION ARGS M N LIST)))) (ADD-SHELL ROM NIL ROMP ((ROM-GUTS (NONE-OF) ZERO))) (ADD-SHELL RAM NIL RAMP ((RAM-GUTS (NONE-OF) ZERO))) (ADD-SHELL STUB NIL STUBP ((STUB-GUTS (NONE-OF) ZERO))) (DEFN MEMORY-PROPERP (N WIDTH MEM) (COND ((STUBP MEM) (AND (PROPERP (STUB-GUTS MEM)) (EQUAL (LENGTH (STUB-GUTS MEM)) WIDTH))) ((ZEROP N) (COND ((RAMP MEM) (AND (PROPERP (RAM-GUTS MEM)) (EQUAL (LENGTH (RAM-GUTS MEM)) WIDTH))) ((ROMP MEM) (AND (PROPERP (ROM-GUTS MEM)) (EQUAL (LENGTH (ROM-GUTS MEM)) WIDTH))) (T F))) (T (AND (LISTP MEM) (MEMORY-PROPERP (SUB1 N) WIDTH (CAR MEM)) (MEMORY-PROPERP (SUB1 N) WIDTH (CDR MEM)))))) (TOGGLE MEMORY-PROPERP-OFF MEMORY-PROPERP T) (DEFN MEMORY-OKP (N WIDTH MEM) (COND ((STUBP MEM) (AND (BVP (STUB-GUTS MEM)) (EQUAL (LENGTH (STUB-GUTS MEM)) WIDTH))) ((ZEROP N) (COND ((RAMP MEM) (AND (BVP (RAM-GUTS MEM)) (EQUAL (LENGTH (RAM-GUTS MEM)) WIDTH))) ((ROMP MEM) (AND (BVP (ROM-GUTS MEM)) (EQUAL (LENGTH (ROM-GUTS MEM)) WIDTH))) (T F))) (T (AND (LISTP MEM) (MEMORY-OKP (SUB1 N) WIDTH (CAR MEM)) (MEMORY-OKP (SUB1 N) WIDTH (CDR MEM)))))) (TOGGLE MEMORY-OKP-OFF MEMORY-OKP T) (DEFN READ-MEM1 (V-ADDR MEM) (COND ((STUBP MEM) (STUB-GUTS MEM)) ((NLISTP V-ADDR) (COND ((RAMP MEM) (RAM-GUTS MEM)) ((ROMP MEM) (ROM-GUTS MEM)) (T 0))) ((NLISTP MEM) 0) ((CAR V-ADDR) (READ-MEM1 (CDR V-ADDR) (CDR MEM))) (T (READ-MEM1 (CDR V-ADDR) (CAR MEM))))) (TOGGLE READ-MEM1-OFF READ-MEM1 T) (DEFN READ-MEM (V-ADDR MEM) (READ-MEM1 (REVERSE V-ADDR) MEM)) (TOGGLE READ-MEM-OFF READ-MEM T) (DEFN WRITE-MEM1 (V-ADDR MEM VALUE) (COND ((STUBP MEM) MEM) ((NLISTP V-ADDR) (IF (RAMP MEM) (RAM VALUE) MEM)) ((NLISTP MEM) MEM) ((CAR V-ADDR) (CONS (CAR MEM) (WRITE-MEM1 (CDR V-ADDR) (CDR MEM) VALUE))) (T (CONS (WRITE-MEM1 (CDR V-ADDR) (CAR MEM) VALUE) (CDR MEM))))) (TOGGLE WRITE-MEM1-OFF WRITE-MEM1 T) (DEFN WRITE-MEM (V-ADDR MEM VALUE) (WRITE-MEM1 (REVERSE V-ADDR) MEM VALUE)) (TOGGLE WRITE-MEM-OFF WRITE-MEM T) (DEFN RAMP-MEM1 (V-ADDR MEM) (COND ((STUBP MEM) F) ((NLISTP V-ADDR) (RAMP MEM)) ((NLISTP MEM) F) ((CAR V-ADDR) (RAMP-MEM1 (CDR V-ADDR) (CDR MEM))) (T (RAMP-MEM1 (CDR V-ADDR) (CAR MEM))))) (TOGGLE RAMP-MEM1-OFF RAMP-MEM1 T) (DEFN RAMP-MEM (V-ADDR MEM) (RAMP-MEM1 (REVERSE V-ADDR) MEM)) (TOGGLE RAMP-MEM-OFF RAMP-MEM T) (DEFN ALL-RAMP-MEM (N MEM) (COND ((STUBP MEM) F) ((ZEROP N) (RAMP MEM)) ((NLISTP MEM) F) (T (AND (ALL-RAMP-MEM (SUB1 N) (CAR MEM)) (ALL-RAMP-MEM (SUB1 N) (CDR MEM)))))) (TOGGLE ALL-RAMP-MEM-OFF ALL-RAMP-MEM T) (DEFN CONSTANT-RAM (MEM VALUE) (COND ((RAMP MEM) (RAM VALUE)) ((NLISTP MEM) MEM) (T (CONS (CONSTANT-RAM (CAR MEM) VALUE) (CONSTANT-RAM (CDR MEM) VALUE))))) (TOGGLE CONSTANT-RAM-OFF CONSTANT-RAM T) (PROVE-LEMMA MEMORY-PROPERP-IF (REWRITE) (IMPLIES (AND (MEMORY-PROPERP N WIDTH A) (MEMORY-PROPERP N WIDTH B)) (MEMORY-PROPERP N WIDTH (IF C A B)))) (PROVE-LEMMA MEMORY-OKP-IF (REWRITE) (IMPLIES (AND (MEMORY-OKP N WIDTH A) (MEMORY-OKP N WIDTH B)) (MEMORY-OKP N WIDTH (IF C A B)))) (PROVE-LEMMA MEMORY-PROPERP-CONSTANT-RAM (REWRITE) (IMPLIES (AND (MEMORY-PROPERP N WIDTH MEM) (PROPERP VALUE) (EQUAL WIDTH (LENGTH VALUE))) (MEMORY-PROPERP N WIDTH (CONSTANT-RAM MEM VALUE))) ((ENABLE MEMORY-PROPERP CONSTANT-RAM))) (PROVE-LEMMA MEMORY-PROPERP-AFTER-WRITE-MEM1 (REWRITE) (IMPLIES (AND (MEMORY-PROPERP N WIDTH MEM) (PROPERP VALUE) (EQUAL WIDTH (LENGTH VALUE)) (EQUAL N (LENGTH V-ADDR))) (MEMORY-PROPERP N WIDTH (WRITE-MEM1 V-ADDR MEM VALUE))) ((ENABLE MEMORY-PROPERP LENGTH WRITE-MEM1))) (PROVE-LEMMA MEMORY-PROPERP-AFTER-WRITE-MEM (REWRITE) (IMPLIES (AND (MEMORY-PROPERP N WIDTH MEM) (PROPERP VALUE) (EQUAL WIDTH (LENGTH VALUE)) (EQUAL N (LENGTH V-ADDR))) (MEMORY-PROPERP N WIDTH (WRITE-MEM V-ADDR MEM VALUE))) ((ENABLE WRITE-MEM))) (PROVE-LEMMA MEMORY-OKP-AFTER-WRITE-MEM1 (REWRITE) (IMPLIES (AND (MEMORY-OKP N WIDTH MEM) (BVP VALUE) (EQUAL WIDTH (LENGTH VALUE)) (EQUAL N (LENGTH V-ADDR))) (MEMORY-OKP N WIDTH (WRITE-MEM1 V-ADDR MEM VALUE))) ((ENABLE MEMORY-OKP LENGTH WRITE-MEM1))) (PROVE-LEMMA MEMORY-OKP-AFTER-WRITE-MEM (REWRITE) (IMPLIES (AND (MEMORY-OKP N WIDTH MEM) (BVP VALUE) (EQUAL WIDTH (LENGTH VALUE)) (EQUAL N (LENGTH V-ADDR))) (MEMORY-OKP N WIDTH (WRITE-MEM V-ADDR MEM VALUE))) ((ENABLE WRITE-MEM))) (PROVE-LEMMA V-IFF-V-ADDR1-V-ADDR2-READ-MEM1-WRITE-MEM1 (REWRITE) (IMPLIES (AND (V-IFF V-ADDR1 V-ADDR2) (RAMP-MEM1 V-ADDR2 MEM) (EQUAL (LENGTH V-ADDR1) (LENGTH V-ADDR2))) (EQUAL (READ-MEM1 V-ADDR1 (WRITE-MEM1 V-ADDR2 MEM VALUE)) VALUE)) ((ENABLE V-IFF MEMORY-OKP READ-MEM1 WRITE-MEM1 RAMP-MEM1))) (PROVE-LEMMA V-IFF-V-ADDR1-V-ADDR2-READ-MEM1-WRITE-MEM1-NOT-RAM (REWRITE) (IMPLIES (AND (NOT (RAMP-MEM1 V-ADDR2 MEM)) (EQUAL (LENGTH V-ADDR1) (LENGTH V-ADDR2))) (EQUAL (READ-MEM1 V-ADDR1 (WRITE-MEM1 V-ADDR2 MEM VALUE)) (READ-MEM1 V-ADDR1 MEM))) ((ENABLE V-IFF MEMORY-OKP READ-MEM1 WRITE-MEM1 RAMP-MEM1))) (PROVE-LEMMA NOT-V-IFF-V-ADDR1-V-ADDR2-READ-MEM1-WRITE-MEM1 (REWRITE) (IMPLIES (NOT (V-IFF V-ADDR1 V-ADDR2)) (EQUAL (READ-MEM1 V-ADDR1 (WRITE-MEM1 V-ADDR2 MEM VALUE)) (READ-MEM1 V-ADDR1 MEM))) ((ENABLE V-IFF MEMORY-OKP READ-MEM1 WRITE-MEM1))) (PROVE-LEMMA READ-MEM-WRITE-MEM NIL (IMPLIES (EQUAL (LENGTH V-ADDR1) (LENGTH V-ADDR2)) (EQUAL (READ-MEM V-ADDR1 (WRITE-MEM V-ADDR2 MEM VALUE)) (IF (AND (V-IFF V-ADDR1 V-ADDR2) (RAMP-MEM V-ADDR2 MEM)) VALUE (READ-MEM V-ADDR1 MEM)))) ((ENABLE READ-MEM WRITE-MEM RAMP-MEM))) (PROVE-LEMMA PROPERP-READ-MEM1 (REWRITE) (IMPLIES (MEMORY-PROPERP (LENGTH V-ADDR) SIZE MEM) (AND (PROPERP (READ-MEM1 V-ADDR MEM)) (EQUAL (LENGTH (READ-MEM1 V-ADDR MEM)) SIZE))) ((ENABLE MEMORY-PROPERP LENGTH READ-MEM1))) (PROVE-LEMMA PROPERP-READ-MEM NIL (IMPLIES (MEMORY-PROPERP (LENGTH (REVERSE V-ADDR)) SIZE MEM) (AND (PROPERP (READ-MEM V-ADDR MEM)) (EQUAL (LENGTH (READ-MEM V-ADDR MEM)) SIZE))) ((ENABLE READ-MEM) (DISABLE LENGTH-REVERSE))) (PROVE-LEMMA PROPERP-READ-MEM-32 (REWRITE) (IMPLIES (MEMORY-PROPERP (LENGTH V-ADDR) 32 MEM) (AND (PROPERP (READ-MEM V-ADDR MEM)) (EQUAL (LENGTH (READ-MEM V-ADDR MEM)) 32))) ((USE (PROPERP-READ-MEM (V-ADDR V-ADDR) (SIZE 32) (MEM MEM))))) (PROVE-LEMMA BVP-READ-MEM1 (REWRITE) (IMPLIES (MEMORY-OKP (LENGTH V-ADDR) SIZE MEM) (AND (BVP (READ-MEM1 V-ADDR MEM)) (EQUAL (LENGTH (READ-MEM1 V-ADDR MEM)) SIZE))) ((ENABLE MEMORY-OKP LENGTH READ-MEM1))) (PROVE-LEMMA BVP-READ-MEM NIL (IMPLIES (MEMORY-OKP (LENGTH (REVERSE V-ADDR)) SIZE MEM) (AND (BVP (READ-MEM V-ADDR MEM)) (EQUAL (LENGTH (READ-MEM V-ADDR MEM)) SIZE))) ((ENABLE READ-MEM) (DISABLE LENGTH-REVERSE))) (PROVE-LEMMA BVP-READ-MEM-32 (REWRITE) (IMPLIES (MEMORY-OKP (LENGTH V-ADDR) 32 MEM) (AND (BVP (READ-MEM V-ADDR MEM)) (EQUAL (LENGTH (READ-MEM V-ADDR MEM)) 32))) ((USE (BVP-READ-MEM (V-ADDR V-ADDR) (SIZE 32) (MEM MEM))))) (PROVE-LEMMA ALL-RAMP-MEM->RAMP-MEM1 (REWRITE) (IMPLIES (ALL-RAMP-MEM (LENGTH V-ADDR) MEM) (RAMP-MEM1 V-ADDR MEM)) ((ENABLE ALL-RAMP-MEM RAMP-MEM1 LENGTH))) (PROVE-LEMMA ALL-RAMP-MEM->RAMP-MEM (REWRITE) (IMPLIES (ALL-RAMP-MEM (LENGTH V-ADDR) MEM) (RAMP-MEM V-ADDR MEM)) ((ENABLE ALL-RAMP-MEM RAMP-MEM))) (PROVE-LEMMA ALL-RAMP-MEM-AFTER-WRITE-MEM1 NIL (IMPLIES (AND (ALL-RAMP-MEM N MEM) (EQUAL N (LENGTH V-ADDR))) (ALL-RAMP-MEM N (WRITE-MEM1 V-ADDR MEM VALUE))) ((ENABLE ALL-RAMP-MEM WRITE-MEM1 LENGTH))) (PROVE-LEMMA ALL-RAMP-MEM-AFTER-WRITE-MEM (REWRITE) (IMPLIES (AND (ALL-RAMP-MEM N MEM) (EQUAL N (LENGTH V-ADDR))) (ALL-RAMP-MEM N (WRITE-MEM V-ADDR MEM VALUE))) ((USE (ALL-RAMP-MEM-AFTER-WRITE-MEM1 (V-ADDR (REVERSE V-ADDR)))) (ENABLE WRITE-MEM))) (PROVE-LEMMA ALL-RAMP-MEM-CONSTANT-RAM (REWRITE) (EQUAL (ALL-RAMP-MEM N (CONSTANT-RAM MEM VALUE)) (ALL-RAMP-MEM N MEM)) ((ENABLE ALL-RAMP-MEM CONSTANT-RAM))) (PROVE-LEMMA MEMORY-OKP==>MEMORY-PROPERP (REWRITE) (IMPLIES (MEMORY-OKP N M MEM) (MEMORY-PROPERP N M MEM)) ((ENABLE MEMORY-OKP MEMORY-PROPERP))) (DEFN DUAL-PORT-RAM-VALUE (BITS ADDRESS-LINES ARGS STATE) (COND ((OR (NOT (BVP (SUBRANGE ARGS 0 (SUB1 ADDRESS-LINES)))) (AND (NOT (EQUAL (NTH (TIMES 2 ADDRESS-LINES) ARGS) T)) (OR (NOT (BVP (SUBRANGE ARGS ADDRESS-LINES (SUB1 (TIMES 2 ADDRESS-LINES))))) (EQUAL (SUBRANGE ARGS 0 (SUB1 ADDRESS-LINES)) (SUBRANGE ARGS ADDRESS-LINES (SUB1 (TIMES 2 ADDRESS-LINES))))))) (MAKE-LIST BITS (X))) ((AND (PROPERP (READ-MEM (SUBRANGE ARGS 0 (SUB1 ADDRESS-LINES)) STATE)) (EQUAL (LENGTH (READ-MEM (SUBRANGE ARGS 0 (SUB1 ADDRESS-LINES)) STATE)) BITS)) (READ-MEM (SUBRANGE ARGS 0 (SUB1 ADDRESS-LINES)) STATE)) (T (MAKE-LIST BITS (X))))) (DEFN DUAL-PORT-RAM-STATE (BITS ADDRESS-LINES ARGS STATE) (COND ((EQUAL (NTH (TIMES 2 ADDRESS-LINES) ARGS) T) STATE) ((NOT (BVP (SUBRANGE ARGS ADDRESS-LINES (SUB1 (TIMES 2 ADDRESS-LINES))))) (CONSTANT-RAM STATE (MAKE-LIST BITS (X)))) ((EQUAL (NTH (TIMES 2 ADDRESS-LINES) ARGS) F) (WRITE-MEM (SUBRANGE ARGS ADDRESS-LINES (SUB1 (TIMES 2 ADDRESS-LINES))) STATE (SUBRANGE ARGS (ADD1 (TIMES 2 ADDRESS-LINES)) (PLUS (TIMES 2 ADDRESS-LINES) BITS)))) (T (WRITE-MEM (SUBRANGE ARGS ADDRESS-LINES (SUB1 (TIMES 2 ADDRESS-LINES))) STATE (MAKE-LIST BITS (X)))))) (PROVE-LEMMA PROPERP-LENGTH-DUAL-PORT-RAM-VALUE (REWRITE) (AND (PROPERP (DUAL-PORT-RAM-VALUE BITS ADDRESS-LINES ARGS STATE)) (EQUAL (LENGTH (DUAL-PORT-RAM-VALUE BITS ADDRESS-LINES ARGS STATE)) (FIX BITS)))) (DEFN NEXT-MEMORY-STATE (STATE STROBE- RW- ADDRESS DATA) (IF (AND (BOOLP STROBE-) (BOOLP RW-)) (CASE (CADR STATE) (0 (COND (STROBE- (LIST (CAR STATE) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (RW- (IF (AND (CADDDDDR STATE) (BOOLP (CADDDDDR STATE))) (IF (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (LIST (CAR STATE) 1 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CAR STATE) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) ((AND (NOT (CADDDDDR STATE)) (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (BVP DATA) (BVP (CADDDDDDDR STATE)) (EQUAL DATA (CADDDDDDDR STATE))) (LIST (CAR STATE) 2 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (1 (COND (STROBE- (IF RW- (LIST (CAR STATE) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) (RW- (IF (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (LIST (CAR STATE) 1 (CADDR STATE) (SUB1 (CADDDR STATE)) (ZEROP (CADDDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CAR STATE) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (2 (COND (STROBE- (COND (RW- (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) ((AND (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (AND (BVP DATA) (BVP (CADDDDDDDR STATE)) (EQUAL DATA (CADDDDDDDR STATE))) (ZEROP (CADDDR STATE))) (LIST (WRITE-MEM ADDRESS (CAR STATE) DATA) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (RW- (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) ((AND (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (BVP DATA) (BVP (CADDDDDDDR STATE)) (EQUAL DATA (CADDDDDDDR STATE))) (LIST (CAR STATE) 2 (CADDR STATE) (SUB1 (CADDDR STATE)) (ZEROP (CADDDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (OTHERWISE (COND (STROBE- (IF RW- (LIST (CAR STATE) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) (RW- (LIST (CAR STATE) 3 (CADDR STATE) (SUB1 (CADDDR STATE)) (ZEROP (CADDDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) (TOGGLE NEXT-MEMORY-STATE-OFF NEXT-MEMORY-STATE T) (DEFN MEMORY-VALUE (STATE STROBE- RW- ADDRESS DATA) (IF* (AND* (BOOLP STROBE-) (BOOLP RW-)) (CASE (CADR STATE) (0 (IF* STROBE- (CONS (X) (MAKE-LIST (LENGTH DATA) (Z))) (CONS (IF* (ZEROP (CAADDR STATE)) F T) (IF* RW- (MAKE-LIST (LENGTH DATA) (X)) (MAKE-LIST (LENGTH DATA) (Z)))))) (1 (IF* STROBE- (CONS (X) (MAKE-LIST (LENGTH DATA) (Z))) (IF* RW- (IF* (AND* (EQUAL ADDRESS (CADDDDDDR STATE)) (AND* (BVP ADDRESS) (BVP (CADDDDDDR STATE)))) (IF* (ZEROP (CADDDR STATE)) (CONS F (IF* (CADDDDR STATE) (READ-MEM ADDRESS (CAR STATE)) (MAKE-LIST (LENGTH DATA) (X)))) (CONS T (MAKE-LIST (LENGTH DATA) (X)))) (IF* (ZEROP (CADDDR STATE)) (CONS F (MAKE-LIST (LENGTH DATA) (X))) (CONS T (MAKE-LIST (LENGTH DATA) (X))))) (IF* (ZEROP (CADDDR STATE)) (CONS F (MAKE-LIST (LENGTH DATA) (Z))) (CONS T (MAKE-LIST (LENGTH DATA) (Z))))))) (2 (IF* STROBE- (CONS (X) (MAKE-LIST (LENGTH DATA) (Z))) (IF* (ZEROP (CADDDR STATE)) (CONS F (MAKE-LIST (LENGTH DATA) (Z))) (CONS T (MAKE-LIST (LENGTH DATA) (Z)))))) (OTHERWISE (IF* STROBE- (CONS (X) (MAKE-LIST (LENGTH DATA) (Z))) (IF* RW- (IF* (ZEROP (CADDDR STATE)) (CONS F (MAKE-LIST (LENGTH DATA) (X))) (CONS T (MAKE-LIST (LENGTH DATA) (X)))) (IF* (ZEROP (CADDDR STATE)) (CONS F (MAKE-LIST (LENGTH DATA) (Z))) (CONS T (MAKE-LIST (LENGTH DATA) (Z)))))))) (CONS (X) (MAKE-LIST (LENGTH DATA) (X))))) (TOGGLE MEMORY-VALUE-OFF MEMORY-VALUE T) (DEFN MEM-VALUE (ARGS STATE) (MEMORY-VALUE STATE (CADR ARGS) (CAR ARGS) (SUBRANGE ARGS 2 33) (SUBRANGE ARGS 34 65))) (TOGGLE MEM-VALUE-OFF MEM-VALUE T) (DEFN MEM-STATE (ARGS STATE) (NEXT-MEMORY-STATE STATE (CADR ARGS) (CAR ARGS) (SUBRANGE ARGS 2 33) (SUBRANGE ARGS 34 65))) (TOGGLE MEM-STATE-OFF MEM-STATE T) (PROVE-LEMMA PROPERP-LENGTH-MEMORY-VALUE (REWRITE) (IMPLIES (AND (MEMORY-PROPERP 32 32 (CAR STATE)) (EQUAL (LENGTH ADDRESS) 32) (EQUAL (LENGTH DATA) 32)) (AND (PROPERP (CDR (MEMORY-VALUE STATE STROBE RW- ADDRESS DATA))) (EQUAL (LENGTH (CDR (MEMORY-VALUE STATE STROBE RW- ADDRESS DATA))) 32))) ((ENABLE MEMORY-VALUE) (DISABLE *1*MAKE-LIST))) (PROVE-LEMMA EQUAL-MEMORY-VALUE (REWRITE) (IMPLIES (EQUAL (LENGTH DATA1) (LENGTH DATA2)) (EQUAL (EQUAL (MEMORY-VALUE STATE STROBE RW- ADDRESS DATA1) (MEMORY-VALUE STATE STROBE RW- ADDRESS DATA2)) T)) ((ENABLE MEMORY-VALUE))) (DEFN NEXT-MEMORY-STATE$INDUCTION (STATE STROBE- RW- ADDRESS DATA) (COND ((AND (BOOLP STROBE-) (BOOLP RW-)) (CASE (CADR STATE) (0 (COND (STROBE- (LIST (CAR STATE) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (RW- (IF (AND (CADDDDDR STATE) (BOOLP (CADDDDDR STATE))) (IF (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (LIST (CAR STATE) 1 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CAR STATE) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) ((AND (NOT (CADDDDDR STATE)) (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (BVP DATA) (BVP (CADDDDDDDR STATE)) (EQUAL DATA (CADDDDDDDR STATE))) (LIST (CAR STATE) 2 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (1 (COND (STROBE- (IF RW- (LIST (CAR STATE) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) (RW- (IF (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (LIST (CAR STATE) 1 (CADDR STATE) (SUB1 (CADDDR STATE)) (ZEROP (CADDDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CAR STATE) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (2 (COND (STROBE- (COND (RW- (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) ((AND (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (AND (BVP DATA) (BVP (CADDDDDDDR STATE)) (EQUAL DATA (CADDDDDDDR STATE))) (ZEROP (CADDDR STATE))) (LIST (WRITE-MEM ADDRESS (CAR STATE) DATA) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (RW- (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) ((AND (AND (BVP ADDRESS) (BVP (CADDDDDDR STATE)) (EQUAL ADDRESS (CADDDDDDR STATE))) (BVP DATA) (BVP (CADDDDDDDR STATE)) (EQUAL DATA (CADDDDDDDR STATE))) (LIST (CAR STATE) 2 (CADDR STATE) (SUB1 (CADDDR STATE)) (ZEROP (CADDDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))) (OTHERWISE (COND (STROBE- (IF RW- (LIST (CAR STATE) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X)))))) (RW- (LIST (CAR STATE) 3 (CADDR STATE) (SUB1 (CADDDR STATE)) (ZEROP (CADDDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 3 (CDADDR STATE) (SUB1 (CAADDR STATE)) (ZEROP (CAADDR STATE)) (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))))))) ((NOT (AND (BOOLP STROBE-) (BOOLP RW-))) (LIST (CONSTANT-RAM (CAR STATE) (MAKE-LIST 32 (X))) 0 (CADDR STATE) 0 T (THREEFIX RW-) (V-THREEFIX ADDRESS) (IF (BOOLP RW-) (IF RW- (V-THREEFIX (CADDDDDDDR STATE)) (V-THREEFIX DATA)) (MAKE-LIST (LENGTH DATA) (X))))) (T (NEXT-MEMORY-STATE$INDUCTION (SUB1 STATE) STROBE- RW- ADDRESS DATA))) ((LESSP (COUNT STATE)))) (PROVE-LEMMA PROPERP-LENGTH-NEXT-MEMORY-STATE (REWRITE) (AND (PROPERP (NEXT-MEMORY-STATE STATE STROBE- RW- ADDRESS DATA)) (EQUAL (LENGTH (NEXT-MEMORY-STATE STATE STROBE- RW- ADDRESS DATA)) 8)) ((INDUCT (NEXT-MEMORY-STATE$INDUCTION STATE STROBE- RW- ADDRESS DATA)) (ENABLE NEXT-MEMORY-STATE))) (DEFN FIX-BREADTH-TREE-STACK (STACK N) (IF (NLISTP STACK) NIL (CONS (APPEND (MAKE-LIST N F) (CAR STACK)) (FIX-BREADTH-TREE-STACK (CDR STACK) (TIMES 2 N))))) (DEFN BREADTH-TREE (TREE STACK N) (IF (NLISTP TREE) (CONS (CONS T (IF (NLISTP STACK) (MAKE-LIST N F) (CAR STACK))) (FIX-BREADTH-TREE-STACK (CDR STACK) 2)) (CONS (CONS T (IF (NLISTP STACK) (MAKE-LIST N F) (CAR STACK))) (BREADTH-TREE (CDR TREE) (BREADTH-TREE (CAR TREE) (CDR STACK) (TIMES 2 N)) (ADD1 (TIMES 2 N)))))) (DEFN COLLECT-BREADTH-TREE (STACK N) (COND ((NLISTP STACK) NIL) ((EQUAL (CAR STACK) (MAKE-LIST N T)) (CONS T (COLLECT-BREADTH-TREE (CDR STACK) (TIMES 2 N)))) (T (CONS F (APPEND (CAR STACK) (COLLECT-BREADTH-TREE (CDR STACK) (TIMES 2 N))))))) (DEFN TREE-NUMBER (TREE) (QUOTIENT (ADD1 (V-TO-NAT (COLLECT-BREADTH-TREE (BREADTH-TREE TREE NIL 0) 1))) 2)) (TOGGLE TREE-NUMBER-OFF TREE-NUMBER T) (DEFN F-BUF (A) (THREEFIX A)) (DEFN F-AND (A B) (COND ((OR (EQUAL A F) (EQUAL B F)) F) ((AND (EQUAL A T) (EQUAL B T)) T) (T (X)))) (DEFN F-AND3 (A B C) (F-AND A (F-AND B C))) (DEFN F-AND4 (A B C D) (F-AND A (F-AND B (F-AND C D)))) (DEFN F-NOT (A) (IF (BOOLP A) (NOT A) (X))) (DEFN F-NAND (A B) (F-NOT (F-AND A B))) (DEFN F-NAND3 (A B C) (F-NOT (F-AND A (F-AND B C)))) (DEFN F-NAND4 (A B C D) (F-NOT (F-AND A (F-AND B (F-AND C D))))) (DEFN F-NAND5 (A B C D E) (F-NOT (F-AND A (F-AND B (F-AND C (F-AND D E)))))) (DEFN F-NAND6 (A B C D E G) (F-NOT (F-AND A (F-AND B (F-AND C (F-AND D (F-AND E G))))))) (DEFN F-NAND8 (A B C D E G H I) (F-NOT (F-AND A (F-AND B (F-AND C (F-AND D (F-AND E (F-AND G (F-AND H I))))))))) (DEFN F-OR (A B) (COND ((OR (EQUAL A T) (EQUAL B T)) T) ((AND (EQUAL A F) (EQUAL B F)) F) (T (X)))) (DEFN F-OR3 (A B C) (F-OR A (F-OR B C))) (DEFN F-OR4 (A B C D) (F-OR A (F-OR B (F-OR C D)))) (DEFN F-NOR (A B) (F-NOT (F-OR A B))) (DEFN F-NOR3 (A B C) (F-NOT (F-OR A (F-OR B C)))) (DEFN F-NOR4 (A B C D) (F-NOT (F-OR A (F-OR B (F-OR C D))))) (DEFN F-NOR5 (A B C D E) (F-NOT (F-OR A (F-OR B (F-OR C (F-OR D E)))))) (DEFN F-NOR6 (A B C D E G) (F-NOT (F-OR A (F-OR B (F-OR C (F-OR D (F-OR E G))))))) (DEFN F-NOR8 (A B C D E G H I) (F-NOT (F-OR A (F-OR B (F-OR C (F-OR D (F-OR E (F-OR G (F-OR H I))))))))) (DEFN F-XOR (A B) (COND ((EQUAL A T) (F-NOT B)) ((EQUAL A F) (THREEFIX B)) (T (X)))) (DEFN F-XOR3 (A B C) (F-XOR A (F-XOR B C))) (DEFN F-EQUV (A B) (COND ((EQUAL A T) (THREEFIX B)) ((EQUAL A F) (F-NOT B)) (T (X)))) (DEFN F-EQUV3 (A B C) (F-EQUV A (F-XOR B C))) (DEFN F-IF (C A B) (COND ((EQUAL C T) (THREEFIX A)) ((EQUAL C F) (THREEFIX B)) (T (X)))) (DEFN FT-BUF (C A) (COND ((EQUAL C T) (THREEFIX A)) ((EQUAL C F) (Z)) (T (X)))) (DEFN FT-WIRE (A B) (COND ((EQUAL A B) (FOURFIX A)) ((EQUAL A (Z)) (FOURFIX B)) ((EQUAL B (Z)) (FOURFIX A)) (T (X)))) (DEFN F-PULLUP (A) (IF (EQUAL A (Z)) T (THREEFIX A))) (DEFN F$AO2 (A B C D) (F-NOR (F-AND A B) (F-AND C D))) (PROVE-LEMMA EXPAND-F-FUNCTIONS (REWRITE) (AND (EQUAL (F-BUF A) (THREEFIX A)) (EQUAL (F-AND A B) (COND ((OR (EQUAL A F) (EQUAL B F)) F) ((AND (EQUAL A T) (EQUAL B T)) T) (T (X)))) (EQUAL (F-AND3 A B C) (F-AND A (F-AND B C))) (EQUAL (F-AND4 A B C D) (F-AND A (F-AND B (F-AND C D)))) (EQUAL (F-NOT A) (IF (BOOLP A) (NOT A) (X))) (EQUAL (F-NAND A B) (F-NOT (F-AND A B))) (EQUAL (F-NAND3 A B C) (F-NOT (F-AND A (F-AND B C)))) (EQUAL (F-NAND4 A B C D) (F-NOT (F-AND A (F-AND B (F-AND C D))))) (EQUAL (F-OR A B) (COND ((OR (EQUAL A T) (EQUAL B T)) T) ((AND (EQUAL A F) (EQUAL B F)) F) (T (X)))) (EQUAL (F-NAND5 A B C D E) (F-NOT (F-AND A (F-AND B (F-AND C (F-AND D E)))))) (EQUAL (F-NAND6 A B C D E G) (F-NOT (F-AND A (F-AND B (F-AND C (F-AND D (F-AND E G))))))) (EQUAL (F-NAND8 A B C D E G H I) (F-NOT (F-AND A (F-AND B (F-AND C (F-AND D (F-AND E (F-AND G (F-AND H I))))))))) (EQUAL (F-OR3 A B C) (F-OR A (F-OR B C))) (EQUAL (F-OR4 A B C D) (F-OR A (F-OR B (F-OR C D)))) (EQUAL (F-NOR A B) (F-NOT (F-OR A B))) (EQUAL (F-NOR3 A B C) (F-NOT (F-OR A (F-OR B C)))) (EQUAL (F-NOR4 A B C D) (F-NOT (F-OR A (F-OR B (F-OR C D))))) (EQUAL (F-NOR5 A B C D E) (F-NOT (F-OR A (F-OR B (F-OR C (F-OR D E)))))) (EQUAL (F-NOR6 A B C D E G) (F-NOT (F-OR A (F-OR B (F-OR C (F-OR D (F-OR E G))))))) (EQUAL (F-NOR8 A B C D E G H I) (F-NOT (F-OR A (F-OR B (F-OR C (F-OR D (F-OR E (F-OR G (F-OR H I))))))))) (EQUAL (F-XOR A B) (COND ((EQUAL A T) (F-NOT B)) ((EQUAL A F) (THREEFIX B)) (T (X)))) (EQUAL (F-XOR3 A B C) (F-XOR A (F-XOR B C))) (EQUAL (F-EQUV A B) (COND ((EQUAL A T) (THREEFIX B)) ((EQUAL A F) (F-NOT B)) (T (X)))) (EQUAL (F-EQUV3 A B C) (F-EQUV A (F-XOR B C))) (EQUAL (F-IF C A B) (COND ((EQUAL C T) (THREEFIX A)) ((EQUAL C F) (THREEFIX B)) (T (X)))) (EQUAL (FT-BUF C A) (COND ((EQUAL C T) (THREEFIX A)) ((EQUAL C F) (Z)) (T (X)))) (EQUAL (FT-WIRE A B) (COND ((EQUAL A B) (FOURFIX A)) ((EQUAL A (Z)) (FOURFIX B)) ((EQUAL B (Z)) (FOURFIX A)) (T (X)))) (EQUAL (F-PULLUP A) (IF (EQUAL A (Z)) T (THREEFIX A))))) (TOGGLE EXPAND-F-FUNCTIONS-OFF EXPAND-F-FUNCTIONS T) (PROVE-LEMMA F-BUF-LEMMA (REWRITE) (IMPLIES (BOOLP X) (EQUAL (F-BUF X) X))) (PROVE-LEMMA F-AND-REWRITE (REWRITE) (AND (NOT (F-AND F X)) (NOT (F-AND X F)) (EQUAL (F-AND X T) (F-BUF X)) (EQUAL (F-AND T X) (F-BUF X)) (IMPLIES (AND X Y (BOOLP X) (BOOLP Y)) (EQUAL (F-AND X Y) T)))) (PROVE-LEMMA F-OR-REWRITE (REWRITE) (AND (EQUAL (F-OR F F) F) (IMPLIES (AND X (BOOLP X)) (EQUAL (F-OR X Y) T)) (IMPLIES (AND X (BOOLP X)) (EQUAL (F-OR Y X) T)))) (PROVE-LEMMA F-NOT-REWRITE (REWRITE) (AND (EQUAL (F-NOT T) F) (EQUAL (F-NOT F) T))) (PROVE-LEMMA FT-BUF-REWRITE (REWRITE) (AND (EQUAL (FT-BUF T X) (THREEFIX X)) (EQUAL (FT-BUF F X) (Z)) (EQUAL (FT-BUF C (THREEFIX X)) (FT-BUF C X)) (EQUAL (FT-BUF (X) X) (X)))) (PROVE-LEMMA F-IF-REWRITE (REWRITE) (AND (EQUAL (F-IF T A B) (F-BUF A)) (EQUAL (F-IF F A B) (F-BUF B)))) (PROVE-LEMMA FT-WIRE-REWRITE (REWRITE) (AND (EQUAL (FT-WIRE (X) X) (X)) (EQUAL (FT-WIRE X (X)) (X)) (EQUAL (FT-WIRE X (Z)) (FOURFIX X)) (EQUAL (FT-WIRE (Z) X) (FOURFIX X)))) (PROVE-LEMMA F-PULLUP-REWRITE (REWRITE) (AND (EQUAL (F-PULLUP T) T) (EQUAL (F-PULLUP F) F) (EQUAL (F-PULLUP (X)) (X)) (EQUAL (F-PULLUP (Z)) T))) (PROVE-LEMMA THREEFIX-HELP-LEMMA (REWRITE) (AND (EQUAL (THREEFIX F) F) (EQUAL (THREEFIX T) T) (EQUAL (THREEFIX (X)) (X)) (EQUAL (THREEFIX (F-BUF X)) (THREEFIX X)) (EQUAL (THREEFIX (F-NOT X)) (F-NOT X)) (EQUAL (THREEFIX (F-AND X Y)) (F-AND X Y)) (EQUAL (THREEFIX (F-OR X Y)) (F-OR X Y)) (EQUAL (THREEFIX (F-XOR X Y)) (F-XOR X Y)) (EQUAL (THREEFIX (F-EQUV X Y)) (F-EQUV X Y)))) (TOGGLE THREEFIX-HELP-LEMMA-OFF THREEFIX-HELP-LEMMA T) (PROVE-LEMMA F-NOT-F-NOT=F-BUF (REWRITE) (EQUAL (F-NOT (F-NOT X)) (F-BUF X))) (TOGGLE F-NOT-F-NOT=F-BUF-OFF F-NOT-F-NOT=F-BUF T) (PROVE-LEMMA F-BUF-DELETE-LEMMAS (REWRITE) (AND (EQUAL (F-BUF (F-BUF A)) (F-BUF A)) (EQUAL (F-BUF (F-NOT A)) (F-NOT A)) (EQUAL (F-BUF (F-NAND A B)) (F-NAND A B)) (EQUAL (F-BUF (F-NAND3 A B C)) (F-NAND3 A B C)) (EQUAL (F-BUF (F-NAND4 A B C D)) (F-NAND4 A B C D)) (EQUAL (F-BUF (F-NAND5 A B C D E)) (F-NAND5 A B C D E)) (EQUAL (F-BUF (F-NAND6 A B C D E G)) (F-NAND6 A B C D E G)) (EQUAL (F-BUF (F-NAND8 A B C D E G H I)) (F-NAND8 A B C D E G H I)) (EQUAL (F-BUF (F-OR A B)) (F-OR A B)) (EQUAL (F-BUF (F-OR3 A B C)) (F-OR3 A B C)) (EQUAL (F-BUF (F-OR4 A B C D)) (F-OR4 A B C D)) (EQUAL (F-BUF (F-XOR A B)) (F-XOR A B)) (EQUAL (F-BUF (F-XOR3 A B C)) (F-XOR3 A B C)) (EQUAL (F-BUF (F-EQUV A B)) (F-EQUV A B)) (EQUAL (F-BUF (F-EQUV3 A B C)) (F-EQUV3 A B C)) (EQUAL (F-BUF (F-AND A B)) (F-AND A B)) (EQUAL (F-BUF (F-AND3 A B C)) (F-AND3 A B C)) (EQUAL (F-BUF (F-AND4 A B C D)) (F-AND4 A B C D)) (EQUAL (F-BUF (F-NOR A B)) (F-NOR A B)) (EQUAL (F-BUF (F-NOR3 A B C)) (F-NOR3 A B C)) (EQUAL (F-BUF (F-NOR4 A B C D)) (F-NOR4 A B C D)) (EQUAL (F-BUF (F-NOR5 A B C D E)) (F-NOR5 A B C D E)) (EQUAL (F-BUF (F-NOR6 A B C D E G)) (F-NOR6 A B C D E G)) (EQUAL (F-BUF (F-NOR8 A B C D E G H I)) (F-NOR8 A B C D E G H I)) (EQUAL (F-BUF (F-IF C A B)) (F-IF C A B))) ((ENABLE THREEFIX-HELP-LEMMA))) (TOGGLE F-BUF-DELETE-LEMMAS-OFF F-BUF-DELETE-LEMMAS T) (PROVE-LEMMA F-GATE-THREEFIX-CONGRUENCE-LEMMAS$HELP (REWRITE) (AND (EQUAL (F-BUF (THREEFIX A)) (F-BUF A)) (EQUAL (F-NOT (THREEFIX A)) (F-NOT A)) (EQUAL (F-OR (THREEFIX A) B) (F-OR A B)) (EQUAL (F-OR A (THREEFIX B)) (F-OR A B)) (EQUAL (F-XOR (THREEFIX A) B) (F-XOR A B)) (EQUAL (F-XOR A (THREEFIX B)) (F-XOR A B)) (EQUAL (F-EQUV (THREEFIX A) B) (F-EQUV A B)) (EQUAL (F-EQUV A (THREEFIX B)) (F-EQUV A B)) (EQUAL (F-AND (THREEFIX A) B) (F-AND A B)) (EQUAL (F-AND A (THREEFIX B)) (F-AND A B)) (EQUAL (F-IF (THREEFIX C) A B) (F-IF C A B)) (EQUAL (F-IF C (THREEFIX A) B) (F-IF C A B)) (EQUAL (F-IF C A (THREEFIX B)) (F-IF C A B)))) (TOGGLE F-GATE-THREEFIX-CONGRUENCE-LEMMAS$HELP-OFF F-GATE-THREEFIX-CONGRUENCE-LEMMAS$HELP T) (PROVE-LEMMA F-GATE-THREEFIX-CONGRUENCE-LEMMAS (REWRITE) (AND (EQUAL (F-BUF (THREEFIX A)) (F-BUF A)) (EQUAL (F-NOT (THREEFIX A)) (F-NOT A)) (EQUAL (F-NAND (THREEFIX A) B) (F-NAND A B)) (EQUAL (F-NAND A (THREEFIX B)) (F-NAND A B)) (EQUAL (F-NAND3 (THREEFIX A) B C) (F-NAND3 A B C)) (EQUAL (F-NAND3 A (THREEFIX B) C) (F-NAND3 A B C)) (EQUAL (F-NAND3 A (THREEFIX B) C) (F-NAND3 A B C)) (EQUAL (F-NAND4 (THREEFIX A) B C D) (F-NAND4 A B C D)) (EQUAL (F-NAND4 A (THREEFIX B) C D) (F-NAND4 A B C D)) (EQUAL (F-NAND4 A B (THREEFIX C) D) (F-NAND4 A B C D)) (EQUAL (F-NAND4 A B C (THREEFIX D)) (F-NAND4 A B C D)) (EQUAL (F-NAND5 (THREEFIX A) B C D E) (F-NAND5 A B C D E)) (EQUAL (F-NAND5 A (THREEFIX B) C D E) (F-NAND5 A B C D E)) (EQUAL (F-NAND5 A B (THREEFIX C) D E) (F-NAND5 A B C D E)) (EQUAL (F-NAND5 A B C (THREEFIX D) E) (F-NAND5 A B C D E)) (EQUAL (F-NAND5 A B C D (THREEFIX E)) (F-NAND5 A B C D E)) (EQUAL (F-NAND6 (THREEFIX A) B C D E G) (F-NAND6 A B C D E G)) (EQUAL (F-NAND6 A (THREEFIX B) C D E G) (F-NAND6 A B C D E G)) (EQUAL (F-NAND6 A B (THREEFIX C) D E G) (F-NAND6 A B C D E G)) (EQUAL (F-NAND6 A B C (THREEFIX D) E G) (F-NAND6 A B C D E G)) (EQUAL (F-NAND6 A B C D (THREEFIX E) G) (F-NAND6 A B C D E G)) (EQUAL (F-NAND6 A B C D E (THREEFIX G)) (F-NAND6 A B C D E G)) (EQUAL (F-NAND8 (THREEFIX A) B C D E G H I) (F-NAND8 A B C D E G H I)) (EQUAL (F-NAND8 A (THREEFIX B) C D E G H I) (F-NAND8 A B C D E G H I)) (EQUAL (F-NAND8 A B (THREEFIX C) D E G H I) (F-NAND8 A B C D E G H I)) (EQUAL (F-NAND8 A B C (THREEFIX D) E G H I) (F-NAND8 A B C D E G H I)) (EQUAL (F-NAND8 A B C D (THREEFIX E) G H I) (F-NAND8 A B C D E G H I)) (EQUAL (F-NAND8 A B C D E (THREEFIX G) H I) (F-NAND8 A B C D E G H I)) (EQUAL (F-NAND8 A B C D E G (THREEFIX H) I) (F-NAND8 A B C D E G H I)) (EQUAL (F-NAND8 A B C D E G H (THREEFIX I)) (F-NAND8 A B C D E G H I)) (EQUAL (F-OR (THREEFIX A) B) (F-OR A B)) (EQUAL (F-OR A (THREEFIX B)) (F-OR A B)) (EQUAL (F-OR3 (THREEFIX A) B C) (F-OR3 A B C)) (EQUAL (F-OR3 A (THREEFIX B) C) (F-OR3 A B C)) (EQUAL (F-OR3 A (THREEFIX B) C) (F-OR3 A B C)) (EQUAL (F-OR4 (THREEFIX A) B C D) (F-OR4 A B C D)) (EQUAL (F-OR4 A (THREEFIX B) C D) (F-OR4 A B C D)) (EQUAL (F-OR4 A B (THREEFIX C) D) (F-OR4 A B C D)) (EQUAL (F-OR4 A B C (THREEFIX D)) (F-OR4 A B C D)) (EQUAL (F-XOR (THREEFIX A) B) (F-XOR A B)) (EQUAL (F-XOR A (THREEFIX B)) (F-XOR A B)) (EQUAL (F-XOR3 (THREEFIX A) B C) (F-XOR3 A B C)) (EQUAL (F-XOR3 A (THREEFIX B) C) (F-XOR3 A B C)) (EQUAL (F-XOR3 A (THREEFIX B) C) (F-XOR3 A B C)) (EQUAL (F-EQUV (THREEFIX A) B) (F-EQUV A B)) (EQUAL (F-EQUV A (THREEFIX B)) (F-EQUV A B)) (EQUAL (F-EQUV3 (THREEFIX A) B C) (F-EQUV3 A B C)) (EQUAL (F-EQUV3 A (THREEFIX B) C) (F-EQUV3 A B C)) (EQUAL (F-EQUV3 A (THREEFIX B) C) (F-EQUV3 A B C)) (EQUAL (F-AND (THREEFIX A) B) (F-AND A B)) (EQUAL (F-AND A (THREEFIX B)) (F-AND A B)) (EQUAL (F-AND3 (THREEFIX A) B C) (F-AND3 A B C)) (EQUAL (F-AND3 A (THREEFIX B) C) (F-AND3 A B C)) (EQUAL (F-AND3 A (THREEFIX B) C) (F-AND3 A B C)) (EQUAL (F-AND4 (THREEFIX A) B C D) (F-AND4 A B C D)) (EQUAL (F-AND4 A (THREEFIX B) C D) (F-AND4 A B C D)) (EQUAL (F-AND4 A B (THREEFIX C) D) (F-AND4 A B C D)) (EQUAL (F-AND4 A B C (THREEFIX D)) (F-AND4 A B C D)) (EQUAL (F-NOR (THREEFIX A) B) (F-NOR A B)) (EQUAL (F-NOR A (THREEFIX B)) (F-NOR A B)) (EQUAL (F-NOR3 (THREEFIX A) B C) (F-NOR3 A B C)) (EQUAL (F-NOR3 A (THREEFIX B) C) (F-NOR3 A B C)) (EQUAL (F-NOR3 A (THREEFIX B) C) (F-NOR3 A B C)) (EQUAL (F-NOR4 (THREEFIX A) B C D) (F-NOR4 A B C D)) (EQUAL (F-NOR4 A (THREEFIX B) C D) (F-NOR4 A B C D)) (EQUAL (F-NOR4 A B (THREEFIX C) D) (F-NOR4 A B C D)) (EQUAL (F-NOR4 A B C (THREEFIX D)) (F-NOR4 A B C D)) (EQUAL (F-NOR5 (THREEFIX A) B C D E) (F-NOR5 A B C D E)) (EQUAL (F-NOR5 A (THREEFIX B) C D E) (F-NOR5 A B C D E)) (EQUAL (F-NOR5 A B (THREEFIX C) D E) (F-NOR5 A B C D E)) (EQUAL (F-NOR5 A B C (THREEFIX D) E) (F-NOR5 A B C D E)) (EQUAL (F-NOR5 A B C D (THREEFIX E)) (F-NOR5 A B C D E)) (EQUAL (F-NOR6 (THREEFIX A) B C D E G) (F-NOR6 A B C D E G)) (EQUAL (F-NOR6 A (THREEFIX B) C D E G) (F-NOR6 A B C D E G)) (EQUAL (F-NOR6 A B (THREEFIX C) D E G) (F-NOR6 A B C D E G)) (EQUAL (F-NOR6 A B C (THREEFIX D) E G) (F-NOR6 A B C D E G)) (EQUAL (F-NOR6 A B C D (THREEFIX E) G) (F-NOR6 A B C D E G)) (EQUAL (F-NOR6 A B C D E (THREEFIX G)) (F-NOR6 A B C D E G)) (EQUAL (F-NOR8 (THREEFIX A) B C D E G H I) (F-NOR8 A B C D E G H I)) (EQUAL (F-NOR8 A (THREEFIX B) C D E G H I) (F-NOR8 A B C D E G H I)) (EQUAL (F-NOR8 A B (THREEFIX C) D E G H I) (F-NOR8 A B C D E G H I)) (EQUAL (F-NOR8 A B C (THREEFIX D) E G H I) (F-NOR8 A B C D E G H I)) (EQUAL (F-NOR8 A B C D (THREEFIX E) G H I) (F-NOR8 A B C D E G H I)) (EQUAL (F-NOR8 A B C D E (THREEFIX G) H I) (F-NOR8 A B C D E G H I)) (EQUAL (F-NOR8 A B C D E G (THREEFIX H) I) (F-NOR8 A B C D E G H I)) (EQUAL (F-NOR8 A B C D E G H (THREEFIX I)) (F-NOR8 A B C D E G H I)) (EQUAL (F-IF (THREEFIX C) A B) (F-IF C A B)) (EQUAL (F-IF C (THREEFIX A) B) (F-IF C A B)) (EQUAL (F-IF C A (THREEFIX B)) (F-IF C A B))) ((ENABLE F-GATE-THREEFIX-CONGRUENCE-LEMMAS$HELP) (DISABLE F-BUF F-NOT F-OR F-AND F-XOR F-EQUV F-IF THREEFIX))) (TOGGLE F-GATE-THREEFIX-CONGRUENCE-LEMMAS-OFF F-GATE-THREEFIX-CONGRUENCE-LEMMAS T) (DEFTHEORY F-GATES (F-BUF F-NOT F-NAND F-NAND3 F-NAND4 F-NAND5 F-NAND6 F-NAND8 F-OR F-OR3 F-OR4 F-XOR F-XOR3 F-EQUV F-EQUV3 F-AND F-AND3 F-AND4 F-NOR F-NOR3 F-NOR4 F-NOR5 F-NOR6 F-NOR8 F-IF FT-BUF FT-WIRE F-PULLUP)) (PROVE-LEMMA F-GATES=B-GATES (REWRITE) (AND (IMPLIES (BOOLP A) (EQUAL (F-BUF A) (B-BUF A))) (IMPLIES (BOOLP A) (EQUAL (F-NOT A) (B-NOT A))) (IMPLIES (AND (BOOLP A) (BOOLP B)) (EQUAL (F-NAND A B) (B-NAND A B))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C)) (EQUAL (F-NAND3 A B C) (B-NAND3 A B C))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D)) (EQUAL (F-NAND4 A B C D) (B-NAND4 A B C D))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D) (BOOLP E)) (EQUAL (F-NAND5 A B C D E) (B-NAND5 A B C D E))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D) (BOOLP E) (BOOLP G)) (EQUAL (F-NAND6 A B C D E G) (B-NAND6 A B C D E G))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D) (BOOLP E) (BOOLP G) (BOOLP H) (BOOLP I)) (EQUAL (F-NAND8 A B C D E G H I) (B-NAND8 A B C D E G H I))) (IMPLIES (AND (BOOLP A) (BOOLP B)) (EQUAL (F-OR A B) (B-OR A B))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C)) (EQUAL (F-OR3 A B C) (B-OR3 A B C))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D)) (EQUAL (F-OR4 A B C D) (B-OR4 A B C D))) (IMPLIES (AND (BOOLP A) (BOOLP B)) (EQUAL (F-XOR A B) (B-XOR A B))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C)) (EQUAL (F-XOR3 A B C) (B-XOR3 A B C))) (IMPLIES (AND (BOOLP A) (BOOLP B)) (EQUAL (F-EQUV A B) (B-EQUV A B))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C)) (EQUAL (F-EQUV3 A B C) (B-EQUV3 A B C))) (IMPLIES (AND (BOOLP A) (BOOLP B)) (EQUAL (F-AND A B) (B-AND A B))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C)) (EQUAL (F-AND3 A B C) (B-AND3 A B C))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D)) (EQUAL (F-AND4 A B C D) (B-AND4 A B C D))) (IMPLIES (AND (BOOLP A) (BOOLP B)) (EQUAL (F-NOR A B) (B-NOR A B))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C)) (EQUAL (F-NOR3 A B C) (B-NOR3 A B C))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D)) (EQUAL (F-NOR4 A B C D) (B-NOR4 A B C D))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D) (BOOLP E)) (EQUAL (F-NOR5 A B C D E) (B-NOR5 A B C D E))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D) (BOOLP E) (BOOLP G)) (EQUAL (F-NOR6 A B C D E G) (B-NOR6 A B C D E G))) (IMPLIES (AND (BOOLP A) (BOOLP B) (BOOLP C) (BOOLP D) (BOOLP E) (BOOLP G) (BOOLP H) (BOOLP I)) (EQUAL (F-NOR8 A B C D E G H I) (B-NOR8 A B C D E G H I))) (IMPLIES (AND (BOOLP C) (BOOLP A) (BOOLP B)) (EQUAL (F-IF C A B) (B-IF C A B)))) ((ENABLE BOOLP))) (DEFN FV-OR (A B) (IF (NLISTP A) NIL (CONS (F-OR (CAR A) (CAR B)) (FV-OR (CDR A) (CDR B))))) (TOGGLE FV-OR-OFF FV-OR T) (PROVE-LEMMA PROPERP-LENGTH-FV-OR (REWRITE) (AND (PROPERP (FV-OR A B)) (EQUAL (LENGTH (FV-OR A B)) (LENGTH A))) ((ENABLE PROPERP FV-OR LENGTH))) (PROVE-LEMMA FV-OR=V-OR (REWRITE) (IMPLIES (AND (BVP A) (BVP B) (EQUAL (LENGTH A) (LENGTH B))) (EQUAL (FV-OR A B) (V-OR A B))) ((ENABLE BVP FV-OR V-OR))) (DEFN FV-XOR (A B) (IF (NLISTP A) NIL (CONS (F-XOR (CAR A) (CAR B)) (FV-XOR (CDR A) (CDR B))))) (TOGGLE FV-XOR-OFF FV-XOR T) (PROVE-LEMMA PROPERP-LENGTH-FV-XOR (REWRITE) (AND (PROPERP (FV-XOR A B)) (EQUAL (LENGTH (FV-XOR A B)) (LENGTH A))) ((ENABLE PROPERP FV-XOR LENGTH))) (PROVE-LEMMA FV-XOR=V-XOR (REWRITE) (IMPLIES (AND (BVP A) (BVP B) (EQUAL (LENGTH A) (LENGTH B))) (EQUAL (FV-XOR A B) (V-XOR A B))) ((ENABLE BVP FV-XOR V-XOR))) (DEFN FV-IF (C A B) (IF (NLISTP A) NIL (CONS (F-IF C (CAR A) (CAR B)) (FV-IF C (CDR A) (CDR B))))) (TOGGLE FV-IF-OFF FV-IF T) (PROVE-LEMMA LENGTH-FV-IF (REWRITE) (EQUAL (LENGTH (FV-IF C A B)) (LENGTH A)) ((ENABLE LENGTH FV-IF))) (PROVE-LEMMA PROPERP-FV-IF (REWRITE) (PROPERP (FV-IF C A B)) ((ENABLE PROPERP FV-IF))) (PROVE-LEMMA V-THREEFIX-FV-IF (REWRITE) (EQUAL (V-THREEFIX (FV-IF C A B)) (FV-IF C A B)) ((ENABLE V-THREEFIX FV-IF))) (PROVE-LEMMA FV-IF-WHEN-BOOLP-C (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (AND (EQUAL (FV-IF T A B) (V-THREEFIX A)) (EQUAL (FV-IF F A B) (V-THREEFIX B)))) ((ENABLE MAKE-LIST V-THREEFIX LENGTH FV-IF))) (PROVE-LEMMA FV-IF-WHEN-BVP (REWRITE) (IMPLIES (AND (BOOLP C) (BVP A) (BVP B) (EQUAL (LENGTH A) (LENGTH B))) (EQUAL (FV-IF C A B) (IF* C A B))) ((ENABLE IF* BOOLP))) (PROVE-LEMMA FV-IF-REWRITE (REWRITE) (IMPLIES (EQUAL (LENGTH A) (LENGTH B)) (EQUAL (FV-IF C A B) (IF (BOOLP C) (IF C (V-THREEFIX A) (V-THREEFIX B)) (MAKE-LIST (LENGTH A) (X))))) ((ENABLE LENGTH FV-IF BOOLP V-THREEFIX MAKE-LIST))) (TOGGLE FV-IF-REWRITE-OFF FV-IF-REWRITE T) (PROVE-LEMMA FV-IF-V-THREEFIX (REWRITE) (AND (EQUAL (FV-IF C (V-THREEFIX A) B) (FV-IF C A B)) (EQUAL (FV-IF C A (V-THREEFIX B)) (FV-IF C A B))) ((ENABLE FV-IF V-THREEFIX))) (DEFN V-WIRE (A B) (IF (NLISTP A) NIL (CONS (FT-WIRE (CAR A) (CAR B)) (V-WIRE (CDR A) (CDR B))))) (TOGGLE V-WIRE-OFF V-WIRE T) (PROVE-LEMMA V-WIRE-X-X=X (REWRITE) (EQUAL (V-WIRE X X) (V-FOURFIX X)) ((ENABLE V-WIRE V-FOURFIX))) (PROVE-LEMMA V-WIRE-MAKE-LIST-Z (REWRITE) (IMPLIES (EQUAL (LENGTH V) N) (AND (EQUAL (V-WIRE (MAKE-LIST N (Z)) V) (V-FOURFIX V)) (EQUAL (V-WIRE V (MAKE-LIST N (Z))) (V-FOURFIX V)))) ((INDUCT (NTH N V)) (ENABLE LENGTH V-WIRE MAKE-LIST V-FOURFIX FOURFIX))) (PROVE-LEMMA PROPERP-LENGTH-V-WIRE (REWRITE) (AND (PROPERP (V-WIRE A B)) (EQUAL (LENGTH (V-WIRE A B)) (LENGTH A))) ((ENABLE PROPERP LENGTH V-WIRE))) (PROVE-LEMMA V-WIRE-MAKE-LIST-X (REWRITE) (IMPLIES (EQUAL N (LENGTH X)) (EQUAL (V-WIRE X (MAKE-LIST N (X))) (MAKE-LIST N (X)))) ((ENABLE LENGTH V-WIRE MAKE-LIST))) (DEFN V-PULLUP (V) (IF (NLISTP V) NIL (CONS (F-PULLUP (CAR V)) (V-PULLUP (CDR V))))) (TOGGLE V-PULLUP-OFF V-PULLUP T) (PROVE-LEMMA PROPERP-LENGTH-V-PULLUP (REWRITE) (AND (PROPERP (V-PULLUP V)) (EQUAL (LENGTH (V-PULLUP V)) (LENGTH V))) ((ENABLE PROPERP LENGTH V-PULLUP))) (PROVE-LEMMA V-PULLUP-BVP (REWRITE) (IMPLIES (BVP V) (EQUAL (V-PULLUP V) V)) ((ENABLE V-PULLUP BVP))) (PROVE-LEMMA V-PULLUP-MAKE-LIST-Z (REWRITE) (EQUAL (V-PULLUP (MAKE-LIST N (Z))) (MAKE-LIST N T)) ((ENABLE V-PULLUP MAKE-LIST))) (DEFN FV-SHIFT-RIGHT (A SI) (IF (NLISTP A) NIL (APPEND (V-THREEFIX (CDR A)) (LIST (THREEFIX SI))))) (TOGGLE FV-SHIFT-RIGHT-OFF FV-SHIFT-RIGHT T) (PROVE-LEMMA FV-SHIFT-RIGHT=V-SHIFT-RIGHT (REWRITE) (IMPLIES (AND (BOOLP SI) (BVP A)) (EQUAL (FV-SHIFT-RIGHT A SI) (V-SHIFT-RIGHT A SI))) ((EXPAND (FV-SHIFT-RIGHT A SI) (V-SHIFT-RIGHT A SI)))) (PROVE-LEMMA PROPERP-LENGTH-FV-SHIFT-RIGHT (REWRITE) (AND (PROPERP (FV-SHIFT-RIGHT A SI)) (EQUAL (LENGTH (FV-SHIFT-RIGHT A SI)) (LENGTH A))) ((ENABLE FV-SHIFT-RIGHT))) (PROVE-LEMMA V-THREEFIX-FV-SHIFT-RIGHT (REWRITE) (EQUAL (V-THREEFIX (FV-SHIFT-RIGHT A SI)) (FV-SHIFT-RIGHT A SI)) ((ENABLE FV-SHIFT-RIGHT V-THREEFIX-APPEND) (DISABLE APPEND-V-THREEFIX))) (DEFN VFT-BUF (C A) (IF (NLISTP A) NIL (CONS (FT-BUF C (CAR A)) (VFT-BUF C (CDR A))))) (TOGGLE VFT-BUF-OFF VFT-BUF T) (PROVE-LEMMA PROPERP-LENGTH-VFT-BUF (REWRITE) (AND (PROPERP (VFT-BUF C A)) (EQUAL (LENGTH (VFT-BUF C A)) (LENGTH A))) ((ENABLE PROPERP VFT-BUF LENGTH))) (PROVE-LEMMA VFT-BUF-LEMMAS (REWRITE) (AND (EQUAL (VFT-BUF T A) (V-THREEFIX A)) (EQUAL (VFT-BUF F A) (MAKE-LIST (LENGTH A) (Z)))) ((ENABLE VFT-BUF V-THREEFIX MAKE-LIST LENGTH))) (PROVE-LEMMA VFT-BUF-REWRITE (REWRITE) (EQUAL (VFT-BUF C A) (COND ((EQUAL C T) (V-THREEFIX A)) ((EQUAL C F) (MAKE-LIST (LENGTH A) (Z))) (T (MAKE-LIST (LENGTH A) (X))))) ((ENABLE VFT-BUF V-THREEFIX MAKE-LIST LENGTH))) (TOGGLE VFT-BUF-REWRITE-OFF VFT-BUF-REWRITE T) (DEFN PRIMP-DATABASE NIL (LIST '(AO2 (DELAYS ((263 737) (83 392))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D) (LOADINGS 1 1 1 1) (LSI-NAME . AO2) (OUT-DEPENDS (A B C D)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR (F-AND A B) (F-AND C D)) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 8)) '(AO4 (DELAYS ((260 895) (82 311))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D) (LOADINGS 1 1 1 1) (LSI-NAME . AO4) (OUT-DEPENDS (A B C D)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND (F-OR A B) (F-OR C D)) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 8)) '(AO6 (DELAYS ((260 745) (82 202))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 1 1) (LSI-NAME . AO6) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR (F-AND A B) C) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 6)) '(AO7 (DELAYS ((261 486) (83 293))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 1 1) (LSI-NAME . AO7) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND (F-OR A B) C) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 6)) '(B-AND (DELAYS ((144 422) (54 707))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP) (INPUTS A B) (LOADINGS 1 1) (LSI-NAME . AN2) (OUT-DEPENDS (A B)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-AND A B) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 6)) '(B-AND3 (DELAYS ((146 663) (58 809))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 1 1) (LSI-NAME . AN3) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-AND3 A B C) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 8)) '(B-AND4 (DELAYS ((149 934) (60 870))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D) (LOADINGS 1 1 1 1) (LSI-NAME . AN4) (OUT-DEPENDS (A B C D)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-AND4 A B C D) 'NIL) (GATES . 3) (PRIMITIVES . 1) (TRANSISTORS . 10)) '(B-EQUV (DELAYS ((145 742) (67 973))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP) (INPUTS A B) (LOADINGS 1 2) (LSI-NAME . EN) (OUT-DEPENDS (A B)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-EQUV A B) 'NIL) (GATES . 3) (PRIMITIVES . 1) (TRANSISTORS . 12)) '(B-EQUV3 (DELAYS ((151 1806) (79 1580))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 3 2) (LSI-NAME . EN3) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-EQUV3 A B C) 'NIL) (GATES . 7) (PRIMITIVES . 1) (TRANSISTORS . 22)) '(B-IF (DELAYS ((70 775) (60 1040))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS S A B) (LOADINGS 2 1 1) (LSI-NAME MUX21H B A S) (OUT-DEPENDS (A B S)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-IF S A B) 'NIL) (GATES . 4) (PRIMITIVES . 1) (TRANSISTORS . 12)) '(B-NAND (DELAYS ((141 420) (82 161))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP) (INPUTS A B) (LOADINGS 1 1) (LSI-NAME . ND2) (OUT-DEPENDS (A B)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND A B) 'NIL) (GATES . 1) (PRIMITIVES . 1) (TRANSISTORS . 4)) '(B-NAND3 (DELAYS ((142 537) (109 322))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 1 1) (LSI-NAME . ND3) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND3 A B C) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 6)) '(B-NAND4 (DELAYS ((144 588) (144 418))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D) (LOADINGS 1 1 1 1) (LSI-NAME . ND4) (OUT-DEPENDS (A B C D)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND4 A B C D) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 8)) '(B-NAND5 (DELAYS ((144 1002) (59 1120))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D E) (LOADINGS 1 1 1 1 1) (LSI-NAME . ND5) (OUT-DEPENDS (A B C D E)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND5 A B C D E) 'NIL) (GATES . 4) (PRIMITIVES . 1) (TRANSISTORS . 16)) '(B-NAND6 (DELAYS ((144 982) (59 1090))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D E G) (LOADINGS 1 1 1 1 1 1) (LSI-NAME . ND6) (OUT-DEPENDS (A B C D E G)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND6 A B C D E G) 'NIL) (GATES . 5) (PRIMITIVES . 1) (TRANSISTORS . 18)) '(B-NAND8 (DELAYS ((144 1042) (60 1360))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D E G H I) (LOADINGS 1 1 1 1 1 1 1 1) (LSI-NAME . ND8) (OUT-DEPENDS (A B C D E G H I)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NAND8 A B C D E G H I) 'NIL) (GATES . 6) (PRIMITIVES . 1) (TRANSISTORS . 22)) '(B-NBUF (DELAYS ((142 447) (57 213)) ((143 302) (52 366))) (DRIVES 9 10) (INPUT-TYPES BOOLP) (INPUTS A) (LOADINGS 1) (LSI-NAME . IVDA) (OUT-DEPENDS (A) (A)) (OUTPUT-TYPES BOOLP BOOLP) (OUTPUTS Y Z) (RESULTS CONS (F-NOT A) (CONS (F-BUF A) 'NIL)) (GATES . 1) (PRIMITIVES . 1) (TRANSISTORS . 4)) '(B-NOR (DELAYS ((260 460) (59 170))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP) (INPUTS A B) (LOADINGS 1 1) (LSI-NAME . NR2) (OUT-DEPENDS (A B)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR A B) 'NIL) (GATES . 1) (PRIMITIVES . 1) (TRANSISTORS . 4)) '(B-NOR3 (DELAYS ((384 798) (59 224))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 1 1) (LSI-NAME . NR3) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR3 A B C) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 6)) '(B-NOR4 (DELAYS ((510 1072) (59 225))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D) (LOADINGS 1 1 1 1) (LSI-NAME . NR4) (OUT-DEPENDS (A B C D)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR4 A B C D) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 8)) '(B-NOR5 (DELAYS ((145 1493) (55 767))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D E) (LOADINGS 1 1 1 1 1) (LSI-NAME . NR5) (OUT-DEPENDS (A B C D E)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR5 A B C D E) 'NIL) (GATES . 4) (PRIMITIVES . 1) (TRANSISTORS . 16)) '(B-NOR6 (DELAYS ((146 1593) (55 807))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D E G) (LOADINGS 1 1 1 1 1 1) (LSI-NAME . NR6) (OUT-DEPENDS (A B C D E G)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR6 A B C D E G) 'NIL) (GATES . 5) (PRIMITIVES . 1) (TRANSISTORS . 18)) '(B-NOR8 (DELAYS ((146 1853) (54 767))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D E G H I) (LOADINGS 1 1 1 1 1 1 1 1) (LSI-NAME . NR8) (OUT-DEPENDS (A B C D E G H I)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOR8 A B C D E G H I) 'NIL) (GATES . 6) (PRIMITIVES . 1) (TRANSISTORS . 22)) '(B-NOT (DELAYS ((70 235) (57 198))) (DRIVES 10) (INPUT-TYPES BOOLP) (INPUTS A) (LOADINGS 2) (LSI-NAME . IVA) (OUT-DEPENDS (A)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOT A) 'NIL) (GATES . 1) (PRIMITIVES . 1) (TRANSISTORS . 3)) '(B-NOT-B4IP (DELAYS ((17 333) (12 124))) (DRIVES 128) (INPUT-TYPES BOOLP) (INPUTS A) (LOADINGS 8) (LSI-NAME . B4IP) (OUT-DEPENDS (A)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOT A) 'NIL) (GATES . 4) (PRIMITIVES . 1) (TRANSISTORS . 12)) '(B-NOT-IVAP (DELAYS ((38 208) (35 126))) (DRIVES 20) (INPUT-TYPES BOOLP) (INPUTS A) (LOADINGS 3) (LSI-NAME . IVAP) (OUT-DEPENDS (A)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-NOT A) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 6)) '(B-OR (DELAYS ((143 332) (58 819))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP) (INPUTS A B) (LOADINGS 1 1) (LSI-NAME . OR2) (OUT-DEPENDS (A B)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-OR A B) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 6)) '(B-OR3 (DELAYS ((144 422) (70 1185))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 1 1) (LSI-NAME . OR3) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-OR3 A B C) 'NIL) (GATES . 2) (PRIMITIVES . 1) (TRANSISTORS . 8)) '(B-OR4 (DELAYS ((143 352) (78 1329))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP) (INPUTS A B C D) (LOADINGS 1 1 1 1) (LSI-NAME . OR4) (OUT-DEPENDS (A B C D)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-OR4 A B C D) 'NIL) (GATES . 3) (PRIMITIVES . 1) (TRANSISTORS . 10)) '(B-XOR (DELAYS ((145 742) (67 973))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP) (INPUTS A B) (LOADINGS 1 2) (LSI-NAME . EO) (OUT-DEPENDS (A B)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-XOR A B) 'NIL) (GATES . 3) (PRIMITIVES . 1) (TRANSISTORS . 12)) '(B-XOR3 (DELAYS ((151 1806) (79 1580))) (DRIVES 10) (INPUT-TYPES BOOLP BOOLP BOOLP) (INPUTS A B C) (LOADINGS 1 3 2) (LSI-NAME . EO3) (OUT-DEPENDS (A B C)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-XOR3 A B C) 'NIL) (GATES . 7) (PRIMITIVES . 1) (TRANSISTORS . 22)) '(DEL2 (DELAYS ((70 2035) (38 2199))) (DRIVES 10) (INPUT-TYPES BOOLP) (INPUTS A) (LOADINGS 1) (LSI-NAME . DEL2) (OUT-DEPENDS (A)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-BUF A) 'NIL) (GATES . 4) (PRIMITIVES . 1) (TRANSISTORS . 16)) '(DEL4 (DELAYS ((73 4017) (38 4179))) (DRIVES 10) (INPUT-TYPES BOOLP) (INPUTS A) (LOADINGS 1) (LSI-NAME . DEL4) (OUT-DEPENDS (A)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-BUF A) 'NIL) (GATES . 7) (PRIMITIVES . 1) (TRANSISTORS . 28)) '(DEL10 (DELAYS ((60 10530) (49 10424))) (DRIVES 10) (INPUT-TYPES BOOLP) (INPUTS A) (LOADINGS 1) (LSI-NAME . DEL10) (OUT-DEPENDS (A)) (OUTPUT-TYPES BOOLP) (OUTPUTS Z) (RESULTS CONS (F-BUF A) 'NIL) (GATES . 19) (PRIMITIVES . 1) (TRANSISTORS . 76)) (LIST 'PROCMON '(DELAYS ((70 25000) (60 25000))) '(DRIVES 10) '(INPUT-TYPES PARAMETRIC PARAMETRIC PARAMETRIC PARAMETRIC) '(INPUTS A E S N) '(LOADINGS 2 2 2 1) '(LSI-NAME . PROCMON) '(OUT-DEPENDS (A E S N)) '(OUTPUT-TYPES PARAMETRIC) '(OUTPUTS Z) (LIST 'RESULTS 'CONS (LIST 'F-IF 'S (LIST 'F-IF 'E (LIST 'F-IF 'A (LIST 'QUOTE F) (LIST 'QUOTE F)) 'A) 'N) ''NIL) '(GATES . 100) '(PRIMITIVES . 1) '(TRANSISTORS . 400)) '(DP-RAM-16X32 (DELAYS ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500)) ((35 7500) (21 7500))) (DRIVES 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP LEVEL BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS READ-A0 READ-A1 READ-A2 READ-A3 WRITE-B0 WRITE-B1 WRITE-B2 WRITE-B3 WEN D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 D14 D15 D16 D17 D18 D19 D20 D21 D22 D23 D24 D25 D26 D27 D28 D29 D30 D31) (LOADINGS 2 2 2 2 2 2 2 2 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (LSI-NAME . CMRB100A) (NEW-STATES DUAL-PORT-RAM-STATE '32 '4 (CONS READ-A0 (CONS READ-A1 (CONS READ-A2 (CONS READ-A3 (CONS WRITE-B0 (CONS WRITE-B1 (CONS WRITE-B2 (CONS WRITE-B3 (CONS WEN (CONS D0 (CONS D1 (CONS D2 (CONS D3 (CONS D4 (CONS D5 (CONS D6 (CONS D7 (CONS D8 (CONS D9 (CONS D10 (CONS D11 (CONS D12 (CONS D13 (CONS D14 (CONS D15 (CONS D16 (CONS D17 (CONS D18 (CONS D19 (CONS D20 (CONS D21 (CONS D22 (CONS D23 (CONS D24 (CONS D25 (CONS D26 (CONS D27 (CONS D28 (CONS D29 (CONS D30 (CONS D31 'NIL))))))))))))))))))))))))))))))))))))))))) STATE) (OUTPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP) (OUT-DEPENDS (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3) (READ-A0 READ-A1 READ-A2 READ-A3)) (OUTPUTS O0 O1 O2 O3 O4 O5 O6 O7 O8 O9 O10 O11 O12 O13 O14 O15 O16 O17 O18 O19 O20 O21 O22 O23 O24 O25 O26 O27 O28 O29 O30 O31) (RESULTS DUAL-PORT-RAM-VALUE '32 '4 (CONS READ-A0 (CONS READ-A1 (CONS READ-A2 (CONS READ-A3 (CONS WRITE-B0 (CONS WRITE-B1 (CONS WRITE-B2 (CONS WRITE-B3 (CONS WEN (CONS D0 (CONS D1 (CONS D2 (CONS D3 (CONS D4 (CONS D5 (CONS D6 (CONS D7 (CONS D8 (CONS D9 (CONS D10 (CONS D11 (CONS D12 (CONS D13 (CONS D14 (CONS D15 (CONS D16 (CONS D17 (CONS D18 (CONS D19 (CONS D20 (CONS D21 (CONS D22 (CONS D23 (CONS D24 (CONS D25 (CONS D26 (CONS D27 (CONS D28 (CONS D29 (CONS D30 (CONS D31 'NIL))))))))))))))))))))))))))))))))))))))))) STATE) (STATE-TYPES ADDRESSED-STATE 4 (RAM '(BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP))) (STATES . STATE) (GATES . 2368) (PRIMITIVES . 1) (TRANSISTORS . 9472)) '(FD1 (DELAYS ((147 1024) (55 1288)) ((145 1432) (53 1447))) (DRIVES 10 10) (INPUT-TYPES BOOLP CLK) (INPUTS D CP) (LOADINGS 1 1) (LSI-NAME . FD1) (NEW-STATES F-BUF D) (OUT-DEPENDS NIL NIL) (OUTPUT-TYPES BOOLP BOOLP) (OUTPUTS Q QN) (RESULTS CONS (F-BUF STATE) (CONS (F-NOT STATE) 'NIL)) (STATE-TYPES . BOOLP) (STATES . STATE) (GATES . 7) (PRIMITIVES . 1) (TRANSISTORS . 26)) '(FD1S (DELAYS ((147 1024) (55 1288)) ((145 1432) (53 1447))) (DRIVES 10 10) (INPUT-TYPES BOOLP CLK BOOLP BOOLP) (INPUTS D CP TI TE) (LOADINGS 1 1 1 2) (LSI-NAME . FD1S) (NEW-STATES F-IF TE TI D) (OUT-DEPENDS NIL NIL) (OUTPUT-TYPES BOOLP BOOLP) (OUTPUTS Q QN) (RESULTS CONS (F-BUF STATE) (CONS (F-NOT STATE) 'NIL)) (STATE-TYPES . BOOLP) (STATES . STATE) (GATES . 9) (PRIMITIVES . 1) (TRANSISTORS . 34)) '(FD1SP (DELAYS ((68 1084) (34 1327)) ((65 1712) (32 1596))) (DRIVES 16 16) (INPUT-TYPES BOOLP CLK BOOLP BOOLP) (INPUTS D CP TI TE) (LOADINGS 1 1 1 2) (LSI-NAME . FD1SP) (NEW-STATES F-IF TE TI D) (OUT-DEPENDS NIL NIL) (OUTPUT-TYPES BOOLP BOOLP) (OUTPUTS Q QN) (RESULTS CONS (F-BUF STATE) (CONS (F-NOT STATE) 'NIL)) (STATE-TYPES . BOOLP) (STATES . STATE) (GATES . 10) (PRIMITIVES . 1) (TRANSISTORS . 38)) '(FD1SLP (DELAYS ((70 1085) (45 982)) ((67 1493) (35 1568))) (DRIVES 12 12) (INPUT-TYPES BOOLP CLK BOOLP BOOLP BOOLP) (INPUTS D CP LD TI TE) (LOADINGS 1 1 2 1 2) (LSI-NAME . FD1SLP) (NEW-STATES F-IF TE TI (F-IF LD D STATE)) (OUT-DEPENDS NIL NIL) (OUTPUT-TYPES BOOLP BOOLP) (OUTPUTS Q QN) (RESULTS CONS (F-BUF STATE) (CONS (F-NOT STATE) 'NIL)) (STATE-TYPES . BOOLP) (STATES . STATE) (GATES . 12) (PRIMITIVES . 1) (TRANSISTORS . 40)) '(ID (DELAYS A) (DRIVES A) (INPUT-TYPES FREE) (INPUTS A) (LOADINGS 0) (LSI-NAME . ID) (OUT-DEPENDS (A)) (OUTPUT-TYPES (A)) (OUTPUTS Z) (RESULTS CONS A 'NIL) (GATES . 0) (PRIMITIVES . 0) (TRANSISTORS . 0)) '(MEM-32X32 (DELAYS ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000)) ((1410 20000) (820 20000))) (DRIVES 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10) (INPUT-TYPES BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP BOOLP) (INPUTS RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 A31 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12 D13 D14 D15 D16 D17 D18 D19 D20 D21 D22 D23 D24 D25 D26 D27 D28 D29 D30 D31) (LOADINGS 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (LSI-NAME . MEM-32X32) (NEW-STATES MEM-STATE (CONS RW- (CONS STROBE- (CONS A0 (CONS A1 (CONS A2 (CONS A3 (CONS A4 (CONS A5 (CONS A6 (CONS A7 (CONS A8 (CONS A9 (CONS A10 (CONS A11 (CONS A12 (CONS A13 (CONS A14 (CONS A15 (CONS A16 (CONS A17 (CONS A18 (CONS A19 (CONS A20 (CONS A21 (CONS A22 (CONS A23 (CONS A24 (CONS A25 (CONS A26 (CONS A27 (CONS A28 (CONS A29 (CONS A30 (CONS A31 (CONS D0 (CONS D1 (CONS D2 (CONS D3 (CONS D4 (CONS D5 (CONS D6 (CONS D7 (CONS D8 (CONS D9 (CONS D10 (CONS D11 (CONS D12 (CONS D13 (CONS D14 (CONS D15 (CONS D16 (CONS D17 (CONS D18 (CONS D19 (CONS D20 (CONS D21 (CONS D22 (CONS D23 (CONS D24 (CONS D25 (CONS D26 (CONS D27 (CONS D28 (CONS D29 (CONS D30 (CONS D31 'NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) STATE) (OUT-DEPENDS (RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 A31) (RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 A31) (RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 A31) (RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 A31) (RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 A31) (RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27 A28 A29 A30 A31) (RW- STROBE- A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17 A18 A19 A20 A21 A22 A23 A24 A25 A26 A27