sundance:/projects/acl2/devel/books/misc> cd sundance:~> cd /u/www/users/moore/acl2/seminar/ sundance:/u/www/users/moore/acl2/seminar> cd 2006.02.15-kaufmann/ sundance:/u/www/users/moore/acl2/seminar/2006.02.15-kaufmann> acl2 GCL (GNU Common Lisp) 2.6.6 CLtL1 Jan 19 2005 20:24:14 Source License: LGPL(gcl,gmp), GPL(unexec,bfd) Binary License: GPL due to GPL'ed components: (BFD UNEXEC) Modifications of this banner must retain notice of a compatible license Dedicated to the memory of W. Schelter Use (help) to get some basic information on how to use GCL. ACL2 Version 2.9.4 built January 30, 2006 23:10:57. Copyright (C) 2006 University of Texas at Austin ACL2 comes with ABSOLUTELY NO WARRANTY. This is free software and you are welcome to redistribute it under certain conditions. For details, see the GNU General Public License. Initialized with (INITIALIZE-ACL2 'INCLUDE-BOOK *ACL2-PASS-2-FILES*). See the documentation topic note-2-9-4 for recent changes. Note: We have modified the prompt in some underlying Lisps to further distinguish it from the ACL2 prompt. NOTE!! Proof trees are disabled in ACL2. To enable them in emacs, look under the ACL2 source directory in interface/emacs/README.doc; and, to turn on proof trees, execute :START-PROOF-TREE in the ACL2 command loop. Look in the ACL2 documentation under PROOF-TREE. ACL2 Version 2.9.4. Level 1. Cbd "/v/filer2/moore/public_html/acl2/seminar/2006.02.15-kaufmann/". Type :help for help. Type (good-bye) to quit completely out of ACL2. ACL2 !>(defpkg "HANOI" (set-difference-equal (union-eq *acl2-exports* *common-lisp-symbols-from-main-lisp-package*) '(PUSH POP GET))) Summary Form: ( DEFPKG "HANOI" ...) Rules: NIL Warnings: None Time: 0.02 seconds (prove: 0.00, print: 0.00, other: 0.02) "HANOI" ACL2 !>:u 0:x(EXIT-BOOT-STRAP-MODE) ACL2 !>(defpkg "HANOI" (set-difference-equal (union-eq *acl2-exports* *common-lisp-symbols-from-main-lisp-package*) '(PUSH POP GET))) [SGC for 21 STRING pages..(8313 writable)..(T=2).GC finished] Summary Form: ( DEFPKG "HANOI" ...) Rules: NIL Warnings: None Time: 0.02 seconds (prove: 0.00, print: 0.00, other: 0.02) "HANOI" ACL2 !>(rebuild "/projects/acl2/devel/books/misc/hanoi.lisp" t) ACL2 loading "/projects/acl2/devel/books/misc/hanoi.lisp". "HANOI" MEM APP DEL PERM PERM-OPENER APP-ASSOC APP-RIGHT-ID GET PUT [SGC for 20 CFUN pages..(8324 writable)..(T=1).GC finished] GET-PUT PUT-GET PUT-PUT-1 PUT-PUT-2 TRUE-LISTP-PUT LEN-PUT PUSH POP TOP H HANOI [SGC for 20 CFUN pages..(8329 writable)..(T=1).GC finished] A B LEGAL-SYNTAXP LEGAL-MOVEP DO-MOVE PLAY TOWER ACL2 Warning [Non-rec] in ( DEFTHM EXAMPLES ...): A :REWRITE rule generated from EXAMPLES will be triggered only by terms containing the non-recursive function symbol HANOI. Unless this function is disabled, this rule is unlikely ever to be used. ACL2 Warning [Non-rec] in ( DEFTHM EXAMPLES ...): A :REWRITE rule generated from EXAMPLES will be triggered only by terms containing the non-recursive function symbol HANOI. Unless this function is disabled, this rule is unlikely ever to be used. ACL2 Warning [Non-rec] in ( DEFTHM EXAMPLES ...): A :REWRITE rule generated from EXAMPLES will be triggered only by terms containing the non-recursive function symbol HANOI. Unless this function is disabled, this rule is unlikely ever to be used. EXAMPLES TRUE-LISTP-TOWER PLAY-APP BIG-TOPS [SGC for 21 STRING pages..(8330 writable)..(T=0).GC finished] INDUCTION-HINT H-LEMMA ACL2 Warning [Non-rec] in ( DEFTHM HANOI-CORRECT ...): A :REWRITE rule generated from HANOI-CORRECT will be triggered only by terms containing the non-recursive function symbol HANOI. Unless this function is disabled, this rule is unlikely ever to be used. ACL2 Warning [Subsume] in ( DEFTHM HANOI-CORRECT ...): A newly proposed :REWRITE rule generated from HANOI-CORRECT probably subsumes the previously added :REWRITE rule EXAMPLES, in the sense that the new rule will now probably be applied whenever the old rule would have been. HANOI-CORRECT Finished loading "/projects/acl2/devel/books/misc/hanoi.lisp". T ACL2 !>"HANOI" "HANOI" HANOI !>:ubt! h-lemma L 33:x(DEFUN INDUCTION-HINT (A B C N S) ...) HANOI !>:start-proof-tree Proof tree output is now enabled. Note that :START-PROOF-TREE works by removing 'proof-tree from the inhibit-output-lst; see :DOC set- inhibit-output-lst. HANOI !>(defmacro proof-term () '(implies (and (natp n) (true-listp s) (equal (len s) 3) (perm (list a b c) '(0 1 2)) (big-tops a b c n s)) (equal (play (h a b c n) (put (app (tower n) (get a s)) a s)) (put (app (tower n) (get c s)) c s)))) Summary Form: ( DEFMACRO PROOF-TERM ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, proof tree: 0.00, other: 0.00) PROOF-TERM HANOI !>(defmacro do-proof () `(defthm h-lemma (proof-term) :rule-classes nil :hints (("Goal" :induct (induction-hint a b c n s))))) Summary Form: ( DEFMACRO DO-PROOF ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, proof tree: 0.00, other: 0.00) DO-PROOF HANOI !>(do-proof) << Starting proof tree logging >> [Note: A hint was supplied for our processing of the goal above. Thanks!] Name the formula above *1. We have been told to use induction. One induction scheme is suggested by the induction hint. We will induct according to a scheme suggested by (INDUCTION-HINT A B C N S). This suggestion was produced using the :induction rule INDUCTION-HINT. If we let (:P A B C N S) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (ZP N)) (:P A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S)) (:P B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (:P A B C N S)) (IMPLIES (ZP N) (:P A B C N S))). This induction is justified by the same argument used to admit INDUCTION- HINT, namely, the measure (ACL2-COUNT N) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). Note, however, that the unmeasured variables C, A, B and S are being instantiated. When applied to the goal at hand the above induction scheme produces the following two nontautological subgoals. Subgoal *1/2 (IMPLIES (AND (NOT (ZP N)) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET A S)) A S)) (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S)))) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET C S)) C S)) (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))))) (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)))). By the simple :definitions NATP and PUSH and the simple :rewrite rules PERM-OPENER and PUT-PUT-2 we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (NOT (ZP N)) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET A S)) A S)) (EQUAL (LEN (PUT (CONS N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (CONS N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B (PUT (CONS N (GET A S)) A S)))) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). [SGC for 442 CONS pages..(8347 writable)..(T=0).GC finished] [SGC for 442 CONS pages..(8347 writable)..(T=0).GC finished] [SGC for 442 CONS pages..(8347 writable)..(T=1).GC finished] [SGC for 25 FIXNUM pages..(10387 writable)..(T=2).GC finished] This simplifies, using the :compound-recognizer rules ACL2::NATP-COMPOUND- RECOGNIZER and ACL2::ZP-COMPOUND-RECOGNIZER, the :definitions A, APP, B, BIG-TOPS, DO-MOVE, GET, H, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH, TOP and TOWER, the :executable-counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules APP-ASSOC, CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PERM-OPENER, PLAY-APP, PUT-PUT- 1 and TRUE-LISTP-PUT, to the following 109 conjectures. (By the way, the case limit affected this analysis. See :DOC case-split-limitations.) Subgoal *1/2.109 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/2.109' (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (INTEGERP (+ -1 N)) (<= 0 (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). [SGC for 25 FIXNUM pages..(10387 writable)..(T=1).GC finished] This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions BIG-TOPS, H and TOWER, the :executable- counterpart of EQUAL, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, GET-PUT, LEN-PUT and TRUE-LISTP-PUT, to the following 16 conjectures. Subgoal *1/2.109.16 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.15 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.15' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.14 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.13 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.13' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.12 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.11 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.11' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.11.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.11.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.11.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.11.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.10 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.9 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.9' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.9.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.9.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.9.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.9.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.8 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.7 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.7' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.7.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.7.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.7.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.7.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.6 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.5 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.5' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.5.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.5.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.5.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.5.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.3' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.3.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.3.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.3.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.3.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.1' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.1.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.1.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.1.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.1.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.108 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (PERM (LIST B A C) '(0 1 2))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of NOT, primitive type reasoning and the :rewrite rule PERM-OPENER. Subgoal *1/2.107 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3)) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of EQUAL, linear arithmetic and the :rewrite rule LEN-PUT. Subgoal *1/2.106 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (TRUE-LISTP (PUT (CONS N (GET C S)) C S))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using linear arithmetic and the :rewrite rule TRUE-LISTP-PUT. Subgoal *1/2.105 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/2.105' (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (INTEGERP (+ -1 N)) (<= 0 (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). [SGC for 3151 CONS pages..(11169 writable)..(T=2).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER, the :definition BIG-TOPS, the :executable- counterpart of EQUAL, linear arithmetic, primitive type reasoning and the :rewrite rules GET-PUT, LEN-PUT and TRUE-LISTP-PUT. Subgoal *1/2.104 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NOT (PERM (LIST B A C) '(0 1 2))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of NOT, primitive type reasoning and the :rewrite rule PERM-OPENER. Subgoal *1/2.103 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NOT (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3)) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of EQUAL, linear arithmetic and the :rewrite rule LEN-PUT. Subgoal *1/2.102 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NOT (TRUE-LISTP (PUT (CONS N (GET C S)) C S))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using linear arithmetic and the :rewrite rule TRUE-LISTP-PUT. Subgoal *1/2.101 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/2.101' (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (INTEGERP (+ -1 N)) (<= 0 (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions BIG-TOPS, H and TOWER, the :executable- counterpart of EQUAL, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, GET-PUT, LEN-PUT and TRUE-LISTP-PUT, to the following 16 conjectures. Subgoal *1/2.101.16 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.15 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.15' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.14 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.13 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.13' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.12 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.11 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.11' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.11.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.11.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.11.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.11.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.10 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.9 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.9' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.9.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.9.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.9.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.9.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.8 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.7 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.7' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.7.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.7.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.7.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.7.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.6 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.5 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.5' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.5.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.5.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.5.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.5.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.3' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.3.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.3.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.3.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.3.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.1' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.1.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.1.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.1.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.1.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.100 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (PERM (LIST B A C) '(0 1 2))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of NOT, primitive type reasoning and the :rewrite rule PERM-OPENER. Subgoal *1/2.99 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3)) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of EQUAL, linear arithmetic and the :rewrite rule LEN-PUT. Subgoal *1/2.98 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (TRUE-LISTP (PUT (CONS N (GET C S)) C S))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using linear arithmetic and the :rewrite rule TRUE-LISTP-PUT. Subgoal *1/2.97 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and the :definition BIG-TOPS. Subgoal *1/2.96 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.95 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.94 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.93 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.92 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.91 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.90 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.89 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.88 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.87 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.86 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.85 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). [SGC for 4704 CONS pages..(12764 writable)..(T=2).GC finished] But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.84 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.83 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.82 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.81 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.80 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.79 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.78 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.77 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.76 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.75 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.74 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.73 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.72 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.71 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.70 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.69 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.68 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.67 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.66 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.65 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.64 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.63 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.62 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.61 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.60 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.59 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.58 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.57 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.56 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.55 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.54 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.53 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.52 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.51 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.50 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.49 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.48 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.47 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.46 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.45 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.44 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.43 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.42 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.41 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.40 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.39 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.38 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.37 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.36 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.35 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.34 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.33 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.32 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.31 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.30 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.29 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.28 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.27 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.26 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.25 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.24 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.23 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.22 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.21 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.20 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.19 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.18 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.17 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.16 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.15 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.14 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.13 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.12 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.11 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.10 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.9 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.8 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.7 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.6 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.5 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.4 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.3 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.2 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.1 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/1 (IMPLIES (ZP N) (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/1' (IMPLIES (AND (ZP N) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :executable-counterparts of <, INTEGERP, NOT, TOWER and ZP and linear arithmetic, to Subgoal *1/1'' (IMPLIES (AND (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C 0 S)) (EQUAL (PLAY (H A B C 0) (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :definitions APP, BIG- TOPS, H and PLAY, the :executable-counterparts of CONSP and ZP, linear arithmetic, primitive type reasoning and the :rewrite rule PUT-GET. That completes the proof of *1. Q.E.D. Summary Form: ( DEFTHM H-LEMMA ...) Rules: ((:COMPOUND-RECOGNIZER ACL2::NATP-COMPOUND-RECOGNIZER) (:COMPOUND-RECOGNIZER ACL2::ZP-COMPOUND-RECOGNIZER) (:DEFINITION A) (:DEFINITION APP) (:DEFINITION B) (:DEFINITION BIG-TOPS) (:DEFINITION DO-MOVE) (:DEFINITION GET) (:DEFINITION H) (:DEFINITION LEGAL-MOVEP) (:DEFINITION LEGAL-SYNTAXP) (:DEFINITION LEN) (:DEFINITION MEM) (:DEFINITION NATP) (:DEFINITION NOT) (:DEFINITION PLAY) (:DEFINITION POP) (:DEFINITION PUSH) (:DEFINITION TOP) (:DEFINITION TOWER) (:EXECUTABLE-COUNTERPART <) (:EXECUTABLE-COUNTERPART BINARY-+) (:EXECUTABLE-COUNTERPART CAR) (:EXECUTABLE-COUNTERPART CDR) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART EQUAL) (:EXECUTABLE-COUNTERPART INTEGERP) (:EXECUTABLE-COUNTERPART LEN) (:EXECUTABLE-COUNTERPART NOT) (:EXECUTABLE-COUNTERPART TOWER) (:EXECUTABLE-COUNTERPART ZP) (:FAKE-RUNE-FOR-LINEAR NIL) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:INDUCTION INDUCTION-HINT) (:REWRITE APP-ASSOC) (:REWRITE CAR-CONS) (:REWRITE CDR-CONS) (:REWRITE GET-PUT) (:REWRITE LEN-PUT) (:REWRITE PERM-OPENER) (:REWRITE PLAY-APP) (:REWRITE PUT-GET) (:REWRITE PUT-PUT-1) (:REWRITE PUT-PUT-2) (:REWRITE TRUE-LISTP-PUT)) Warnings: None Time: 3.41 seconds (prove: 2.76, print: 0.59, proof tree: 0.06, other: 0.00) H-LEMMA HANOI !>:U 35:x(DEFMACRO DO-PROOF NIL ...) HANOI !>(in-theory (disable get-put)) Summary Form: ( IN-THEORY (DISABLE ...)) Rules: NIL Warnings: None Time: 0.01 seconds (prove: 0.00, print: 0.00, proof tree: 0.00, other: 0.01) 1845 HANOI !>(do-proof) << Starting proof tree logging >> [Note: A hint was supplied for our processing of the goal above. Thanks!] Name the formula above *1. We have been told to use induction. One induction scheme is suggested by the induction hint. We will induct according to a scheme suggested by (INDUCTION-HINT A B C N S). This suggestion was produced using the :induction rule INDUCTION-HINT. If we let (:P A B C N S) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (ZP N)) (:P A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S)) (:P B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (:P A B C N S)) (IMPLIES (ZP N) (:P A B C N S))). This induction is justified by the same argument used to admit INDUCTION- HINT, namely, the measure (ACL2-COUNT N) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). Note, however, that the unmeasured variables C, A, B and S are being instantiated. When applied to the goal at hand the above induction scheme produces the following two nontautological subgoals. Subgoal *1/2 (IMPLIES (AND (NOT (ZP N)) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET A S)) A S)) (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S)))) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET C S)) C S)) (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))))) (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)))). By the simple :definitions NATP and PUSH and the simple :rewrite rules PERM-OPENER and PUT-PUT-2 we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (NOT (ZP N)) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET A S)) A S)) (EQUAL (LEN (PUT (CONS N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (CONS N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B (PUT (CONS N (GET A S)) A S)))) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rules ACL2::NATP-COMPOUND- RECOGNIZER and ACL2::ZP-COMPOUND-RECOGNIZER, the :definitions A, APP, B, BIG-TOPS, DO-MOVE, GET, H, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH, TOP and TOWER, the :executable-counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules APP-ASSOC, CAR-CONS, CDR-CONS, LEN-PUT, PERM-OPENER, PLAY-APP, PUT-PUT-1 and TRUE- LISTP-PUT, to the following 115 conjectures. (By the way, the case limit affected this analysis. See :DOC case-split-limitations.) Subgoal *1/2.115 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/2.115' (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (INTEGERP (+ -1 N)) (<= 0 (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). [SGC for 6725 CONS pages..(14946 writable)..(T=4).GC finished] This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions BIG-TOPS, H and TOWER, the :executable- counterpart of EQUAL, linear arithmetic, primitive type reasoning and the :rewrite rules LEN-PUT and TRUE-LISTP-PUT, to the following 64 conjectures. Subgoal *1/2.115.64 (IMPLIES (AND (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.115.63 (IMPLIES (AND (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.115.63' (IMPLIES (AND (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS, to the following 24 conjectures. Subgoal *1/2.115.63.24 (IMPLIES (AND (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :compound-recognizer rule ACL2::NATP-COMPOUND- RECOGNIZER, primitive type reasoning, the :rewrite rule PUT-PUT-1 and the :type-prescription rule PUT, to Subgoal *1/2.115.63.24' (IMPLIES (AND (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N))) (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S))))). We generalize this conjecture, replacing (GET 2 S) by GT, (+ -1 N) by I and (GET A S) by GT0 and restricting the type of the new variable I to be that of the term it replaces, as established by primitive type reasoning and ACL2::ZP-COMPOUND-RECOGNIZER. This produces Subgoal *1/2.115.63.24'' (IMPLIES (AND (INTEGERP I) (<= 0 I) (EQUAL (PLAY (H A 2 B I) (PUT (APP (TOWER I) (GET A (PUT (CONS N GT0) A S))) A S)) (PUT (CONS N GT0) A (PUT (APP (TOWER I) (GET B (PUT (CONS N GT0) A S))) B S))) (<= 0 I) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP (TOWER I) (GET B (PUT (CONS N GT) 2 S))) B S))) (PUT (APP (TOWER I) (GET 2 (PUT (CONS N GT) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N))) (CONSP (GET A (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S))))). By case analysis we reduce the conjecture to Subgoal *1/2.115.63.24''' (IMPLIES (AND (INTEGERP I) (<= 0 I) (EQUAL (PLAY (H A 2 B I) (PUT (APP (TOWER I) (GET A (PUT (CONS N GT0) A S))) A S)) (PUT (CONS N GT0) A (PUT (APP (TOWER I) (GET B (PUT (CONS N GT0) A S))) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP (TOWER I) (GET B (PUT (CONS N GT) 2 S))) B S))) (PUT (APP (TOWER I) (GET 2 (PUT (CONS N GT) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N))) (CONSP (GET A (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S))))). We generalize this conjecture, replacing (H A 2 B I) by H, (PUT (CONS N GT) 2 S) by L, (PUT (CONS N GT0) A S) by L0 and (TOWER I) by TR and restricting the types of the new variables L and L0 to be those of the terms they replace, as established by PUT. This produces Subgoal *1/2.115.63.24'4' (IMPLIES (AND (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N))) (CONSP (GET A (PLAY H (PUT (APP TR (CONS N GT0)) A S))))). Name the formula above *1.1. Subgoal *1/2.115.63.23 (IMPLIES (AND (EQUAL (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 0 S)) 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 0 S)) 0 S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL B 0)) (NOT (EQUAL B 2)) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :executable-counterparts of <, EQUAL, INTEGERP and NOT and linear arithmetic, to Subgoal *1/2.115.63.23' (IMPLIES (AND (EQUAL (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 0 S)) 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 0 S)) 0 S))) 1 S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 2 S)) 2 S))) 1 (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (CONSP (GET 0 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :definitions GET and PUT, the :executable- counterparts of BINARY-+ and ZP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS, to Subgoal *1/2.115.63.23'' (IMPLIES (AND (EQUAL (PLAY (H 0 2 1 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CONS N (CAR S))) (CDR S))) (CONS (CONS N (CAR S)) (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S)))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 2 S)) 2 S))) 1 (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (CAR S))) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (NOT (CONSP (GET 1 (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S)))))) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (CONS (CAR S) (PUT (CONS N (GET 1 (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S)))) 1 (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :definitions GET, LEN, PUT and TRUE-LISTP, the :executable-counterparts of BINARY-+, CAR, CDR, CONSP, EQUAL, GET, LEN, NOT and ZP, primitive type reasoning and the :rewrite rules CAR- CONS and CDR-CONS, to Subgoal *1/2.115.63.23''' (IMPLIES (AND (EQUAL (PLAY (H 0 2 1 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CONS N (CAR S))) (CDR S))) (LIST* (CONS N (CAR S)) (APP (TOWER (+ -1 N)) (CADR S)) (CDDR S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 (CDR S))) 2 S))) 1 (PUT (CONS N (GET 1 (CDR S))) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 1 (CDR S))) 2 S))) 2 S)) (<= 0 N) (CONSP S) (TRUE-LISTP (CDR S)) (EQUAL (+ 1 (LEN (CDR S))) 3) (NOT (CONSP (CAR S))) (NOT (CONSP (CADR S))) (NOT (CONSP (GET 1 (CDR S)))) (NOT (ZP N)) (NOT (CONSP (CADDR S)))) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* (CAR S) (APP (TOWER (+ -1 N)) (CADR S)) (CONS N (CADDR S)) (CDDDR S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 (CDR S)))) 2 S))). But simplification reduces this to T, using the :definitions GET, LEN, PUT and TRUE-LISTP, the :executable-counterparts of BINARY-+, EQUAL, LEN and ZP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS. Subgoal *1/2.115.63.22 (IMPLIES (AND (EQUAL (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 0 S)) 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 0 S)) 0 S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL B 0)) (NOT (EQUAL B 2)) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :executable-counterparts of <, EQUAL, INTEGERP and NOT and linear arithmetic, to Subgoal *1/2.115.63.22' (IMPLIES (AND (EQUAL (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 0 S)) 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 0 S)) 0 S))) 1 S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 2 S)) 2 S))) 1 (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (CONSP (GET 0 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :definitions GET and PUT, the :executable- counterparts of BINARY-+ and ZP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS, to Subgoal *1/2.115.63.22'' (IMPLIES (AND (EQUAL (PLAY (H 0 2 1 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CONS N (CAR S))) (CDR S))) (CONS (CONS N (CAR S)) (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S)))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 2 S)) 2 S))) 1 (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (CAR S))) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (< N (CAR (GET 1 (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S)))))) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (CONS (CAR S) (PUT (CONS N (GET 1 (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S)))) 1 (CDR (PUT (APP (TOWER (+ -1 N)) (CADR S)) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :definitions GET, LEN, PUT and TRUE-LISTP, the :executable-counterparts of BINARY-+, CAR, CDR, CONSP, EQUAL, GET, LEN, NOT and ZP, primitive type reasoning and the :rewrite rules CAR- CONS and CDR-CONS, to Subgoal *1/2.115.63.22''' (IMPLIES (AND (EQUAL (PLAY (H 0 2 1 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CONS N (CAR S))) (CDR S))) (LIST* (CONS N (CAR S)) (APP (TOWER (+ -1 N)) (CADR S)) (CDDR S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 (CDR S))) 2 S))) 1 (PUT (CONS N (GET 1 (CDR S))) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 1 (CDR S))) 2 S))) 2 S)) (<= 0 N) (CONSP S) (TRUE-LISTP (CDR S)) (EQUAL (+ 1 (LEN (CDR S))) 3) (NOT (CONSP (CAR S))) (NOT (CONSP (CADR S))) (NOT (CONSP (GET 1 (CDR S)))) (NOT (ZP N)) (< N (CAADDR S))) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* (CAR S) (APP (TOWER (+ -1 N)) (CADR S)) (CONS N (CADDR S)) (CDDDR S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 (CDR S)))) 2 S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER, the :definitions GET, LEN, PUT and TRUE-LISTP, the :executable-counterparts of BINARY-+ and ZP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS. Subgoal *1/2.115.63.21 (IMPLIES (AND (EQUAL (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 1 S)) 1 S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL B 1)) (NOT (EQUAL B 2)) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :executable-counterparts of <, EQUAL, INTEGERP and NOT and linear arithmetic, to Subgoal *1/2.115.63.21' (IMPLIES (AND (EQUAL (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 1 S)) 1 S))) 0 S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 2 S)) 2 S))) 0 (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (CONSP (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :definitions GET and PUT, the :executable- counterparts of BINARY-+ and ZP and the :rewrite rules CAR-CONS and CDR-CONS, to Subgoal *1/2.115.63.21'' (IMPLIES (AND (EQUAL (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (LIST* (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (GET 1 S)) 1 S))) (CONS N (GET 1 S)) (CDDR S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (GET 2 S)) 2 S))) (CDR (PUT (CONS N (GET 2 S)) 2 S)))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (CAR S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (CONSP (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :definitions GET, LEN and TRUE-LISTP, the :executable-counterparts of BINARY-+, CAR, CDR, CONSP, EQUAL, GET, LEN, NOT and ZP and primitive type reasoning, to Subgoal *1/2.115.63.21''' (IMPLIES (AND (EQUAL (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (CADR S)) 1 S))) 1 S)) (LIST* (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (CADR S)) 1 S))) (CONS N (CADR S)) (CDDR S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (CADDR S)) 2 S))) (CDR (PUT (CONS N (CADDR S)) 2 S)))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (CADDR S)) 2 S))) 2 S)) (<= 0 N) (CONSP S) (CONSP (CDR S)) (TRUE-LISTP (CDDR S)) (EQUAL (+ 1 1 (LEN (CDDR S))) 3) (NOT (CONSP (CADR S))) (NOT (CONSP (CAR S))) (NOT (CONSP (CADDR S))) (NOT (ZP N)) (CONSP (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))))) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADDR S))) 2 S))). But simplification reduces this to T, using the :definitions GET and PUT, the :executable-counterparts of BINARY-+ and ZP, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, DEFAULT-<-2 and DEFAULT-CAR. Subgoal *1/2.115.63.20 (IMPLIES (AND (EQUAL (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 1 S)) 1 S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL B 1)) (NOT (EQUAL B 2)) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :executable-counterparts of <, EQUAL, INTEGERP and NOT and linear arithmetic, to Subgoal *1/2.115.63.20' (IMPLIES (AND (EQUAL (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 1 S)) 1 S))) 0 S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 2 S)) 2 S))) 0 (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (CONSP (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :definitions GET and PUT, the :executable- counterparts of BINARY-+ and ZP and the :rewrite rules CAR-CONS and CDR-CONS, to Subgoal *1/2.115.63.20'' (IMPLIES (AND (EQUAL (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (LIST* (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (GET 1 S)) 1 S))) (CONS N (GET 1 S)) (CDDR S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (GET 2 S)) 2 S))) (CDR (PUT (CONS N (GET 2 S)) 2 S)))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (CAR S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (CONSP (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). [SGC for 6725 CONS pages..(15146 writable)..(T=4).GC finished] This simplifies, using the :definitions GET, LEN and TRUE-LISTP, the :executable-counterparts of BINARY-+, CAR, CDR, CONSP, EQUAL, GET, LEN, NOT and ZP and primitive type reasoning, to Subgoal *1/2.115.63.20''' (IMPLIES (AND (EQUAL (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (CADR S)) 1 S))) 1 S)) (LIST* (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (CADR S)) 1 S))) (CONS N (CADR S)) (CDDR S))) (<= 0 (+ -1 N)) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (CONS (APP (TOWER (+ -1 N)) (CAR (PUT (CONS N (CADDR S)) 2 S))) (CDR (PUT (CONS N (CADDR S)) 2 S)))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (CADDR S)) 2 S))) 2 S)) (<= 0 N) (CONSP S) (CONSP (CDR S)) (TRUE-LISTP (CDDR S)) (EQUAL (+ 1 1 (LEN (CDDR S))) 3) (NOT (CONSP (CADR S))) (NOT (CONSP (CAR S))) (NOT (CONSP (CADDR S))) (NOT (ZP N)) (CONSP (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))))) (EQUAL (PLAY (H 0 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) (GET 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S)))) 2 (PLAY (H 1 2 0 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADR S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (CADDR S))) 2 S))). But simplification reduces this to T, using the :definitions GET and PUT, the :executable-counterparts of BINARY-+ and ZP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS. Subgoal *1/2.115.63.19 (IMPLIES (AND (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :compound-recognizer rule ACL2::NATP-COMPOUND- RECOGNIZER, primitive type reasoning, the :rewrite rule PUT-PUT-1 and the :type-prescription rule PUT, to Subgoal *1/2.115.63.19' (IMPLIES (AND (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (NOT (ZP N)) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S))))) (< (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))). We generalize this conjecture, replacing (GET 2 S) by GT, (+ -1 N) by I and (GET A S) by GT0 and restricting the type of the new variable I to be that of the term it replaces, as established by primitive type reasoning and ACL2::ZP-COMPOUND-RECOGNIZER. This produces Subgoal *1/2.115.63.19'' (IMPLIES (AND (INTEGERP I) (<= 0 I) (EQUAL (PLAY (H A 2 B I) (PUT (APP (TOWER I) (GET A (PUT (CONS N GT0) A S))) A S)) (PUT (CONS N GT0) A (PUT (APP (TOWER I) (GET B (PUT (CONS N GT0) A S))) B S))) (<= 0 I) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP (TOWER I) (GET B (PUT (CONS N GT) 2 S))) B S))) (PUT (APP (TOWER I) (GET 2 (PUT (CONS N GT) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N)) (CONSP (GET 2 (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S))))) (< (CAR (GET A (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S)))) (CAR (GET 2 (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S)))))). By case analysis we reduce the conjecture to Subgoal *1/2.115.63.19''' (IMPLIES (AND (INTEGERP I) (<= 0 I) (EQUAL (PLAY (H A 2 B I) (PUT (APP (TOWER I) (GET A (PUT (CONS N GT0) A S))) A S)) (PUT (CONS N GT0) A (PUT (APP (TOWER I) (GET B (PUT (CONS N GT0) A S))) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP (TOWER I) (GET B (PUT (CONS N GT) 2 S))) B S))) (PUT (APP (TOWER I) (GET 2 (PUT (CONS N GT) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N)) (CONSP (GET 2 (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S))))) (< (CAR (GET A (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S)))) (CAR (GET 2 (PLAY (H A 2 B I) (PUT (APP (TOWER I) (CONS N GT0)) A S)))))). We generalize this conjecture, replacing (H A 2 B I) by H, (PUT (CONS N GT) 2 S) by L, (PUT (CONS N GT0) A S) by L0 and (TOWER I) by TR and restricting the types of the new variables L and L0 to be those of the terms they replace, as established by PUT. This produces Subgoal *1/2.115.63.19'4' (IMPLIES (AND (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N)) (CONSP (GET 2 (PLAY H (PUT (APP TR (CONS N GT0)) A S))))) (< (CAR (GET A (PLAY H (PUT (APP TR (CONS N GT0)) A S)))) (CAR (GET 2 (PLAY H (PUT (APP TR (CONS N GT0)) A S)))))). We generalize this conjecture, replacing (APP TR (CONS N GT0)) by L1 and restricting the type of the new variable L1 to be that of the term it replaces, as established by primitive type reasoning and APP. This produces Subgoal *1/2.115.63.19'5' (IMPLIES (AND (CONSP L1) (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N)) (CONSP (GET 2 (PLAY H (PUT L1 A S))))) (< (CAR (GET A (PLAY H (PUT L1 A S)))) (CAR (GET 2 (PLAY H (PUT L1 A S)))))). We generalize this conjecture, replacing (PUT L1 A S) by L2 and restricting the type of the new variable L2 to be that of the term it replaces, as established by PUT. This produces Subgoal *1/2.115.63.19'6' (IMPLIES (AND (CONSP L2) (CONSP L1) (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N)) (CONSP (GET 2 (PLAY H L2)))) (< (CAR (GET A (PLAY H L2))) (CAR (GET 2 (PLAY H L2))))). We generalize this conjecture, replacing (PLAY H L2) by PY. This produces Subgoal *1/2.115.63.19'7' (IMPLIES (AND (CONSP L2) (CONSP L1) (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N)) (CONSP (GET 2 PY))) (< (CAR (GET A PY)) (CAR (GET 2 PY)))). We generalize this conjecture, replacing (GET 2 PY) by L3. This produces Subgoal *1/2.115.63.19'8' (IMPLIES (AND (CONSP L2) (CONSP L1) (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N)) (CONSP L3)) (< (CAR (GET A PY)) (CAR L3))). The destructor terms (CAR L3) and (CDR L3) can be eliminated by using CAR-CDR-ELIM to replace L3 by (CONS L4 L5), (CAR L3) by L4 and (CDR L3) by L5. This produces the following goal. Subgoal *1/2.115.63.19'9' (IMPLIES (AND (CONSP (CONS L4 L5)) (CONSP L2) (CONSP L1) (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N))) (< (CAR (GET A PY)) L4)). This simplifies, using primitive type reasoning, to Subgoal *1/2.115.63.19'10' (IMPLIES (AND (CONSP L2) (CONSP L1) (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N))) (< (CAR (GET A PY)) L4)). We suspect that the terms (CONSP L1) and (CONSP L2) are irrelevant to the truth of this conjecture and throw them out. We will thus try to prove Subgoal *1/2.115.63.19'11' (IMPLIES (AND (CONSP L) (CONSP L0) (INTEGERP I) (<= 0 I) (EQUAL (PLAY H (PUT (APP TR (GET A L0)) A S)) (PUT (CONS N GT0) A (PUT (APP TR (GET B L0)) B S))) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 2)) (NOT (EQUAL A 2)) (EQUAL (PLAY (H B A 2 I) (PUT (CONS N GT) 2 (PUT (APP TR (GET B L)) B S))) (PUT (APP TR (GET 2 L)) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP GT0)) (NOT (CONSP (GET B S))) (NOT (CONSP GT)) (NOT (ZP N))) (< (CAR (GET A PY)) L4)). Name the formula above *1.2. Subgoal *1/2.115.63.18 (IMPLIES (AND (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 1 S)) 1 S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.115.63.17 (IMPLIES (AND (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 0 S)) 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 0 S)) 0 S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.115.63.16 (IMPLIES (AND (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.115.63.15 (IMPLIES (AND (EQUAL (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 1)) (NOT (EQUAL A 1)) (EQUAL (PLAY (H B A 1 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 1 S)) 1 S))) B (PUT (CONS N (GET 1 S)) 1 S))) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 1 S))) (NOT (ZP N)) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). This simplifies, using the :compound-recognizer rule ACL2::NATP-COMPOUND- RECOGNIZER, primitive type reasoning, the :rewrite rule PUT-PUT-1 and the :type-prescription rule PUT, to Subgoal *1/2.115.63.15' (IMPLIES (AND (EQUAL (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (NOT (EQUAL B A)) (NOT (EQUAL B 1)) (NOT (EQUAL A 1)) (EQUAL (PLAY (H B A 1 (+ -1 N)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 1 S)) 1 S))) B S))) (PUT (APP (TOWER (+ -1 N)) (GET 1 (PUT (CONS N (GET 1 S)) 1 S))) 1 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 1 S))) (NOT (ZP N))) (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S))))). Error: Console interrupt. Fast links are on: do (si::use-fast-links nil) for debugging Error signalled by DEFTHM-FN. Broken at COND. Type :H for Help. ACL2[RAW LISP]>>:q Here is the current pstack [see :DOC pstack]: (ACL2::WATERFALL) HANOI !>:pe get-put D 11 (DEFTHM GET-PUT (IMPLIES (AND (NATP I) (NATP J)) (EQUAL (GET I (PUT V J X)) (IF (EQUAL I J) V (GET I X))))) HANOI !>:pl get Rune: (:REWRITE GET-PUT) Status: Disabled Lhs: (GET I (PUT V J X)) Rhs: (IF (EQUAL I J) V (GET I X)) Hyps: (AND (NATP I) (NATP J)) Equiv: EQUAL Backchain-limit-lst: NIL Subclass: ACL2::BACKCHAIN Loop-stopper: NIL Rune: (:DEFINITION GET) Status: Enabled Lhs: (GET N X) Rhs: (IF (ZP N) (CAR X) (GET (+ -1 N) (CDR X))) Hyps: T Equiv: EQUAL Backchain-limit-lst: NIL Subclass: ACL2::DEFINITION Controller-alist: ((GET T NIL)) HANOI !>:pl (GET B (PUT (CONS N (GET A S)) A S)) 1. GET-PUT (disabled) New term: (IF (EQUAL B A) (CONS N (GET A S)) (GET B S)) Hypotheses: ((NATP B) (NATP A)) HANOI !>(include-book "misc/find-lemmas" :dir :system) Loading /v/filer3/v0q004/acl2/v2-9-4-linux/books/misc/find-lemmas.o start address -T 0x8f51000 Finished loading /v/filer3/v0q004/acl2/v2-9-4-linux/books/misc/find-lemmas.o Summary Form: ( INCLUDE-BOOK "misc/find-lemmas" ...) Rules: NIL Warnings: None Time: 0.01 seconds (prove: 0.00, print: 0.00, proof tree: 0.00, other: 0.01) "/v/filer3/v0q004/acl2/v2-9-4-linux/books/misc/find-lemmas.lisp" HANOI !>(find-lemmas (get put)) ACL2 Error in ACL2::TOP-LEVEL: The symbol FIND-LEMMAS (in package "HANOI") has neither a function nor macro definition in ACL2. Please define it. HANOI !>(acl2::find-lemmas (get put)) ((DEFTHM GET-PUT (IMPLIES (AND (NATP I) (NATP J)) (EQUAL (GET I (PUT V J X)) (IF (EQUAL I J) V (GET I X))))) (DEFTHM PUT-GET (IMPLIES (AND (EQUAL X (GET N S)) (NATP N) (< N (LEN S))) (EQUAL (PUT X N S) S)))) HANOI !>(verify (proof-term)) ->: p (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))) ->: th *** Top-level hypotheses: There are no top-level hypotheses. The current subterm is: (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))) ->: (induct (induction-hint a b c n s)) ***** Now entering the theorem prover ***** << Starting proof tree logging >> [Note: A hint was supplied for our processing of the goal above. Thanks!] Name the formula above *1. We have been told to use induction. One induction scheme is suggested by the induction hint. We will induct according to a scheme suggested by (INDUCTION-HINT A B C N S). This suggestion was produced using the :induction rule INDUCTION-HINT. If we let (:P A B C N S) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (ZP N)) (:P A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S)) (:P B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (:P A B C N S)) (IMPLIES (ZP N) (:P A B C N S))). This induction is justified by the same argument used to admit INDUCTION- HINT, namely, the measure (ACL2-COUNT N) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). Note, however, that the unmeasured variables C, A, B and S are being instantiated. When applied to the goal at hand the above induction scheme produces the following two nontautological subgoals. Subgoal *1/2 (IMPLIES (AND (NOT (ZP N)) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET A S)) A S)) (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S)))) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET C S)) C S)) (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))))) (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal *1/2|. Subgoal *1/1 (IMPLIES (ZP N) (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal *1/1|. That completes the proof of *1. Q.E.D. Creating two new goals: (ACL2::MAIN . 1) and (ACL2::MAIN . 2). The proof of the current goal, ACL2::MAIN, has been completed. However, the following subgoals remain to be proved: (ACL2::MAIN . 1) and (ACL2::MAIN . 2). Now proving (ACL2::MAIN . 1). ->: goals (ACL2::MAIN . 1) (ACL2::MAIN . 2) ->: comm 1. (:INDUCT (INDUCTION-HINT A B C N S)) << no event name specified at start >> ->: th *** Top-level hypotheses: 1. (NOT (ZP N)) 2. (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET A S)) A S)) (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S)))) 3. (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET C S)) C S)) (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S)))) The current subterm is: (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))) ->: goals (ACL2::MAIN . 1) (ACL2::MAIN . 2) ->: cg Now proving (ACL2::MAIN . 2). ->: goals (ACL2::MAIN . 2) (ACL2::MAIN . 1) ->: th *** Top-level hypotheses: 1. (ZP N) The current subterm is: (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))) ->: prove ***** Now entering the theorem prover ***** << Starting proof tree logging >> By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Goal' (IMPLIES (AND (ZP N) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :executable-counterparts of <, INTEGERP, NOT, TOWER and ZP and linear arithmetic, to Goal'' (IMPLIES (AND (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C 0 S)) (EQUAL (PLAY (H A B C 0) (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :definitions APP, BIG- TOPS, H and PLAY, the :executable-counterparts of CONSP and ZP, linear arithmetic, primitive type reasoning and the :rewrite rule PUT-GET. Q.E.D. The proof of the current goal, (ACL2::MAIN . 2), has been completed, as have all of its subgoals. Now proving (ACL2::MAIN . 1). ->: goals (ACL2::MAIN . 1) ->: th *** Top-level hypotheses: 1. (NOT (ZP N)) 2. (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET A S)) A S)) (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S)))) 3. (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET C S)) C S)) (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S)))) The current subterm is: (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))) ->: split ***** Now entering the theorem prover ***** << Starting proof tree logging >> [Note: A hint was supplied for our processing of the goal above. Thanks!] By case analysis we reduce the conjecture to Goal' (IMPLIES (AND (NOT (ZP N)) (OR (NOT (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET A S)) A S)) (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S)))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S)))) (OR (NOT (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET C S)) C S)) (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S)))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S)))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using trivial observations, to the following 31 conjectures. Subgoal 31 (IMPLIES (AND (NOT (ZP N)) (NOT (NATP (+ -1 N))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 31|. Subgoal 30 (IMPLIES (AND (NOT (ZP N)) (NOT (PERM (LIST A C B) '(0 1 2))) (NOT (NATP (+ -1 N))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 30|. Subgoal 29 (IMPLIES (AND (NOT (ZP N)) (NOT (PERM (LIST A C B) '(0 1 2))) (NOT (PERM (LIST B A C) '(0 1 2))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 29|. Subgoal 28 (IMPLIES (AND (NOT (ZP N)) (NOT (PERM (LIST A C B) '(0 1 2))) (NOT (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3)) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 28|. Subgoal 27 (IMPLIES (AND (NOT (ZP N)) (NOT (PERM (LIST A C B) '(0 1 2))) (NOT (TRUE-LISTP (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 27|. Subgoal 26 (IMPLIES (AND (NOT (ZP N)) (NOT (PERM (LIST A C B) '(0 1 2))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 26|. Subgoal 25 (IMPLIES (AND (NOT (ZP N)) (NOT (PERM (LIST A C B) '(0 1 2))) (NOT (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 25|. Subgoal 24 (IMPLIES (AND (NOT (ZP N)) (NOT (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3)) (NOT (NATP (+ -1 N))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 24|. Subgoal 23 (IMPLIES (AND (NOT (ZP N)) (NOT (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3)) (NOT (PERM (LIST B A C) '(0 1 2))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 23|. Subgoal 22 (IMPLIES (AND (NOT (ZP N)) (NOT (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3)) (NOT (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3)) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 22|. Subgoal 21 (IMPLIES (AND (NOT (ZP N)) (NOT (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3)) (NOT (TRUE-LISTP (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 21|. Subgoal 20 (IMPLIES (AND (NOT (ZP N)) (NOT (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 20|. Subgoal 19 (IMPLIES (AND (NOT (ZP N)) (NOT (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3)) (NOT (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 19|. Subgoal 18 (IMPLIES (AND (NOT (ZP N)) (NOT (TRUE-LISTP (PUT (PUSH N (GET A S)) A S))) (NOT (NATP (+ -1 N))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 18|. Subgoal 17 (IMPLIES (AND (NOT (ZP N)) (NOT (TRUE-LISTP (PUT (PUSH N (GET A S)) A S))) (NOT (PERM (LIST B A C) '(0 1 2))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 17|. Subgoal 16 (IMPLIES (AND (NOT (ZP N)) (NOT (TRUE-LISTP (PUT (PUSH N (GET A S)) A S))) (NOT (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3)) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 16|. Subgoal 15 (IMPLIES (AND (NOT (ZP N)) (NOT (TRUE-LISTP (PUT (PUSH N (GET A S)) A S))) (NOT (TRUE-LISTP (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 15|. Subgoal 14 (IMPLIES (AND (NOT (ZP N)) (NOT (TRUE-LISTP (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 14|. Subgoal 13 (IMPLIES (AND (NOT (ZP N)) (NOT (TRUE-LISTP (PUT (PUSH N (GET A S)) A S))) (NOT (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 13|. Subgoal 12 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S))) (NOT (NATP (+ -1 N))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 12|. Subgoal 11 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S))) (NOT (PERM (LIST B A C) '(0 1 2))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 11|. Subgoal 10 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S))) (NOT (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3)) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 10|. Subgoal 9 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S))) (NOT (TRUE-LISTP (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 9|. Subgoal 8 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 8|. Subgoal 7 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S))) (NOT (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 7|. Subgoal 6 (IMPLIES (AND (NOT (ZP N)) (NOT (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (NOT (NATP (+ -1 N))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 6|. Subgoal 5 (IMPLIES (AND (NOT (ZP N)) (NOT (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (NOT (PERM (LIST B A C) '(0 1 2))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 5|. Subgoal 4 (IMPLIES (AND (NOT (ZP N)) (NOT (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (NOT (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3)) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 4|. Subgoal 3 (IMPLIES (AND (NOT (ZP N)) (NOT (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (NOT (TRUE-LISTP (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 3|. Subgoal 2 (IMPLIES (AND (NOT (ZP N)) (NOT (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 2|. Subgoal 1 (IMPLIES (AND (NOT (ZP N)) (NOT (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (NOT (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 1|. Q.E.D. Creating 31 new goals: ((ACL2::MAIN . 1) . 1), ((ACL2::MAIN . 1) . 2), ((ACL2::MAIN . 1) . 3), ((ACL2::MAIN . 1) . 4), ((ACL2::MAIN . 1) . 5), ((ACL2::MAIN . 1) . 6), ((ACL2::MAIN . 1) . 7), ((ACL2::MAIN . 1) . 8), ((ACL2::MAIN . 1) . 9), ((ACL2::MAIN . 1) . 10), ((ACL2::MAIN . 1) . 11), ((ACL2::MAIN . 1) . 12), ((ACL2::MAIN . 1) . 13), ((ACL2::MAIN . 1) . 14), ((ACL2::MAIN . 1) . 15), ((ACL2::MAIN . 1) . 16), ((ACL2::MAIN . 1) . 17), ((ACL2::MAIN . 1) . 18), ((ACL2::MAIN . 1) . 19), ((ACL2::MAIN . 1) . 20), ((ACL2::MAIN . 1) . 21), ((ACL2::MAIN . 1) . 22), ((ACL2::MAIN . 1) . 23), ((ACL2::MAIN . 1) . 24), ((ACL2::MAIN . 1) . 25), ((ACL2::MAIN . 1) . 26), ((ACL2::MAIN . 1) . 27), ((ACL2::MAIN . 1) . 28), ((ACL2::MAIN . 1) . 29), ((ACL2::MAIN . 1) . 30) and ((ACL2::MAIN . 1) . 31). The proof of the current goal, (ACL2::MAIN . 1), has been completed. However, the following subgoals remain to be proved: ((ACL2::MAIN . 1) . 1), ((ACL2::MAIN . 1) . 2), ((ACL2::MAIN . 1) . 3), ((ACL2::MAIN . 1) . 4), ((ACL2::MAIN . 1) . 5), ((ACL2::MAIN . 1) . 6), ((ACL2::MAIN . 1) . 7), ((ACL2::MAIN . 1) . 8), ((ACL2::MAIN . 1) . 9), ((ACL2::MAIN . 1) . 10), ((ACL2::MAIN . 1) . 11), ((ACL2::MAIN . 1) . 12), ((ACL2::MAIN . 1) . 13), ((ACL2::MAIN . 1) . 14), ((ACL2::MAIN . 1) . 15), ((ACL2::MAIN . 1) . 16), ((ACL2::MAIN . 1) . 17), ((ACL2::MAIN . 1) . 18), ((ACL2::MAIN . 1) . 19), ((ACL2::MAIN . 1) . 20), ((ACL2::MAIN . 1) . 21), ((ACL2::MAIN . 1) . 22), ((ACL2::MAIN . 1) . 23), ((ACL2::MAIN . 1) . 24), ((ACL2::MAIN . 1) . 25), ((ACL2::MAIN . 1) . 26), ((ACL2::MAIN . 1) . 27), ((ACL2::MAIN . 1) . 28), ((ACL2::MAIN . 1) . 29), ((ACL2::MAIN . 1) . 30) and ((ACL2::MAIN . 1) . 31). Now proving ((ACL2::MAIN . 1) . 1). ->: (quiet bash) Q.E.D. ->: undo Undoing: :BASH ->: (quiet prove) Q.E.D. ->: (quiet (repeat prove)) Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. [SGC for 10507 CONS pages..(19174 writable)..(T=6).GC finished] [SGC for 10507 CONS pages..(19252 writable)..(T=6).GC finished] [SGC for 416 FIXNUM pages..(21685 writable)..(T=7).GC finished] Error: Console interrupt. Fast links are on: do (si::use-fast-links nil) for debugging Error signalled by VERIFY-FN. Broken at COND. Type :H for Help. ACL2[RAW LISP]>:Q Here is the current pstack [see :DOC pstack]: (ACL2::EV-FNCALL ACL2::SIMPLIFY-CLAUSE ACL2::WATERFALL) HANOI !>:q Exiting the ACL2 read-eval-print loop. To re-enter, execute (LP). ACL2>(lp) ACL2 Version 2.9.4. Level 1. Cbd "/v/filer2/moore/public_html/acl2/seminar/2006.02.15-kaufmann/". Type :help for help. Type (good-bye) to quit completely out of ACL2. HANOI !>(verify) ->: comm 1. :PROVE 2. :PROVE 3. :PROVE 4. :PROVE 5. :PROVE 6. :PROVE 7. :PROVE 8. :PROVE 9. :PROVE 10. :PROVE 11. :PROVE 12. :PROVE 13. :PROVE 14. :PROVE 15. :PROVE 16. :PROVE 17. :PROVE 18. :PROVE 19. :PROVE 20. :PROVE 21. :PROVE 22. :PROVE 23. :PROVE 24. :SPLIT 25. :PROVE 26. (:CHANGE-GOAL NIL T) 27. (:INDUCT (INDUCTION-HINT A B C N S)) << no event name specified at start >> ->: th *** Top-level hypotheses: 1. (NOT (ZP N)) 2. (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S))) 3. (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))) 4. (NATP N) 5. (TRUE-LISTP S) 6. (EQUAL (LEN S) 3) 7. (PERM (LIST A B C) '(0 1 2)) 8. (BIG-TOPS A B C N S) The current subterm is: (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)) ->: (quiet bash) [SGC for 14204 CONS pages..(23141 writable)..(T=7).GC finished] [SGC for 14204 CONS pages..(23624 writable)..(T=7).GC finished] [SGC for 14204 CONS pages..(23668 writable)..(T=8).GC finished] [SGC for 14204 CONS pages..(23668 writable)..(T=8).GC finished] [SGC for 14204 CONS pages..(23668 writable)..(T=8).GC finished] [SGC for 14204 CONS pages..(23668 writable)..(T=8).GC finished] [SGC for 14204 CONS pages..(23668 writable)..(T=8).GC finished] [SGC for 14204 CONS pages..(23668 writable)..(T=8).GC finished] [SGC for 1245 STRING pages..(25198 writable)..(T=9).GC finished] [SGC for 1245 STRING pages..(25372 writable)..(T=9).GC finished] [SGC for 1245 STRING pages..(25372 writable)..(T=9).GC finished] [SGC for 20041 CONS pages..(29895 writable)..(T=11).GC finished] [SGC for 20041 CONS pages..(29900 writable)..(T=11).GC finished] [SGC for 20041 CONS pages..(29926 writable)..(T=12).GC finished] [SGC for 20041 CONS pages..(29926 writable)..(T=11).GC finished] Q.E.D. ->: goals (((ACL2::MAIN . 1) . 24) . 1) (((ACL2::MAIN . 1) . 24) . 2) (((ACL2::MAIN . 1) . 24) . 3) (((ACL2::MAIN . 1) . 24) . 4) (((ACL2::MAIN . 1) . 24) . 5) (((ACL2::MAIN . 1) . 24) . 6) (((ACL2::MAIN . 1) . 24) . 7) (((ACL2::MAIN . 1) . 24) . 8) (((ACL2::MAIN . 1) . 24) . 9) (((ACL2::MAIN . 1) . 24) . 10) (((ACL2::MAIN . 1) . 24) . 11) (((ACL2::MAIN . 1) . 24) . 12) (((ACL2::MAIN . 1) . 24) . 13) (((ACL2::MAIN . 1) . 24) . 14) (((ACL2::MAIN . 1) . 24) . 15) (((ACL2::MAIN . 1) . 24) . 16) (((ACL2::MAIN . 1) . 24) . 17) (((ACL2::MAIN . 1) . 24) . 18) (((ACL2::MAIN . 1) . 24) . 19) (((ACL2::MAIN . 1) . 24) . 20) (((ACL2::MAIN . 1) . 24) . 21) (((ACL2::MAIN . 1) . 24) . 22) (((ACL2::MAIN . 1) . 24) . 23) (((ACL2::MAIN . 1) . 24) . 24) (((ACL2::MAIN . 1) . 24) . 25) (((ACL2::MAIN . 1) . 24) . 26) (((ACL2::MAIN . 1) . 24) . 27) (((ACL2::MAIN . 1) . 24) . 28) (((ACL2::MAIN . 1) . 24) . 29) (((ACL2::MAIN . 1) . 24) . 30) (((ACL2::MAIN . 1) . 24) . 31) (((ACL2::MAIN . 1) . 24) . 32) (((ACL2::MAIN . 1) . 24) . 33) (((ACL2::MAIN . 1) . 24) . 34) (((ACL2::MAIN . 1) . 24) . 35) (((ACL2::MAIN . 1) . 24) . 36) (((ACL2::MAIN . 1) . 24) . 37) (((ACL2::MAIN . 1) . 24) . 38) (((ACL2::MAIN . 1) . 24) . 39) (((ACL2::MAIN . 1) . 24) . 40) (((ACL2::MAIN . 1) . 24) . 41) (((ACL2::MAIN . 1) . 24) . 42) (((ACL2::MAIN . 1) . 24) . 43) (((ACL2::MAIN . 1) . 24) . 44) (((ACL2::MAIN . 1) . 24) . 45) (((ACL2::MAIN . 1) . 24) . 46) (((ACL2::MAIN . 1) . 24) . 47) (((ACL2::MAIN . 1) . 24) . 48) (((ACL2::MAIN . 1) . 24) . 49) (((ACL2::MAIN . 1) . 24) . 50) (((ACL2::MAIN . 1) . 24) . 51) (((ACL2::MAIN . 1) . 24) . 52) (((ACL2::MAIN . 1) . 24) . 53) (((ACL2::MAIN . 1) . 24) . 54) (((ACL2::MAIN . 1) . 24) . 55) (((ACL2::MAIN . 1) . 24) . 56) (((ACL2::MAIN . 1) . 24) . 57) (((ACL2::MAIN . 1) . 24) . 58) (((ACL2::MAIN . 1) . 24) . 59) (((ACL2::MAIN . 1) . 24) . 60) (((ACL2::MAIN . 1) . 24) . 61) (((ACL2::MAIN . 1) . 24) . 62) (((ACL2::MAIN . 1) . 24) . 63) (((ACL2::MAIN . 1) . 24) . 64) ((ACL2::MAIN . 1) . 25) ((ACL2::MAIN . 1) . 26) ((ACL2::MAIN . 1) . 27) ((ACL2::MAIN . 1) . 28) ((ACL2::MAIN . 1) . 29) ((ACL2::MAIN . 1) . 30) ((ACL2::MAIN . 1) . 31) ->: undo Undoing: :BASH ->: bash ***** Now entering the theorem prover ***** << Starting proof tree logging >> [Note: A hint was supplied for our processing of the goal above. Thanks!] By the simple :definitions NATP and PUSH and the simple :rewrite rules PERM-OPENER and PUT-PUT-2 we reduce the conjecture to Goal' (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B (PUT (CONS N (GET A S)) A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, BIG-TOPS, DO-MOVE, GET, H, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH, TOP and TOWER, the :executable-counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, primitive type reasoning and the :rewrite rules APP-ASSOC, CAR-CONS, CDR-CONS, PLAY-APP and PUT-PUT-1, to the following 123 conjectures. (By the way, the case limit affected this analysis. See :DOC case-split-limitations.) Subgoal 123 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET C S)))) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, H, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH, TOP and TOWER, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, primitive type reasoning and the :rewrite rules APP-ASSOC, CAR-CONS, CDR-CONS and PLAY-APP, to the following 24 conjectures. Subgoal 123.24 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). This simplifies, using the :compound-recognizer rule ACL2::NATP-COMPOUND- RECOGNIZER, primitive type reasoning, the :rewrite rule PUT-PUT-1 and the :type-prescription rule PUT, to Subgoal 123.24' (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S)))) (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S))))). But we have been asked to pretend that this goal is subsumed by the as-yet-to-be-proved ACL2::|PROOF-CHECKER Subgoal 123.24'|. Subgoal 123.23 (IMPLIES (AND (NOT (ZP N)) (EQUAL (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET 0 (PUT (CONS N (GET 0 S)) 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 0 S)) 0 S))) B S))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B (PUT (CONS N (GET 2 S)) 2 S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). Error: Console interrupt. Fast links are on: do (si::use-fast-links nil) for debugging Error signalled by VERIFY-FN. Broken at COND. Type :H for Help. ACL2[RAW LISP]>>:q Here is the current pstack [see :DOC pstack]: (ACL2::WATERFALL) HANOI !>(verify) ->: restore ->: goals (((ACL2::MAIN . 1) . 24) . 1) (((ACL2::MAIN . 1) . 24) . 2) (((ACL2::MAIN . 1) . 24) . 3) (((ACL2::MAIN . 1) . 24) . 4) (((ACL2::MAIN . 1) . 24) . 5) (((ACL2::MAIN . 1) . 24) . 6) (((ACL2::MAIN . 1) . 24) . 7) (((ACL2::MAIN . 1) . 24) . 8) (((ACL2::MAIN . 1) . 24) . 9) (((ACL2::MAIN . 1) . 24) . 10) (((ACL2::MAIN . 1) . 24) . 11) (((ACL2::MAIN . 1) . 24) . 12) (((ACL2::MAIN . 1) . 24) . 13) (((ACL2::MAIN . 1) . 24) . 14) (((ACL2::MAIN . 1) . 24) . 15) (((ACL2::MAIN . 1) . 24) . 16) (((ACL2::MAIN . 1) . 24) . 17) (((ACL2::MAIN . 1) . 24) . 18) (((ACL2::MAIN . 1) . 24) . 19) (((ACL2::MAIN . 1) . 24) . 20) (((ACL2::MAIN . 1) . 24) . 21) (((ACL2::MAIN . 1) . 24) . 22) (((ACL2::MAIN . 1) . 24) . 23) (((ACL2::MAIN . 1) . 24) . 24) (((ACL2::MAIN . 1) . 24) . 25) (((ACL2::MAIN . 1) . 24) . 26) (((ACL2::MAIN . 1) . 24) . 27) (((ACL2::MAIN . 1) . 24) . 28) (((ACL2::MAIN . 1) . 24) . 29) (((ACL2::MAIN . 1) . 24) . 30) (((ACL2::MAIN . 1) . 24) . 31) (((ACL2::MAIN . 1) . 24) . 32) (((ACL2::MAIN . 1) . 24) . 33) (((ACL2::MAIN . 1) . 24) . 34) (((ACL2::MAIN . 1) . 24) . 35) (((ACL2::MAIN . 1) . 24) . 36) (((ACL2::MAIN . 1) . 24) . 37) (((ACL2::MAIN . 1) . 24) . 38) (((ACL2::MAIN . 1) . 24) . 39) (((ACL2::MAIN . 1) . 24) . 40) (((ACL2::MAIN . 1) . 24) . 41) (((ACL2::MAIN . 1) . 24) . 42) (((ACL2::MAIN . 1) . 24) . 43) (((ACL2::MAIN . 1) . 24) . 44) (((ACL2::MAIN . 1) . 24) . 45) (((ACL2::MAIN . 1) . 24) . 46) (((ACL2::MAIN . 1) . 24) . 47) (((ACL2::MAIN . 1) . 24) . 48) (((ACL2::MAIN . 1) . 24) . 49) (((ACL2::MAIN . 1) . 24) . 50) (((ACL2::MAIN . 1) . 24) . 51) (((ACL2::MAIN . 1) . 24) . 52) (((ACL2::MAIN . 1) . 24) . 53) (((ACL2::MAIN . 1) . 24) . 54) (((ACL2::MAIN . 1) . 24) . 55) (((ACL2::MAIN . 1) . 24) . 56) (((ACL2::MAIN . 1) . 24) . 57) (((ACL2::MAIN . 1) . 24) . 58) (((ACL2::MAIN . 1) . 24) . 59) (((ACL2::MAIN . 1) . 24) . 60) (((ACL2::MAIN . 1) . 24) . 61) (((ACL2::MAIN . 1) . 24) . 62) (((ACL2::MAIN . 1) . 24) . 63) (((ACL2::MAIN . 1) . 24) . 64) ((ACL2::MAIN . 1) . 25) ((ACL2::MAIN . 1) . 26) ((ACL2::MAIN . 1) . 27) ((ACL2::MAIN . 1) . 28) ((ACL2::MAIN . 1) . 29) ((ACL2::MAIN . 1) . 30) ((ACL2::MAIN . 1) . 31) ->: (save foo) ->: exit Exiting.... NIL HANOI !>(retrieve foo) ->: th *** Top-level hypotheses: 1. (NOT (ZP N)) 2. (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S))) 3. (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET 2 S)) 2 S))) B S))) (PUT (APP (TOWER (+ -1 N)) (GET 2 (PUT (CONS N (GET 2 S)) 2 S))) 2 S)) 4. (<= 0 N) 5. (TRUE-LISTP S) 6. (EQUAL (LEN S) 3) 7. (INTEGERP A) 8. (<= 0 A) 9. (<= A 2) 10. (INTEGERP B) 11. (<= 0 B) 12. (<= B 2) 13. (NOT (EQUAL A B)) 14. (NOT (EQUAL A 2)) 15. (NOT (EQUAL B 2)) 16. (NOT (CONSP (GET A S))) 17. (NOT (CONSP (GET B S))) 18. (NOT (CONSP (GET 2 S))) The current subterm is: (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) ->: (contradict 2) ->: p (NOT (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B S)))) ->: (dv 1 2 3 1 2 0) ->: p (GET B (PUT (CONS N (GET A S)) A S)) ->: p-top (NOT (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (*** (GET B (PUT (CONS N (GET A S)) A S)) ***)) B S)))) ->: p (GET B (PUT (CONS N (GET A S)) A S)) ->: sr ; show-rewrites 1. GET-PUT (disabled) New term: (IF (EQUAL B A) (CONS N (GET A S)) (GET B S)) Hypotheses: ->: (in-theory (enable get-put)) ->: prove *** NO CHANGE *** -- The PROVE command should only be used at the top. Use (= T) if that is what you want. ->: undo Undoing: (:IN-THEORY (ENABLE GET-PUT)) ->: undo Undoing: (:DV 1 2 3 1 2 0) ->: (in-theory (enable get-put)) ->: prove ***** Now entering the theorem prover ***** << Starting proof tree logging >> This simplifies, using the :compound-recognizer rule ACL2::NATP-COMPOUND- RECOGNIZER, the :executable-counterpart of EQUAL, primitive type reasoning and the :rewrite rule GET-PUT, to Goal' (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S))))) (EQUAL (PLAY (H B A 2 (+ -1 N)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (NOT (CONSP (GET A S))) (NOT (CONSP (GET B S))) (NOT (CONSP (GET 2 S)))) (NOT (EQUAL (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))))). But simplification reduces this to T, using primitive type reasoning and the :rewrite rule GET-PUT. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 1), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 2). ->: exit Exiting.... NIL HANOI !>(verify) ->: (quiet (repeat bash)) Q.E.D. Q.E.D. Q.E.D. Q.E.D. ->: goals (((ACL2::MAIN . 1) . 24) . 5) (((ACL2::MAIN . 1) . 24) . 6) (((ACL2::MAIN . 1) . 24) . 7) (((ACL2::MAIN . 1) . 24) . 8) (((ACL2::MAIN . 1) . 24) . 9) (((ACL2::MAIN . 1) . 24) . 10) (((ACL2::MAIN . 1) . 24) . 11) (((ACL2::MAIN . 1) . 24) . 12) (((ACL2::MAIN . 1) . 24) . 13) (((ACL2::MAIN . 1) . 24) . 14) (((ACL2::MAIN . 1) . 24) . 15) (((ACL2::MAIN . 1) . 24) . 16) (((ACL2::MAIN . 1) . 24) . 17) (((ACL2::MAIN . 1) . 24) . 18) (((ACL2::MAIN . 1) . 24) . 19) (((ACL2::MAIN . 1) . 24) . 20) (((ACL2::MAIN . 1) . 24) . 21) (((ACL2::MAIN . 1) . 24) . 22) (((ACL2::MAIN . 1) . 24) . 23) (((ACL2::MAIN . 1) . 24) . 24) (((ACL2::MAIN . 1) . 24) . 25) (((ACL2::MAIN . 1) . 24) . 26) (((ACL2::MAIN . 1) . 24) . 27) (((ACL2::MAIN . 1) . 24) . 28) (((ACL2::MAIN . 1) . 24) . 29) (((ACL2::MAIN . 1) . 24) . 30) (((ACL2::MAIN . 1) . 24) . 31) (((ACL2::MAIN . 1) . 24) . 32) (((ACL2::MAIN . 1) . 24) . 33) (((ACL2::MAIN . 1) . 24) . 34) (((ACL2::MAIN . 1) . 24) . 35) (((ACL2::MAIN . 1) . 24) . 36) (((ACL2::MAIN . 1) . 24) . 37) (((ACL2::MAIN . 1) . 24) . 38) (((ACL2::MAIN . 1) . 24) . 39) (((ACL2::MAIN . 1) . 24) . 40) (((ACL2::MAIN . 1) . 24) . 41) (((ACL2::MAIN . 1) . 24) . 42) (((ACL2::MAIN . 1) . 24) . 43) (((ACL2::MAIN . 1) . 24) . 44) (((ACL2::MAIN . 1) . 24) . 45) (((ACL2::MAIN . 1) . 24) . 46) (((ACL2::MAIN . 1) . 24) . 47) (((ACL2::MAIN . 1) . 24) . 48) (((ACL2::MAIN . 1) . 24) . 49) (((ACL2::MAIN . 1) . 24) . 50) (((ACL2::MAIN . 1) . 24) . 51) (((ACL2::MAIN . 1) . 24) . 52) (((ACL2::MAIN . 1) . 24) . 53) (((ACL2::MAIN . 1) . 24) . 54) (((ACL2::MAIN . 1) . 24) . 55) (((ACL2::MAIN . 1) . 24) . 56) (((ACL2::MAIN . 1) . 24) . 57) (((ACL2::MAIN . 1) . 24) . 58) (((ACL2::MAIN . 1) . 24) . 59) (((ACL2::MAIN . 1) . 24) . 60) (((ACL2::MAIN . 1) . 24) . 61) (((ACL2::MAIN . 1) . 24) . 62) (((ACL2::MAIN . 1) . 24) . 63) (((ACL2::MAIN . 1) . 24) . 64) ((ACL2::MAIN . 1) . 25) ((ACL2::MAIN . 1) . 26) ((ACL2::MAIN . 1) . 27) ((ACL2::MAIN . 1) . 28) ((ACL2::MAIN . 1) . 29) ((ACL2::MAIN . 1) . 30) ((ACL2::MAIN . 1) . 31) ->: prove ***** Now entering the theorem prover ***** << Starting proof tree logging >> The destructor terms (CAR S) and (CDR S) can be eliminated. Furthermore, those terms are at the root of a chain of three rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace S by (CONS S1 S2), (CAR S) by S1 and (CDR S) by S2. (2) Use CAR-CDR-ELIM, again, to replace S2 by (CONS S3 S4), (CAR S2) by S3 and (CDR S2) by S4. (3) Finally, use CAR-CDR-ELIM to replace S4 by (CONS S5 S6), (CAR S4) by S5 and (CDR S4) by S6. These steps produce the following goal. Goal' (IMPLIES (AND (CONSP (CONS S5 S6)) (CONSP (LIST* S3 S5 S6)) (CONSP (LIST* S1 S3 S5 S6)) (NOT (ZP N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)) (LIST* S1 (CONS N S3) (APP (TOWER (+ -1 N)) S5) S6)) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (CONS N S1) S3 (APP (TOWER (+ -1 N)) S5) S6)) (LIST* (APP (TOWER (+ -1 N)) (CONS N S1)) S3 S5 S6)) (<= 0 N) (TRUE-LISTP S6) (EQUAL (+ 1 1 1 (LEN S6)) 3) (NOT (CONSP S3)) (NOT (CONSP S5)) (NOT (CONSP S1))) (CONSP (GET 1 (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))))). But simplification reduces this to T, using the :definition GET, the :executable-counterparts of BINARY-+ and ZP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 5), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 6). ->: (repeat prove) #->: (ACL2::REPEAT-REC PROVE) ##->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> The destructor terms (CAR S) and (CDR S) can be eliminated. Furthermore, those terms are at the root of a chain of three rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace S by (CONS S1 S2), (CAR S) by S1 and (CDR S) by S2. (2) Use CAR-CDR-ELIM, again, to replace S2 by (CONS S3 S4), (CAR S2) by S3 and (CDR S2) by S4. (3) Finally, use CAR-CDR-ELIM to replace S4 by (CONS S5 S6), (CAR S4) by S5 and (CDR S4) by S6. These steps produce the following goal. Goal' (IMPLIES (AND (CONSP (CONS S5 S6)) (CONSP (LIST* S3 S5 S6)) (CONSP (LIST* S1 S3 S5 S6)) (NOT (ZP N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)) (LIST* S1 (CONS N S3) (APP (TOWER (+ -1 N)) S5) S6)) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (CONS N S1) S3 (APP (TOWER (+ -1 N)) S5) S6)) (LIST* (APP (TOWER (+ -1 N)) (CONS N S1)) S3 S5 S6)) (<= 0 N) (TRUE-LISTP S6) (EQUAL (+ 1 1 1 (LEN S6)) 3) (NOT (CONSP S3)) (NOT (CONSP S5)) (NOT (CONSP S1)) (CONSP (CADR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)))) (NOT (CONSP (CAR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)))))) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (CONS (CAADR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))) (CAR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)))) (CDADR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))) (CDDR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))))) (LIST* (APP (TOWER (+ -1 N)) (CONS N S1)) S3 S5 S6))). But simplification reduces this to T, using primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 6), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 7). ##->: (ACL2::REPEAT-REC PROVE) ###->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> The destructor terms (CAR S) and (CDR S) can be eliminated. Furthermore, those terms are at the root of a chain of three rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace S by (CONS S1 S2), (CAR S) by S1 and (CDR S) by S2. (2) Use CAR-CDR-ELIM, again, to replace S2 by (CONS S3 S4), (CAR S2) by S3 and (CDR S2) by S4. (3) Finally, use CAR-CDR-ELIM to replace S4 by (CONS S5 S6), (CAR S4) by S5 and (CDR S4) by S6. These steps produce the following goal. Goal' (IMPLIES (AND (CONSP (CONS S5 S6)) (CONSP (LIST* S3 S5 S6)) (CONSP (LIST* S1 S3 S5 S6)) (NOT (ZP N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)) (LIST* S1 (CONS N S3) (APP (TOWER (+ -1 N)) S5) S6)) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (CONS N S1) S3 (APP (TOWER (+ -1 N)) S5) S6)) (LIST* (APP (TOWER (+ -1 N)) (CONS N S1)) S3 S5 S6)) (<= 0 N) (TRUE-LISTP S6) (EQUAL (+ 1 1 1 (LEN S6)) 3) (NOT (CONSP S3)) (NOT (CONSP S5)) (NOT (CONSP S1)) (CONSP (CADR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)))) (< (CAADR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))) (CAAR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))))) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (CONS (CAADR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))) (CAR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)))) (CDADR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))) (CDDR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))))) (LIST* (APP (TOWER (+ -1 N)) (CONS N S1)) S3 S5 S6))). But simplification reduces this to T, using primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, DEFAULT-<-2 and DEFAULT- CAR. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 7), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 8). ###->: (ACL2::REPEAT-REC PROVE) ####->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> The destructor terms (CAR S) and (CDR S) can be eliminated. Furthermore, those terms are at the root of a chain of three rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace S by (CONS S1 S2), (CAR S) by S1 and (CDR S) by S2. (2) Use CAR-CDR-ELIM, again, to replace S2 by (CONS S3 S4), (CAR S2) by S3 and (CDR S2) by S4. (3) Finally, use CAR-CDR-ELIM to replace S4 by (CONS S5 S6), (CAR S4) by S5 and (CDR S4) by S6. These steps produce the following goal. Goal' (IMPLIES (AND (CONSP (CONS S5 S6)) (CONSP (LIST* S3 S5 S6)) (CONSP (LIST* S1 S3 S5 S6)) (NOT (ZP N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)) (LIST* S1 (CONS N S3) (APP (TOWER (+ -1 N)) S5) S6)) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (CONS N S1) S3 (APP (TOWER (+ -1 N)) S5) S6)) (LIST* (APP (TOWER (+ -1 N)) (CONS N S1)) S3 S5 S6)) (<= 0 N) (TRUE-LISTP S6) (EQUAL (+ 1 1 1 (LEN S6)) 3) (NOT (CONSP S3)) (NOT (CONSP S5)) (NOT (CONSP S1)) (CONSP (CAR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))))) (< (CAR (GET 1 (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6)))) (CAAR (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N S3)) S5 S6))))). But simplification reduces this to T, using primitive type reasoning and the :rewrite rule CAR-CONS. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 8), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 9). ####->: (ACL2::REPEAT-REC PROVE) #####->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> But simplification reduces this to T, using the :compound-recognizer rule ACL2::NATP-COMPOUND-RECOGNIZER, the :executable-counterpart of EQUAL, primitive type reasoning and the :rewrite rule GET-PUT. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 9), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 10). #####->: (ACL2::REPEAT-REC PROVE) ######->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> [SGC for 20041 CONS pages..(29929 writable)..(T=10).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ACL2::NATP-COMPOUND-RECOGNIZER, the :executable-counterpart of EQUAL, primitive type reasoning and the :rewrite rules CAR-CONS and GET-PUT. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 10), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 11). ######->: (ACL2::REPEAT-REC PROVE) #######->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> But simplification reduces this to T, using the :compound-recognizer rule ACL2::NATP-COMPOUND-RECOGNIZER, the :executable-counterpart of EQUAL, primitive type reasoning and the :rewrite rule GET-PUT. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 11), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 12). #######->: (ACL2::REPEAT-REC PROVE) ########->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> But simplification reduces this to T, using the :compound-recognizer rule ACL2::NATP-COMPOUND-RECOGNIZER, the :executable-counterpart of EQUAL, primitive type reasoning and the :rewrite rules CAR-CONS and GET-PUT. Q.E.D. The proof of the current goal, (((ACL2::MAIN . 1) . 24) . 12), has been completed, as have all of its subgoals. Now proving (((ACL2::MAIN . 1) . 24) . 13). ########->: (ACL2::REPEAT-REC PROVE) #########->: PROVE ***** Now entering the theorem prover ***** << Starting proof tree logging >> The destructor terms (CAR S) and (CDR S) can be eliminated. Furthermore, those terms are at the root of a chain of four rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace S by (CONS S1 S2), (CAR S) by S1 and (CDR S) by S2. (2) Use CAR-CDR-ELIM, again, to replace S1 by (CONS S3 S4), (CAR S1) by S3 and (CDR S1) by S4. (3) Use CAR-CDR- ELIM to replace S2 by (CONS S5 S6), (CAR S2) by S5 and (CDR S2) by S6. (4) Finally, use CAR-CDR-ELIM to replace S6 by (CONS S7 S8), (CAR S6) by S7 and (CDR S6) by S8. These steps produce the following two goals. Subgoal 2 (IMPLIES (AND (NOT (CONSP S1)) (CONSP (CONS S1 S2)) (NOT (ZP N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N (CAR S2))) (CDR S2))) (LIST* S1 (CONS N (CAR S2)) (APP (TOWER (+ -1 N)) (CADR S2)) (CDDR S2))) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (CONS N S1) (CAR S2) (APP (TOWER (+ -1 N)) (CADR S2)) (CDDR S2))) (CONS (APP (TOWER (+ -1 N)) (CONS N S1)) S2)) (<= 0 N) (CONSP S2) (CONSP (CDR S2)) (TRUE-LISTP (CDDR S2)) (EQUAL (+ 1 1 1 (LEN (CDDR S2))) 3) (NOT (CONSP (CAR S2))) (NOT (CONSP (CADR S2))) (< N (CAR S1))) (CONSP (GET 1 (PLAY (H 1 0 2 (+ -1 N)) (LIST* S1 (APP (TOWER (+ -1 N)) (CONS N (CAR S2))) (CDR S2)))))). But we reduce the conjecture to T, by the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal 1 (IMPLIES (AND (CONSP (CONS S7 S8)) (CONSP (LIST* S5 S7 S8)) (CONSP (CONS S3 S4)) (CONSP (LIST* (CONS S3 S4) S5 S7 S8)) (NOT (ZP N)) (EQUAL (PLAY (H 1 0 2 (+ -1 N)) (LIST* (CONS S3 S4) (APP (TOWER (+ -1 N)) (CONS N S5)) S7 S8)) (LIST* (CONS S3 S4) (CONS N S5) (APP (TOWER (+ -1 N)) S7) S8)) (EQUAL (PLAY (H 2 1 0 (+ -1 N)) (LIST* (LIST* N S3 S4) S5 (APP (TOWER (+ -1 N)) S7) S8)) (LIST* (APP (TOWER (+ -1 N)) (LIST* N S3 S4)) S5 S7 S8)) (<= 0 N) (TRUE-LISTP S8) (EQUAL (+ 1 1 1 (LEN S8)) 3) (NOT (CONSP S5)) (NOT (CONSP S7)) (< N S3)) (CONSP (GET 1 (PLAY (H 1 0 2 (+ -1 N)) (LIST* (CONS S3 S4) (APP (TOWER (+ -1 N)) (CONS N S5)) S7 S8))))). Error: Console interrupt. Fast links are on: do (si::use-fast-links nil) for debugging Error signalled by VERIFY-FN. Broken at COND. Type :H for Help. ACL2[RAW LISP]>>:q Here is the current pstack [see :DOC pstack]: (ACL2::WATERFALL) HANOI !>(verify) ->: (quiet (repeat prove)) Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. [SGC for 20041 CONS pages..(29929 writable)..(T=10).GC finished] Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. Q.E.D. [SGC for 0 RELOCATABLE-BLOCKS pages..(29929 writable)..(T=9).GC finished] Q.E.D. Q.E.D. ->: goals *** NO CHANGE *** -- There are no unproved goals! You may wish to exit. ->: (exit h-lemma nil) (DEFTHM H-LEMMA (PROOF-TERM) :RULE-CLASSES NIL :INSTRUCTIONS ((:INDUCT (INDUCTION-HINT A B C N S)) (:CHANGE-GOAL NIL T) :PROVE :SPLIT :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :BASH (:CONTRAPOSE 2) (:IN-THEORY (ENABLE GET-PUT)) :PROVE :BASH :BASH :BASH :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE :PROVE)) ACL2 Query (ACL2-PC::EXIT): Do you want to submit this event? Possible replies are: Y (Yes), R (yes and Replay commands), N (No, but exit), A (Abort exiting). (Y, R, N or A): n NIL HANOI !>(in-theory (enable get-put)) Summary Form: ( IN-THEORY (ENABLE ...)) Rules: NIL Warnings: None Time: 0.01 seconds (prove: 0.00, print: 0.00, proof tree: 0.00, other: 0.01) 1846 HANOI !>(acl2::set-saved-output t t) HANOI !>(do-proof) Q.E.D. H-LEMMA HANOI !>:pso! Output replay for: ( DEFTHM H-LEMMA ...) << Starting proof tree logging >> [Note: A hint was supplied for our processing of the goal above. Thanks!] Name the formula above *1. We have been told to use induction. One induction scheme is suggested by the induction hint. We will induct according to a scheme suggested by (INDUCTION-HINT A B C N S). This suggestion was produced using the :induction rule INDUCTION-HINT. If we let (:P A B C N S) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (ZP N)) (:P A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S)) (:P B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (:P A B C N S)) (IMPLIES (ZP N) (:P A B C N S))). This induction is justified by the same argument used to admit INDUCTION- HINT, namely, the measure (ACL2-COUNT N) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). Note, however, that the unmeasured variables C, A, B and S are being instantiated. When applied to the goal at hand the above induction scheme produces the following two nontautological subgoals. Subgoal *1/2 (IMPLIES (AND (NOT (ZP N)) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET A S)) A S)) (EQUAL (LEN (PUT (PUSH N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (PUSH N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (PUSH N (GET A S)) A S))) A (PUT (PUSH N (GET A S)) A S))) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET A S)) A S))) B (PUT (PUSH N (GET A S)) A S)))) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (PUSH N (GET C S)) C S)) (EQUAL (LEN (PUT (PUSH N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (PUSH N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (PUSH N (GET C S)) C S))) B (PUT (PUSH N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (PUSH N (GET C S)) C S))) C (PUT (PUSH N (GET C S)) C S))))) (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)))). By the simple :definitions NATP and PUSH and the simple :rewrite rules PERM-OPENER and PUT-PUT-2 we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (NOT (ZP N)) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET A S)) A S)) (EQUAL (LEN (PUT (CONS N (GET A S)) A S)) 3) (PERM (LIST A C B) '(0 1 2)) (BIG-TOPS A C B (+ -1 N) (PUT (CONS N (GET A S)) A S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET A (PUT (CONS N (GET A S)) A S))) A S)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET A S)) A S))) B (PUT (CONS N (GET A S)) A S)))) (IMPLIES (AND (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rules ACL2::NATP-COMPOUND- RECOGNIZER and ACL2::ZP-COMPOUND-RECOGNIZER, the :definitions A, APP, B, BIG-TOPS, DO-MOVE, GET, H, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH, TOP and TOWER, the :executable-counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules APP-ASSOC, CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PERM-OPENER, PLAY-APP, PUT-PUT- 1 and TRUE-LISTP-PUT, to the following 109 conjectures. (By the way, the case limit affected this analysis. See :DOC case-split-limitations.) Subgoal *1/2.109 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/2.109' (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (INTEGERP (+ -1 N)) (<= 0 (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions BIG-TOPS, H and TOWER, the :executable- counterpart of EQUAL, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, GET-PUT, LEN-PUT and TRUE-LISTP-PUT, to the following 16 conjectures. Subgoal *1/2.109.16 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.15 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.15' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.14 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.13 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.13' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.12 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.11 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.11' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.11.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.11.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.11.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.11.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.10 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.9 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.9' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.9.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.9.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.9.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. [SGC for 20041 CONS pages..(62457 writable)..(T=11).GC finished] Subgoal *1/2.109.9.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.8 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.7 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.7' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.7.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.7.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.7.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.7.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.6 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.5 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.5' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.5.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.5.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.5.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.5.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.3' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.3.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.3.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.3.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.3.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.109.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.109.1' (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.109.1.4 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.1.3 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.1.2 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.109.1.1 (IMPLIES (AND (NOT (CONSP (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.108 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (PERM (LIST B A C) '(0 1 2))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of NOT, primitive type reasoning and the :rewrite rule PERM-OPENER. Subgoal *1/2.107 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3)) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of EQUAL, linear arithmetic and the :rewrite rule LEN-PUT. Subgoal *1/2.106 (IMPLIES (AND (NOT (ZP N)) (NOT (CONSP (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (TRUE-LISTP (PUT (CONS N (GET C S)) C S))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using linear arithmetic and the :rewrite rule TRUE-LISTP-PUT. Subgoal *1/2.105 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/2.105' (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (INTEGERP (+ -1 N)) (<= 0 (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER, the :definition BIG-TOPS, the :executable- counterpart of EQUAL, linear arithmetic, primitive type reasoning and the :rewrite rules GET-PUT, LEN-PUT and TRUE-LISTP-PUT. Subgoal *1/2.104 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NOT (PERM (LIST B A C) '(0 1 2))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of NOT, primitive type reasoning and the :rewrite rule PERM-OPENER. Subgoal *1/2.103 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NOT (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3)) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of EQUAL, linear arithmetic and the :rewrite rule LEN-PUT. Subgoal *1/2.102 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (NOT (TRUE-LISTP (PUT (CONS N (GET C S)) C S))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using linear arithmetic and the :rewrite rule TRUE-LISTP-PUT. Subgoal *1/2.101 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NATP (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (PERM (LIST B A C) '(0 1 2)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/2.101' (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (INTEGERP (+ -1 N)) (<= 0 (+ -1 N)) (TRUE-LISTP (PUT (CONS N (GET C S)) C S)) (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (IMPLIES (BIG-TOPS B A C (+ -1 N) (PUT (CONS N (GET C S)) C S)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions BIG-TOPS, H and TOWER, the :executable- counterpart of EQUAL, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, GET-PUT, LEN-PUT and TRUE-LISTP-PUT, to the following 16 conjectures. Subgoal *1/2.101.16 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.15 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.15' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.14 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.13 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.13' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.12 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.11 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.11' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.11.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.11.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.11.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.11.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.10 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.9 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.9' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.9.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.9.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.9.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.9.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.8 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.7 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.7' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.7.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.7.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.7.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.7.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.6 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.5 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.5' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.5.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (< (+ -1 N) N) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.5.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.5.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.5.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (< (+ -1 N) N) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.3' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.3.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.3.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.3.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.3.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (NOT (CONSP (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (ZP N)) (EQUAL (PLAY NIL (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and primitive type reasoning. Subgoal *1/2.101.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (APP (H A C B (+ -1 N)) (CONS (LIST 'MOVE A C) (H B A C (+ -1 N)))) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET A S)) A S)) (PUT (APP (APP (TOWER (+ -1 N)) (LIST N)) (GET C S)) C S))). By the simple :rewrite rules APP-ASSOC and PLAY-APP we reduce the conjecture to Subgoal *1/2.101.1' (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N))) (EQUAL (PLAY (CONS (LIST 'MOVE A C) (H B A C (+ -1 N))) (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET A S))) A S))) (PUT (APP (TOWER (+ -1 N)) (APP (LIST N) (GET C S))) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :definitions A, APP, B, DO-MOVE, GET, LEGAL-MOVEP, LEGAL-SYNTAXP, LEN, MEM, PLAY, POP, PUSH and TOP, the :executable- counterparts of <, BINARY-+, CAR, CDR, CONSP, EQUAL, INTEGERP, LEN, NOT and ZP, linear arithmetic, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, GET-PUT, LEN-PUT, PUT-GET, PUT-PUT-1 and PUT-PUT-2, to the following four conjectures. Subgoal *1/2.101.1.4 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B A)) (NOT (EQUAL B C)) (NOT (EQUAL A C)) (NOT (CONSP (GET A S))) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.1.3 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 0 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)) (PUT (CONS N (GET 0 S)) 0 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 0)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (EQUAL (PLAY (H B 0 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.1.2 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 2 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)) (PUT (CONS N (GET 2 S)) 2 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 2)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (EQUAL (PLAY (H B 2 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.101.1.1 (IMPLIES (AND (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H 1 C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)) (PUT (CONS N (GET 1 S)) 1 (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (<= 0 (+ -1 N)) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL B 1)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (EQUAL (PLAY (H B 1 C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (ZP N)) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.100 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (PERM (LIST B A C) '(0 1 2))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of NOT, primitive type reasoning and the :rewrite rule PERM-OPENER. Subgoal *1/2.99 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (EQUAL (LEN (PUT (CONS N (GET C S)) C S)) 3)) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :executable-counterpart of EQUAL, linear arithmetic and the :rewrite rule LEN-PUT. Subgoal *1/2.98 (IMPLIES (AND (NOT (ZP N)) (< (+ -1 N) (CAR (GET B S))) (EQUAL (PLAY (H A C B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)) (PUT (CONS N (GET A S)) A (PUT (APP (TOWER (+ -1 N)) (GET B S)) B S))) (NOT (TRUE-LISTP (PUT (CONS N (GET C S)) C S))) (IMPLIES NIL (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B (PUT (CONS N (GET C S)) C S))) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (GET C (PUT (CONS N (GET C S)) C S))) C S))) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using linear arithmetic and the :rewrite rule TRUE-LISTP-PUT. Subgoal *1/2.97 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (EQUAL (PLAY (H B A C (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (GET B S)) B (PUT (CONS N (GET C S)) C S))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S)) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). But simplification reduces this to T, using the :compound-recognizer rule ACL2::ZP-COMPOUND-RECOGNIZER and the :definition BIG-TOPS. Subgoal *1/2.96 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.95 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.94 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.93 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.92 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.91 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.90 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.89 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.88 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.87 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.86 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.85 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.84 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.83 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.82 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.81 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (< N (CAR (GET A S))) (NOT (CONSP (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.80 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.79 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.78 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.77 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.76 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.75 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.74 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.73 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (NOT (CONSP (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.72 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.71 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.70 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.69 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.68 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.67 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.66 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.65 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.64 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.63 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.62 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.61 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.60 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.59 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.58 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.57 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET A S)) (<= (CAR (GET A S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.56 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.55 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.54 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.53 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.52 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.51 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.50 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.49 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.48 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.47 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.46 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.45 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.44 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.43 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.42 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.41 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.40 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.39 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.38 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. [SGC for 2819 STRING pages..(63679 writable)..(T=9).GC finished] Subgoal *1/2.37 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.36 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.35 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.34 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.33 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (NOT (CONSP (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.32 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.31 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.30 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.29 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.28 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.27 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.26 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.25 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (NOT (CONSP (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.24 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (NOT (CONSP (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.23 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.22 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 0) (EQUAL C 2) (CONSP (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 2 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 2 (PLAY (H 0 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.21 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.20 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 2)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL A 1) (EQUAL C 2) (CONSP (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 2 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 2 (PLAY (H 1 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.19 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 2 S)) (<= (CAR (GET 2 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 2)) (NOT (EQUAL B 2)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 2 S))) (EQUAL C 2) (CONSP (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 2 (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 2 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.18 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B C)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 1) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.17 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B C)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 0) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.16 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B C)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (EQUAL A 2) (NOT (EQUAL C 0)) (NOT (EQUAL C 1)) (NOT (EQUAL C 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.15 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (NOT (CONSP (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.14 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (NOT (CONSP (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.13 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 0 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 0 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 0) (EQUAL C 1) (CONSP (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (< (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (CAR (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))))) (EQUAL (PLAY (H B 0 1 (+ -1 N)) (PUT (CDR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 0 (PUT (CONS (CAR (GET 0 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) (GET 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S)))) 1 (PLAY (H 0 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.12 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.11 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 1)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL A 2) (EQUAL C 1) (CONSP (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 1 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 1 (PLAY (H 2 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.10 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 1 S)) (<= (CAR (GET 1 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL A B)) (NOT (EQUAL A 1)) (NOT (EQUAL B 1)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET 1 S))) (EQUAL C 1) (CONSP (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (<= (CAR (GET 1 (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))) (CAR (GET A (PLAY (H A 1 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET A S))) A S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.9 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET C S)) (<= (CAR (GET C S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (< N (CAR (GET A S))) (< N (CAR (GET B S))) (< N (CAR (GET C S))) (NOT (EQUAL A 0)) (NOT (EQUAL A 1)) (NOT (EQUAL A 2))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET C S))) C S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.8 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (NOT (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.7 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (NOT (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.6 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (< (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL (PLAY (H B 1 0 (+ -1 N)) (PUT (CDR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 1 (PUT (CONS (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.5 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 1 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 1 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 1) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (<= (CAR (GET 0 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))) (CAR (GET 1 (PLAY (H 1 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 1 S))) 1 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.4 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (NOT (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.3 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (NOT (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.2 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (< (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL (PLAY (H B 2 0 (+ -1 N)) (PUT (CDR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 2 (PUT (CONS (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S))))) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/2.1 (IMPLIES (AND (NOT (ZP N)) (CONSP (GET 0 S)) (<= (CAR (GET 0 S)) (+ -1 N)) (CONSP (GET B S)) (<= (CAR (GET B S)) (+ -1 N)) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP B) (<= 0 B) (<= B 2) (NOT (EQUAL 2 B)) (NOT (EQUAL B 0)) (< N (CAR (GET 2 S))) (< N (CAR (GET B S))) (< N (CAR (GET 0 S))) (EQUAL A 2) (EQUAL C 0) (CONSP (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (<= (CAR (GET 0 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))) (CAR (GET 2 (PLAY (H 2 0 B (+ -1 N)) (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 2 S))) 2 S)))))) (EQUAL NIL (PUT (APP (TOWER (+ -1 N)) (CONS N (GET 0 S))) 0 S))). But simplification reduces this to T, using linear arithmetic. Subgoal *1/1 (IMPLIES (ZP N) (IMPLIES (AND (NATP N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (PERM (LIST A B C) '(0 1 2)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S)))). By the simple :definition NATP and the simple :rewrite rule PERM-OPENER we reduce the conjecture to Subgoal *1/1' (IMPLIES (AND (ZP N) (INTEGERP N) (<= 0 N) (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C N S)) (EQUAL (PLAY (H A B C N) (PUT (APP (TOWER N) (GET A S)) A S)) (PUT (APP (TOWER N) (GET C S)) C S))). This simplifies, using the :compound-recognizer rule ACL2::ZP-COMPOUND- RECOGNIZER, the :executable-counterparts of <, INTEGERP, NOT, TOWER and ZP and linear arithmetic, to Subgoal *1/1'' (IMPLIES (AND (TRUE-LISTP S) (EQUAL (LEN S) 3) (INTEGERP A) (<= 0 A) (<= A 2) (INTEGERP B) (<= 0 B) (<= B 2) (INTEGERP C) (<= 0 C) (<= C 2) (NOT (EQUAL A B)) (NOT (EQUAL A C)) (NOT (EQUAL B C)) (BIG-TOPS A B C 0 S)) (EQUAL (PLAY (H A B C 0) (PUT (APP NIL (GET A S)) A S)) (PUT (APP NIL (GET C S)) C S))). But simplification reduces this to T, using the :definitions APP, BIG- TOPS, H and PLAY, the :executable-counterparts of CONSP and ZP, linear arithmetic, primitive type reasoning and the :rewrite rule PUT-GET. That completes the proof of *1. Q.E.D. Summary Form: ( DEFTHM H-LEMMA ...) Rules: ((:COMPOUND-RECOGNIZER ACL2::NATP-COMPOUND-RECOGNIZER) (:COMPOUND-RECOGNIZER ACL2::ZP-COMPOUND-RECOGNIZER) (:DEFINITION A) (:DEFINITION APP) (:DEFINITION B) (:DEFINITION BIG-TOPS) (:DEFINITION DO-MOVE) (:DEFINITION GET) (:DEFINITION H) (:DEFINITION LEGAL-MOVEP) (:DEFINITION LEGAL-SYNTAXP) (:DEFINITION LEN) (:DEFINITION MEM) (:DEFINITION NATP) (:DEFINITION NOT) (:DEFINITION PLAY) (:DEFINITION POP) (:DEFINITION PUSH) (:DEFINITION TOP) (:DEFINITION TOWER) (:EXECUTABLE-COUNTERPART <) (:EXECUTABLE-COUNTERPART BINARY-+) (:EXECUTABLE-COUNTERPART CAR) (:EXECUTABLE-COUNTERPART CDR) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART EQUAL) (:EXECUTABLE-COUNTERPART INTEGERP) (:EXECUTABLE-COUNTERPART LEN) (:EXECUTABLE-COUNTERPART NOT) (:EXECUTABLE-COUNTERPART TOWER) (:EXECUTABLE-COUNTERPART ZP) (:FAKE-RUNE-FOR-LINEAR NIL) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:INDUCTION INDUCTION-HINT) (:REWRITE APP-ASSOC) (:REWRITE CAR-CONS) (:REWRITE CDR-CONS) (:REWRITE GET-PUT) (:REWRITE LEN-PUT) (:REWRITE PERM-OPENER) (:REWRITE PLAY-APP) (:REWRITE PUT-GET) (:REWRITE PUT-PUT-1) (:REWRITE PUT-PUT-2) (:REWRITE TRUE-LISTP-PUT)) Warnings: None Time: 1.82 seconds (prove: 0.46, print: 0.85, proof tree: 0.51, other: 0.00) HANOI !>(acl2::set-saved-output nil :normal) HANOI !>:set-print-clause-ids t HANOI !>:u 38:x(IN-THEORY (ENABLE GET-PUT)) HANOI !>(set-inhibit-output-lst '(prove)) ACL2 Warning in SET-INHIBIT-OUTPUT-LST: The printing of proof-trees is enabled, but the printing of proofs is not. You may want to execute :STOP-PROOF-TREE in order to inhibit proof-trees as well. (PROVE) HANOI !>(do-proof) ACL2 Warning in ( DEFTHM H-LEMMA ...): The printing of proof-trees is enabled, but the printing of proofs is not. You may want to execute :STOP-PROOF-TREE in order to inhibit proof-trees as well. Subgoal *1/2 Subgoal *1/2' Subgoal *1/2.109 Subgoal *1/2.109' Subgoal *1/2.109.16 Subgoal *1/2.109.15 Subgoal *1/2.109.15' Subgoal *1/2.109.14 Subgoal *1/2.109.13 Subgoal *1/2.109.13' Subgoal *1/2.109.12 Subgoal *1/2.109.11 Subgoal *1/2.109.11' Subgoal *1/2.109.11.4 Subgoal *1/2.109.11.3 Subgoal *1/2.109.11.2 Subgoal *1/2.109.11.1 Subgoal *1/2.109.10 Subgoal *1/2.109.9 Subgoal *1/2.109.9' Subgoal *1/2.109.9.4 Subgoal *1/2.109.9.3 Subgoal *1/2.109.9.2 Subgoal *1/2.109.9.1 Subgoal *1/2.109.8 Subgoal *1/2.109.7 Subgoal *1/2.109.7' Subgoal *1/2.109.7.4 Subgoal *1/2.109.7.3 Subgoal *1/2.109.7.2 Subgoal *1/2.109.7.1 Subgoal *1/2.109.6 Subgoal *1/2.109.5 Subgoal *1/2.109.5' Subgoal *1/2.109.5.4 Subgoal *1/2.109.5.3 Subgoal *1/2.109.5.2 Subgoal *1/2.109.5.1 Subgoal *1/2.109.4 Subgoal *1/2.109.3 Subgoal *1/2.109.3' Subgoal *1/2.109.3.4 Subgoal *1/2.109.3.3 Subgoal *1/2.109.3.2 Subgoal *1/2.109.3.1 Subgoal *1/2.109.2 Subgoal *1/2.109.1 Subgoal *1/2.109.1' Subgoal *1/2.109.1.4 Subgoal *1/2.109.1.3 Subgoal *1/2.109.1.2 Subgoal *1/2.109.1.1 Subgoal *1/2.108 Subgoal *1/2.107 Subgoal *1/2.106 Subgoal *1/2.105 Subgoal *1/2.105' Subgoal *1/2.104 Subgoal *1/2.103 Subgoal *1/2.102 Subgoal *1/2.101 Subgoal *1/2.101' Subgoal *1/2.101.16 Subgoal *1/2.101.15 Subgoal *1/2.101.15' Subgoal *1/2.101.14 Subgoal *1/2.101.13 Subgoal *1/2.101.13' Subgoal *1/2.101.12 Subgoal *1/2.101.11 Subgoal *1/2.101.11' Subgoal *1/2.101.11.4 Subgoal *1/2.101.11.3 Subgoal *1/2.101.11.2 Subgoal *1/2.101.11.1 Subgoal *1/2.101.10 Subgoal *1/2.101.9 Subgoal *1/2.101.9' Subgoal *1/2.101.9.4 Subgoal *1/2.101.9.3 Subgoal *1/2.101.9.2 Subgoal *1/2.101.9.1 Subgoal *1/2.101.8 Subgoal *1/2.101.7 Subgoal *1/2.101.7' Subgoal *1/2.101.7.4 Subgoal *1/2.101.7.3 Subgoal *1/2.101.7.2 Subgoal *1/2.101.7.1 Subgoal *1/2.101.6 Subgoal *1/2.101.5 Subgoal *1/2.101.5' Subgoal *1/2.101.5.4 Subgoal *1/2.101.5.3 Subgoal *1/2.101.5.2 Subgoal *1/2.101.5.1 Subgoal *1/2.101.4 Subgoal *1/2.101.3 Subgoal *1/2.101.3' Subgoal *1/2.101.3.4 Subgoal *1/2.101.3.3 Subgoal *1/2.101.3.2 Subgoal *1/2.101.3.1 Subgoal *1/2.101.2 Subgoal *1/2.101.1 Subgoal *1/2.101.1' Subgoal *1/2.101.1.4 Subgoal *1/2.101.1.3 Subgoal *1/2.101.1.2 Subgoal *1/2.101.1.1 Subgoal *1/2.100 Subgoal *1/2.99 Subgoal *1/2.98 Subgoal *1/2.97 Subgoal *1/2.96 Subgoal *1/2.95 Subgoal *1/2.94 Subgoal *1/2.93 Subgoal *1/2.92 Subgoal *1/2.91 Subgoal *1/2.90 Subgoal *1/2.89 Subgoal *1/2.88 Subgoal *1/2.87 Subgoal *1/2.86 Subgoal *1/2.85 Subgoal *1/2.84 Subgoal *1/2.83 Subgoal *1/2.82 Subgoal *1/2.81 Subgoal *1/2.80 Subgoal *1/2.79 Subgoal *1/2.78 Subgoal *1/2.77 Subgoal *1/2.76 Subgoal *1/2.75 Subgoal *1/2.74 Subgoal *1/2.73 Subgoal *1/2.72 Subgoal *1/2.71 Subgoal *1/2.70 Subgoal *1/2.69 Subgoal *1/2.68 Subgoal *1/2.67 Subgoal *1/2.66 Subgoal *1/2.65 Subgoal *1/2.64 Subgoal *1/2.63 Subgoal *1/2.62 Subgoal *1/2.61 Subgoal *1/2.60 Subgoal *1/2.59 Subgoal *1/2.58 Subgoal *1/2.57 Subgoal *1/2.56 Subgoal *1/2.55 Subgoal *1/2.54 Subgoal *1/2.53 Subgoal *1/2.52 Subgoal *1/2.51 Subgoal *1/2.50 Subgoal *1/2.49 Subgoal *1/2.48 Subgoal *1/2.47 Subgoal *1/2.46 Subgoal *1/2.45 Subgoal *1/2.44 Subgoal *1/2.43 Subgoal *1/2.42 Subgoal *1/2.41 Subgoal *1/2.40 Subgoal *1/2.39 Subgoal *1/2.38 Subgoal *1/2.37 Subgoal *1/2.36 Subgoal *1/2.35 Subgoal *1/2.34 Subgoal *1/2.33 Subgoal *1/2.32 Subgoal *1/2.31 Subgoal *1/2.30 Subgoal *1/2.29 Subgoal *1/2.28 Subgoal *1/2.27 Subgoal *1/2.26 Subgoal *1/2.25 Subgoal *1/2.24 Subgoal *1/2.23 Subgoal *1/2.22 Subgoal *1/2.21 Subgoal *1/2.20 Subgoal *1/2.19 Subgoal *1/2.18 Subgoal *1/2.17 Subgoal *1/2.16 Subgoal *1/2.15 Subgoal *1/2.14 Subgoal *1/2.13 Subgoal *1/2.12 Subgoal *1/2.11 Subgoal *1/2.10 Subgoal *1/2.9 Subgoal *1/2.8 Subgoal *1/2.7 Subgoal *1/2.6 Subgoal *1/2.5 Subgoal *1/2.4 Subgoal *1/2.3 Subgoal *1/2.2 Subgoal *1/2.1 Subgoal *1/1 Subgoal *1/1' Subgoal *1/1'' Summary Form: ( DEFTHM H-LEMMA ...) Rules: ((:COMPOUND-RECOGNIZER ACL2::NATP-COMPOUND-RECOGNIZER) (:COMPOUND-RECOGNIZER ACL2::ZP-COMPOUND-RECOGNIZER) (:DEFINITION A) (:DEFINITION APP) (:DEFINITION B) (:DEFINITION BIG-TOPS) (:DEFINITION DO-MOVE) (:DEFINITION GET) (:DEFINITION H) (:DEFINITION LEGAL-MOVEP) (:DEFINITION LEGAL-SYNTAXP) (:DEFINITION LEN) (:DEFINITION MEM) (:DEFINITION NATP) (:DEFINITION NOT) (:DEFINITION PLAY) (:DEFINITION POP) (:DEFINITION PUSH) (:DEFINITION TOP) (:DEFINITION TOWER) (:EXECUTABLE-COUNTERPART <) (:EXECUTABLE-COUNTERPART BINARY-+) (:EXECUTABLE-COUNTERPART CAR) (:EXECUTABLE-COUNTERPART CDR) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART EQUAL) (:EXECUTABLE-COUNTERPART INTEGERP) (:EXECUTABLE-COUNTERPART LEN) (:EXECUTABLE-COUNTERPART NOT) (:EXECUTABLE-COUNTERPART TOWER) (:EXECUTABLE-COUNTERPART ZP) (:FAKE-RUNE-FOR-LINEAR NIL) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:INDUCTION INDUCTION-HINT) (:REWRITE APP-ASSOC) (:REWRITE CAR-CONS) (:REWRITE CDR-CONS) (:REWRITE GET-PUT) (:REWRITE LEN-PUT) (:REWRITE PERM-OPENER) (:REWRITE PLAY-APP) (:REWRITE PUT-GET) (:REWRITE PUT-PUT-1) (:REWRITE PUT-PUT-2) (:REWRITE TRUE-LISTP-PUT)) Warnings: None Time: 2.81 seconds (prove: 2.72, print: 0.00, proof tree: 0.08, other: 0.01) H-LEMMA HANOI !>:u 38:x(IN-THEORY (ENABLE GET-PUT)) HANOI !>(acl2::set-saved-output t t) HANOI !>(do-proof) Subgoal *1/2 Subgoal *1/2' Subgoal *1/2.109 Subgoal *1/2.109' Subgoal *1/2.109.16 Subgoal *1/2.109.15 Subgoal *1/2.109.15' Subgoal *1/2.109.14 Subgoal *1/2.109.13 Subgoal *1/2.109.13' Subgoal *1/2.109.12 Subgoal *1/2.109.11 Subgoal *1/2.109.11' Subgoal *1/2.109.11.4 Subgoal *1/2.109.11.3 Subgoal *1/2.109.11.2 Subgoal *1/2.109.11.1 Subgoal *1/2.109.10 Subgoal *1/2.109.9 Subgoal *1/2.109.9' Subgoal *1/2.109.9.4 [SGC for 20041 CONS pages..(63691 writable)..(T=11).GC finished] Subgoal *1/2.109.9.3 Subgoal *1/2.109.9.2 Subgoal *1/2.109.9.1 Subgoal *1/2.109.8 Subgoal *1/2.109.7 Subgoal *1/2.109.7' Subgoal *1/2.109.7.4 Subgoal *1/2.109.7.3 Subgoal *1/2.109.7.2 Subgoal *1/2.109.7.1 Subgoal *1/2.109.6 Subgoal *1/2.109.5 Subgoal *1/2.109.5' Subgoal *1/2.109.5.4 Subgoal *1/2.109.5.3 Subgoal *1/2.109.5.2 Subgoal *1/2.109.5.1 Subgoal *1/2.109.4 Subgoal *1/2.109.3 Subgoal *1/2.109.3' Subgoal *1/2.109.3.4 Subgoal *1/2.109.3.3 Subgoal *1/2.109.3.2 Subgoal *1/2.109.3.1 Subgoal *1/2.109.2 Subgoal *1/2.109.1 Subgoal *1/2.109.1' Subgoal *1/2.109.1.4 Subgoal *1/2.109.1.3 Subgoal *1/2.109.1.2 Subgoal *1/2.109.1.1 Subgoal *1/2.108 Subgoal *1/2.107 Subgoal *1/2.106 Subgoal *1/2.105 Subgoal *1/2.105' Subgoal *1/2.104 Subgoal *1/2.103 Subgoal *1/2.102 Subgoal *1/2.101 Subgoal *1/2.101' Subgoal *1/2.101.16 Subgoal *1/2.101.15 Subgoal *1/2.101.15' Subgoal *1/2.101.14 Subgoal *1/2.101.13 Subgoal *1/2.101.13' Subgoal *1/2.101.12 Subgoal *1/2.101.11 Subgoal *1/2.101.11' Subgoal *1/2.101.11.4 Subgoal *1/2.101.11.3 Subgoal *1/2.101.11.2 Subgoal *1/2.101.11.1 Subgoal *1/2.101.10 Subgoal *1/2.101.9 Subgoal *1/2.101.9' Subgoal *1/2.101.9.4 Subgoal *1/2.101.9.3 Subgoal *1/2.101.9.2 Subgoal *1/2.101.9.1 Subgoal *1/2.101.8 Subgoal *1/2.101.7 Subgoal *1/2.101.7' Subgoal *1/2.101.7.4 Subgoal *1/2.101.7.3 Subgoal *1/2.101.7.2 Subgoal *1/2.101.7.1 Subgoal *1/2.101.6 Subgoal *1/2.101.5 Subgoal *1/2.101.5' Subgoal *1/2.101.5.4 Subgoal *1/2.101.5.3 Subgoal *1/2.101.5.2 Subgoal *1/2.101.5.1 Subgoal *1/2.101.4 Subgoal *1/2.101.3 Subgoal *1/2.101.3' Subgoal *1/2.101.3.4 Subgoal *1/2.101.3.3 Subgoal *1/2.101.3.2 Subgoal *1/2.101.3.1 Subgoal *1/2.101.2 Subgoal *1/2.101.1 Subgoal *1/2.101.1' Subgoal *1/2.101.1.4 Subgoal *1/2.101.1.3 Subgoal *1/2.101.1.2 Subgoal *1/2.101.1.1 Subgoal *1/2.100 Subgoal *1/2.99 Subgoal *1/2.98 Subgoal *1/2.97 Subgoal *1/2.96 Subgoal *1/2.95 Subgoal *1/2.94 Subgoal *1/2.93 Subgoal *1/2.92 Subgoal *1/2.91 Subgoal *1/2.90 Subgoal *1/2.89 Subgoal *1/2.88 Subgoal *1/2.87 Subgoal *1/2.86 Subgoal *1/2.85 Subgoal *1/2.84 Subgoal *1/2.83 Subgoal *1/2.82 Subgoal *1/2.81 Subgoal *1/2.80 Subgoal *1/2.79 Subgoal *1/2.78 Subgoal *1/2.77 Subgoal *1/2.76 Subgoal *1/2.75 Subgoal *1/2.74 Subgoal *1/2.73 Subgoal *1/2.72 Subgoal *1/2.71 Subgoal *1/2.70 Subgoal *1/2.69 Subgoal *1/2.68 Subgoal *1/2.67 Subgoal *1/2.66 Subgoal *1/2.65 Subgoal *1/2.64 Subgoal *1/2.63 Subgoal *1/2.62 Subgoal *1/2.61 Subgoal *1/2.60 Subgoal *1/2.59 Subgoal *1/2.58 Subgoal *1/2.57 Subgoal *1/2.56 Subgoal *1/2.55 Subgoal *1/2.54 Subgoal *1/2.53 Subgoal *1/2.52 Subgoal *1/2.51 Subgoal *1/2.50 Subgoal *1/2.49 Subgoal *1/2.48 Subgoal *1/2.47 Subgoal *1/2.46 Subgoal *1/2.45 Subgoal *1/2.44 Subgoal *1/2.43 Subgoal *1/2.42 Subgoal *1/2.41 Subgoal *1/2.40 Subgoal *1/2.39 Subgoal *1/2.38 Subgoal *1/2.37 Subgoal *1/2.36 Subgoal *1/2.35 Subgoal *1/2.34 Subgoal *1/2.33 Subgoal *1/2.32 Subgoal *1/2.31 Subgoal *1/2.30 Subgoal *1/2.29 Subgoal *1/2.28 Subgoal *1/2.27 Subgoal *1/2.26 Subgoal *1/2.25 Subgoal *1/2.24 Subgoal *1/2.23 Subgoal *1/2.22 Subgoal *1/2.21 Subgoal *1/2.20 Subgoal *1/2.19 Subgoal *1/2.18 Subgoal *1/2.17 Subgoal *1/2.16 Subgoal *1/2.15 Subgoal *1/2.14 Subgoal *1/2.13 Subgoal *1/2.12 Subgoal *1/2.11 Subgoal *1/2.10 Subgoal *1/2.9 Subgoal *1/2.8 Subgoal *1/2.7 Subgoal *1/2.6 Subgoal *1/2.5 Subgoal *1/2.4 Subgoal *1/2.3 Subgoal *1/2.2 Subgoal *1/2.1 Subgoal *1/1 Subgoal *1/1' Subgoal *1/1'' Q.E.D. H-LEMMA HANOI !>Bye. Attempting to exit Lisp. If this fails to work, type :q and then try again. sundance:/u/www/users/moore/acl2/seminar/2006.02.15-kaufmann> acl2 GCL (GNU Common Lisp) 2.6.6 CLtL1 Jan 19 2005 20:24:14 Source License: LGPL(gcl,gmp), GPL(unexec,bfd) Binary License: GPL due to GPL'ed components: (BFD UNEXEC) Modifications of this banner must retain notice of a compatible license Dedicated to the memory of W. Schelter Use (help) to get some basic information on how to use GCL. ACL2 Version 2.9.4 built January 30, 2006 23:10:57. Copyright (C) 2006 University of Texas at Austin ACL2 comes with ABSOLUTELY NO WARRANTY. This is free software and you are welcome to redistribute it under certain conditions. For details, see the GNU General Public License. Initialized with (INITIALIZE-ACL2 'INCLUDE-BOOK *ACL2-PASS-2-FILES*). See the documentation topic note-2-9-4 for recent changes. Note: We have modified the prompt in some underlying Lisps to further distinguish it from the ACL2 prompt. NOTE!! Proof trees are disabled in ACL2. To enable them in emacs, look under the ACL2 source directory in interface/emacs/README.doc; and, to turn on proof trees, execute :START-PROOF-TREE in the ACL2 command loop. Look in the ACL2 documentation under PROOF-TREE. ACL2 Version 2.9.4. Level 1. Cbd "/v/filer2/moore/public_html/acl2/seminar/2006.02.15-kaufmann/". Type :help for help. Type (good-bye) to quit completely out of ACL2. ACL2 !>;; Ready to execute ACL2-LOAD -- hit when ready (acl2::ld "/u/www/users/moore/acl2/seminar/2006.02.15-kaufmann/temp-emacs-file.lisp" :LD-PRE-EVAL-PRINT acl2::t :ld-error-action :return) ACL2 Version 2.9.4. Level 2. Cbd "/u/www/users/moore/acl2/seminar/2006.02.15-kaufmann/". Type :help for help. Type (good-bye) to quit completely out of ACL2. ACL2 !>>(DEFTHM TRUE-LISTP-EXPLODE-NONNEGATIVE-INTEGER (IMPLIES (TRUE-LISTP Z) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z)))) Name the formula above *1. Perhaps we can prove *1 by induction. Two induction schemes are suggested by this conjecture. However, one of these is flawed and so we are left with one viable candidate. We will induct according to a scheme suggested by (EXPLODE-NONNEGATIVE-INTEGER X Y Z). This suggestion was produced using the :induction rule EXPLODE-NONNEGATIVE-INTEGER. If we let (:P X Y Z) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (OR (ZP X) (NOT (PRINT-BASE-P Y)))) (:P (FLOOR X Y) Y (CONS (DIGIT-TO-CHAR (MOD X Y)) Z))) (:P X Y Z)) (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P Y))) (NOT (NULL Z))) (:P X Y Z)) (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P Y))) (NULL Z)) (:P X Y Z))). This induction is justified by the same argument used to admit EXPLODE- NONNEGATIVE-INTEGER, namely, the measure (ACL2-COUNT X) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). Note, however, that the unmeasured variable Z is being instantiated. When applied to the goal at hand the above induction scheme produces the following four nontautological subgoals. Subgoal *1/4 (IMPLIES (AND (NOT (OR (ZP X) (NOT (PRINT-BASE-P Y)))) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (FLOOR X Y) Y (CONS (DIGIT-TO-CHAR (MOD X Y)) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z))). By the simple :definitions FLOOR and PRINT-BASE-P we reduce the conjecture to Subgoal *1/4' (IMPLIES (AND (NOT (OR (ZP X) (NOT (MEMBER Y '(2 8 10 16))))) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (LET ((Q (* X (/ Y)))) (LET ((D (DENOMINATOR Q)) (N (NUMERATOR Q))) (COND ((EQUAL D 1) N) ((< N 0) (+ (- (NONNEGATIVE-INTEGER-QUOTIENT (- N) D)) -1)) (T (NONNEGATIVE-INTEGER-QUOTIENT N D))))) Y (CONS (DIGIT-TO-CHAR (MOD X Y)) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z))). This simplifies, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :congruence rule IFF-IMPLIES-EQUAL-NOT, the :definitions FLOOR, MEMBER, MOD and NOT, the :executable-counterparts of CAR, CDR, CONSP and UNARY-/, primitive type reasoning and the :rewrite rule COMMUTATIVITY- OF-*, to the following eight conjectures. Subgoal *1/4.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 2) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS (DIGIT-TO-CHAR (+ X (- (* 2 (NUMERATOR (* 1/2 X)))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.8.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). [SGC for 442 CONS pages..(8299 writable)..(T=1).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). [SGC for 442 CONS pages..(8299 writable)..(T=1).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.8.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 1)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 2)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 3)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 4)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 5)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 6)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 7)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 8)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 9)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 10)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 11)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 12)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 13)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 14)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 2) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS (DIGIT-TO-CHAR (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.7.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.7.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 1)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 2)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 3)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 4)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 5)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 6)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 7)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 8)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 9)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 10)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 11)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 12)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 13)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 14)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 Z))). [SGC for 20 CFUN pages..(8852 writable)..(T=2).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE- INTEGER. Subgoal *1/4.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 10) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS (DIGIT-TO-CHAR (+ X (- (* 10 (NUMERATOR (* 1/10 X)))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.6.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.6.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 1)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 2)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 3)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 4)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 5)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 6)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 7)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 8)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 9)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 10)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 11)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 12)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 13)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 14)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). [SGC for 20 CFUN pages..(8852 writable)..(T=0).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 10) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS (DIGIT-TO-CHAR (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.5.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.5.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 1)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 2)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 3)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 4)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 5)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 6)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 7)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 8)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 9)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 10)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 11)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 12)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 13)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 14)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE- INTEGER. Subgoal *1/4.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 8) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS (DIGIT-TO-CHAR (+ X (- (* 8 (NUMERATOR (* 1/8 X)))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.4.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). [SGC for 21 STRING pages..(9122 writable)..(T=1).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.4.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 1)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 2)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 3)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 4)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 5)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 6)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 7)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 8)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 9)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 10)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 11)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 12)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 13)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 14)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 8) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS (DIGIT-TO-CHAR (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.3.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.3.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 1)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 2)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 3)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 4)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 5)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 6)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 7)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 8)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 9)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 10)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 11)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 12)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 13)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 14)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 Z))). [SGC for 1265 CONS pages..(9143 writable)..(T=2).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE- INTEGER. Subgoal *1/4.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 16) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS (DIGIT-TO-CHAR (+ X (- (* 16 (NUMERATOR (* 1/16 X)))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.2.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.2.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 1)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 2)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 3)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 4)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 5)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 6)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 7)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 8)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 9)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 10)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 11)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 12)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 13)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 14)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL Y 16) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS (DIGIT-TO-CHAR (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))))))) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.1.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 1) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\1 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 2) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\2 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 3) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\3 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 4) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\4 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 5) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\5 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 6) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\6 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). [SGC for 1265 CONS pages..(9144 writable)..(T=1).GC finished] But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 7) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\7 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 8) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\8 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 9) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\9 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 10) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\A Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 11) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\B Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 12) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\C Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 13) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\D Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 14) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\E Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 15) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\F Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/4.1.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 1)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 2)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 3)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 4)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 5)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 6)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 7)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 8)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 9)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 10)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 11)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 12)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 13)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 14)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 15)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\0 Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule EXPLODE-NONNEGATIVE- INTEGER. Subgoal *1/3 (IMPLIES (AND (NOT (OR (ZP X) (NOT (PRINT-BASE-P Y)))) (NOT (TRUE-LISTP (CONS (DIGIT-TO-CHAR (MOD X Y)) Z))) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z))). But we reduce the conjecture to T, by primitive type reasoning. Subgoal *1/2 (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P Y))) (NOT (NULL Z)) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z))). By the simple :definitions NULL and PRINT-BASE-P we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (OR (ZP X) (NOT (MEMBER Y '(2 8 10 16)))) Z (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :congruence rule IFF-IMPLIES-EQUAL- NOT, the :definitions EXPLODE-NONNEGATIVE-INTEGER, MEMBER, NOT and PRINT-BASE-P, the :executable-counterparts of CAR, CDR and CONSP and primitive type reasoning. Subgoal *1/1 (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P Y))) (NULL Z) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z))). By the simple :definitions NULL and PRINT-BASE-P we reduce the conjecture to Subgoal *1/1' (IMPLIES (AND (OR (ZP X) (NOT (MEMBER Y '(2 8 10 16)))) (NOT Z) (TRUE-LISTP Z)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X Y Z))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :congruence rule IFF-IMPLIES-EQUAL- NOT, the :definitions EXPLODE-NONNEGATIVE-INTEGER, MEMBER, NOT and PRINT-BASE-P, the :executable-counterparts of CAR, CDR, CONSP, EQUAL, NOT and TRUE-LISTP and primitive type reasoning. That completes the proof of *1. Q.E.D. The storage of TRUE-LISTP-EXPLODE-NONNEGATIVE-INTEGER depends upon the :type-prescription rule TRUE-LISTP. Summary Form: ( DEFTHM TRUE-LISTP-EXPLODE-NONNEGATIVE-INTEGER ...) Rules: ((:COMPOUND-RECOGNIZER ZP-COMPOUND-RECOGNIZER) (:CONGRUENCE IFF-IMPLIES-EQUAL-NOT) (:DEFINITION DIGIT-TO-CHAR) (:DEFINITION EXPLODE-NONNEGATIVE-INTEGER) (:DEFINITION FLOOR) (:DEFINITION MEMBER) (:DEFINITION MOD) (:DEFINITION NOT) (:DEFINITION NULL) (:DEFINITION PRINT-BASE-P) (:EXECUTABLE-COUNTERPART CAR) (:EXECUTABLE-COUNTERPART CDR) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART DIGIT-TO-CHAR) (:EXECUTABLE-COUNTERPART EQUAL) (:EXECUTABLE-COUNTERPART NOT) (:EXECUTABLE-COUNTERPART PRINT-BASE-P) (:EXECUTABLE-COUNTERPART TRUE-LISTP) (:EXECUTABLE-COUNTERPART UNARY-/) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:INDUCTION EXPLODE-NONNEGATIVE-INTEGER) (:REWRITE COMMUTATIVITY-OF-*) (:TYPE-PRESCRIPTION EXPLODE-NONNEGATIVE-INTEGER) (:TYPE-PRESCRIPTION TRUE-LISTP)) Warnings: None Time: 1.46 seconds (prove: 1.28, print: 0.18, other: 0.00) TRUE-LISTP-EXPLODE-NONNEGATIVE-INTEGER ACL2 !>>(DEFTHM TRUE-LISTP-APPEND (EQUAL (TRUE-LISTP (APPEND X Y)) (TRUE-LISTP Y))) Name the formula above *1. Perhaps we can prove *1 by induction. Two induction schemes are suggested by this conjecture. However, one of these is flawed and so we are left with one viable candidate. We will induct according to a scheme suggested by (BINARY-APPEND X Y). This suggestion was produced using the :induction rule BINARY-APPEND. If we let (:P X Y) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (ENDP X)) (:P (CDR X) Y)) (:P X Y)) (IMPLIES (ENDP X) (:P X Y))). This induction is justified by the same argument used to admit BINARY- APPEND, namely, the measure (ACL2-COUNT X) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). When applied to the goal at hand the above induction scheme produces the following two nontautological subgoals. Subgoal *1/2 (IMPLIES (AND (NOT (ENDP X)) (EQUAL (TRUE-LISTP (APPEND (CDR X) Y)) (TRUE-LISTP Y))) (EQUAL (TRUE-LISTP (APPEND X Y)) (TRUE-LISTP Y))). By the simple :definition ENDP we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (CONSP X) (EQUAL (TRUE-LISTP (APPEND (CDR X) Y)) (TRUE-LISTP Y))) (EQUAL (TRUE-LISTP (APPEND X Y)) (TRUE-LISTP Y))). But simplification reduces this to T, using the :definitions BINARY- APPEND and TRUE-LISTP, primitive type reasoning and the :rewrite rule CDR-CONS. Subgoal *1/1 (IMPLIES (ENDP X) (EQUAL (TRUE-LISTP (APPEND X Y)) (TRUE-LISTP Y))). By the simple :definition ENDP we reduce the conjecture to Subgoal *1/1' (IMPLIES (NOT (CONSP X)) (EQUAL (TRUE-LISTP (APPEND X Y)) (TRUE-LISTP Y))). But simplification reduces this to T, using the :definition BINARY- APPEND and primitive type reasoning. That completes the proof of *1. Q.E.D. Summary Form: ( DEFTHM TRUE-LISTP-APPEND ...) Rules: ((:DEFINITION BINARY-APPEND) (:DEFINITION ENDP) (:DEFINITION NOT) (:DEFINITION TRUE-LISTP) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:INDUCTION BINARY-APPEND) (:REWRITE CDR-CONS)) Warnings: None Time: 0.01 seconds (prove: 0.00, print: 0.01, other: 0.00) TRUE-LISTP-APPEND ACL2 !>>(DEFTHM TRUE-LISTP-EXPLODE-ATOM (TRUE-LISTP (EXPLODE-ATOM X Y))) Name the formula above *1. Perhaps we can prove *1 by induction. One induction scheme is suggested by this conjecture. We will induct according to a scheme suggested by (EXPLODE-ATOM X Y). This suggestion was produced using the :induction rule EXPLODE-ATOM. If we let (:P X Y) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (NOT (STRINGP X))) (:P X Y)) (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (STRINGP X)) (:P X Y)) (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (CHARACTERP X)) (:P X Y)) (IMPLIES (AND (NOT (RATIONALP X)) (COMPLEX-RATIONALP X) (:P (REALPART X) Y) (:P (IMAGPART X) Y)) (:P X Y)) (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (:P (NUMERATOR X) Y)) (:P X Y)) (IMPLIES (AND (RATIONALP X) (INTEGERP X) (NOT (EQL 10 Y))) (:P X Y)) (IMPLIES (AND (RATIONALP X) (INTEGERP X) (EQL 10 Y)) (:P X Y))). This induction is justified by the same argument used to admit EXPLODE- ATOM, namely, the measure (ACL2-COUNT X) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). When applied to the goal at hand the above induction scheme produces the following seven nontautological subgoals. Subgoal *1/7 (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (NOT (STRINGP X))) (TRUE-LISTP (EXPLODE-ATOM X Y))). But simplification reduces this to T, using the :definition EXPLODE- ATOM and primitive type reasoning. Subgoal *1/6 (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (STRINGP X)) (TRUE-LISTP (EXPLODE-ATOM X Y))). But simplification reduces this to T, using the :definition EXPLODE- ATOM and primitive type reasoning. Subgoal *1/5 (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (CHARACTERP X)) (TRUE-LISTP (EXPLODE-ATOM X Y))). But simplification reduces this to T, using the :definition EXPLODE- ATOM and primitive type reasoning. Subgoal *1/4 (IMPLIES (AND (NOT (RATIONALP X)) (COMPLEX-RATIONALP X) (TRUE-LISTP (EXPLODE-ATOM (REALPART X) Y)) (TRUE-LISTP (EXPLODE-ATOM (IMAGPART X) Y))) (TRUE-LISTP (EXPLODE-ATOM X Y))). But simplification reduces this to T, using the :definitions EXPLODE- ATOM and TRUE-LISTP, the :executable-counterpart of TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP-APPEND. Subgoal *1/3 (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (TRUE-LISTP (EXPLODE-ATOM (NUMERATOR X) Y))) (TRUE-LISTP (EXPLODE-ATOM X Y))). But simplification reduces this to T, using the :definitions EXPLODE- ATOM and TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS, TRUE-LISTP-APPEND and TRUE-LISTP-EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2 (IMPLIES (AND (RATIONALP X) (INTEGERP X) (NOT (EQL 10 Y))) (TRUE-LISTP (EXPLODE-ATOM X Y))). By the simple :definition EQL we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (RATIONALP X) (INTEGERP X) (NOT (EQUAL 10 Y))) (TRUE-LISTP (EXPLODE-ATOM X Y))). This simplifies, using the :definition EXPLODE-ATOM, the :executable- counterpart of EQUAL and primitive type reasoning, to the following eight conjectures. Subgoal *1/2.8 (IMPLIES (AND (INTEGERP X) (EQUAL Y 2) (< X 0)) (TRUE-LISTP (LIST* #\# #\b #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 2 NIL)))). But simplification reduces this to T, using the :definition TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP- EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.7 (IMPLIES (AND (INTEGERP X) (EQUAL Y 2) (<= 0 X)) (TRUE-LISTP (LIST* #\# #\b (EXPLODE-NONNEGATIVE-INTEGER X 2 NIL)))). But simplification reduces this to T, using the :definition TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP- EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.6 (IMPLIES (AND (INTEGERP X) (EQUAL Y 8) (< X 0)) (TRUE-LISTP (LIST* #\# #\o #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 8 NIL)))). But simplification reduces this to T, using the :definition TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP- EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.5 (IMPLIES (AND (INTEGERP X) (EQUAL Y 8) (<= 0 X)) (TRUE-LISTP (LIST* #\# #\o (EXPLODE-NONNEGATIVE-INTEGER X 8 NIL)))). But simplification reduces this to T, using the :definition TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP- EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.4 (IMPLIES (AND (INTEGERP X) (EQUAL Y 16) (< X 0)) (TRUE-LISTP (LIST* #\# #\x #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 16 NIL)))). But simplification reduces this to T, using the :definition TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP- EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.3 (IMPLIES (AND (INTEGERP X) (NOT (EQUAL 10 Y)) (NOT (EQUAL Y 2)) (NOT (EQUAL Y 8)) (NOT (EQUAL Y 16)) (< X 0)) (TRUE-LISTP (LIST* #\# NIL #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) Y NIL)))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, MEMBER and PRINT-BASE-P, the :executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL and TRUE-LISTP and primitive type reasoning. Subgoal *1/2.2 (IMPLIES (AND (INTEGERP X) (EQUAL Y 16) (<= 0 X)) (TRUE-LISTP (LIST* #\# #\x (EXPLODE-NONNEGATIVE-INTEGER X 16 NIL)))). But simplification reduces this to T, using the :definition TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP- EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.1 (IMPLIES (AND (INTEGERP X) (NOT (EQUAL 10 Y)) (NOT (EQUAL Y 2)) (NOT (EQUAL Y 8)) (NOT (EQUAL Y 16)) (<= 0 X)) (TRUE-LISTP (LIST* #\# NIL (EXPLODE-NONNEGATIVE-INTEGER X Y NIL)))). But simplification reduces this to T, using the :definitions EXPLODE- NONNEGATIVE-INTEGER, MEMBER and PRINT-BASE-P, the :executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL and TRUE-LISTP and primitive type reasoning. Subgoal *1/1 (IMPLIES (AND (RATIONALP X) (INTEGERP X) (EQL 10 Y)) (TRUE-LISTP (EXPLODE-ATOM X Y))). By the simple :definition EQL we reduce the conjecture to Subgoal *1/1' (IMPLIES (AND (RATIONALP X) (INTEGERP X) (EQUAL 10 Y)) (TRUE-LISTP (EXPLODE-ATOM X Y))). This simplifies, using the :definition EXPLODE-ATOM and the :executable- counterpart of EQUAL, to the following two conjectures. Subgoal *1/1.2 (IMPLIES (AND (INTEGERP X) (< X 0)) (TRUE-LISTP (CONS #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 10 NIL)))). But simplification reduces this to T, using the :definition TRUE-LISTP, primitive type reasoning and the :rewrite rules CDR-CONS and TRUE-LISTP- EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/1.1 (IMPLIES (AND (INTEGERP X) (<= 0 X)) (TRUE-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 NIL))). But simplification reduces this to T, using the :rewrite rule TRUE- LISTP-EXPLODE-NONNEGATIVE-INTEGER. That completes the proof of *1. Q.E.D. The storage of TRUE-LISTP-EXPLODE-ATOM depends upon the :type-prescription rule TRUE-LISTP. Summary Form: ( DEFTHM TRUE-LISTP-EXPLODE-ATOM ...) Rules: ((:COMPOUND-RECOGNIZER ZP-COMPOUND-RECOGNIZER) (:DEFINITION EQL) (:DEFINITION EXPLODE-ATOM) (:DEFINITION EXPLODE-NONNEGATIVE-INTEGER) (:DEFINITION MEMBER) (:DEFINITION NOT) (:DEFINITION PRINT-BASE-P) (:DEFINITION TRUE-LISTP) (:EXECUTABLE-COUNTERPART CAR) (:EXECUTABLE-COUNTERPART CDR) (:EXECUTABLE-COUNTERPART CONS) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART EQUAL) (:EXECUTABLE-COUNTERPART TRUE-LISTP) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:INDUCTION EXPLODE-ATOM) (:REWRITE CDR-CONS) (:REWRITE TRUE-LISTP-APPEND) (:REWRITE TRUE-LISTP-EXPLODE-NONNEGATIVE-INTEGER) (:TYPE-PRESCRIPTION TRUE-LISTP)) Warnings: None Time: 0.07 seconds (prove: 0.07, print: 0.00, other: 0.00) TRUE-LISTP-EXPLODE-ATOM ACL2 !>>(DEFUN GOOD-ATOM-LISTP (LST) (DECLARE (XARGS :GUARD T)) (COND ((ATOM LST) (NULL LST)) (T (AND (LET ((X (CAR LST))) (OR (ACL2-NUMBERP X) (CHARACTERP X) (STRINGP X) (SYMBOLP X))) (GOOD-ATOM-LISTP (CDR LST)))))) The admission of GOOD-ATOM-LISTP is trivial, using the relation O< (which is known to be well-founded on the domain recognized by O-P) and the measure (ACL2-COUNT LST). We observe that the type of GOOD- ATOM-LISTP is described by the theorem (OR (EQUAL (GOOD-ATOM-LISTP LST) T) (EQUAL (GOOD-ATOM-LISTP LST) NIL)). We used primitive type reasoning. The guard conjecture for GOOD-ATOM-LISTP is trivial to prove. GOOD- ATOM-LISTP is compliant with Common Lisp. Summary Form: ( DEFUN GOOD-ATOM-LISTP ...) Rules: ((:FAKE-RUNE-FOR-TYPE-SET NIL)) Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) GOOD-ATOM-LISTP ACL2 !>>(DEFUN PACKN1* (LST) (DECLARE (XARGS :GUARD (GOOD-ATOM-LISTP LST))) (COND ((ENDP LST) NIL) (T (APPEND (EXPLODE-ATOM (CAR LST) 10) (PACKN1* (CDR LST)))))) The admission of PACKN1* is trivial, using the relation O< (which is known to be well-founded on the domain recognized by O-P) and the measure (ACL2-COUNT LST). We observe that the type of PACKN1* is described by the theorem (OR (CONSP (PACKN1* LST)) (EQUAL (PACKN1* LST) NIL)). We used the :type-prescription rule BINARY-APPEND. [SGC for 21 STRING pages..(9157 writable)..(T=1).GC finished] The non-trivial part of the guard conjecture for PACKN1* is Goal (AND (IMPLIES (AND (GOOD-ATOM-LISTP LST) (NOT (CONSP LST))) (EQUAL LST NIL)) (IMPLIES (AND (GOOD-ATOM-LISTP LST) (NOT (ENDP LST))) (GOOD-ATOM-LISTP (CDR LST))) (IMPLIES (AND (GOOD-ATOM-LISTP LST) (NOT (ENDP LST))) (PRINT-BASE-P 10)) (IMPLIES (AND (GOOD-ATOM-LISTP LST) (NOT (ENDP LST))) (TRUE-LISTP (EXPLODE-ATOM (CAR LST) 10))) (IMPLIES (AND (GOOD-ATOM-LISTP LST) (NOT (ENDP LST)) (NOT (ACL2-NUMBERP (CAR LST))) (NOT (CHARACTERP (CAR LST))) (NOT (STRINGP (CAR LST)))) (SYMBOLP (CAR LST)))). By the simple :definition ENDP, the :executable-counterpart of PRINT- BASE-P and the simple :rewrite rule TRUE-LISTP-EXPLODE-ATOM we reduce the conjecture to the following three conjectures. Subgoal 3 (IMPLIES (AND (GOOD-ATOM-LISTP LST) (NOT (CONSP LST))) (EQUAL LST NIL)). But simplification reduces this to T, using the :definition GOOD-ATOM- LISTP and primitive type reasoning. Subgoal 2 (IMPLIES (AND (GOOD-ATOM-LISTP LST) (CONSP LST)) (GOOD-ATOM-LISTP (CDR LST))). But simplification reduces this to T, using the :definition GOOD-ATOM- LISTP. Subgoal 1 (IMPLIES (AND (GOOD-ATOM-LISTP LST) (CONSP LST) (NOT (ACL2-NUMBERP (CAR LST))) (NOT (CHARACTERP (CAR LST))) (NOT (STRINGP (CAR LST)))) (SYMBOLP (CAR LST))). But simplification reduces this to T, using the :definition GOOD-ATOM- LISTP. Q.E.D. That completes the proof of the guard theorem for PACKN1*. PACKN1* is compliant with Common Lisp. Summary Form: ( DEFUN PACKN1* ...) Rules: ((:DEFINITION ENDP) (:DEFINITION GOOD-ATOM-LISTP) (:DEFINITION NOT) (:EXECUTABLE-COUNTERPART PRINT-BASE-P) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:REWRITE TRUE-LISTP-EXPLODE-ATOM) (:TYPE-PRESCRIPTION BINARY-APPEND)) Warnings: None Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01) PACKN1* ACL2 !>>(DEFTHM CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER (IMPLIES (CHARACTER-LISTP ANS) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS)))) Name the formula above *1. Perhaps we can prove *1 by induction. Two induction schemes are suggested by this conjecture. However, one of these is flawed and so we are left with one viable candidate. We will induct according to a scheme suggested by (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS). This suggestion was produced using the :induction rule EXPLODE-NONNEGATIVE-INTEGER. If we let (:P ANS BASE X) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (OR (ZP X) (NOT (PRINT-BASE-P BASE)))) (:P (CONS (DIGIT-TO-CHAR (MOD X BASE)) ANS) BASE (FLOOR X BASE))) (:P ANS BASE X)) (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P BASE))) (NOT (NULL ANS))) (:P ANS BASE X)) (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P BASE))) (NULL ANS)) (:P ANS BASE X))). This induction is justified by the same argument used to admit EXPLODE- NONNEGATIVE-INTEGER, namely, the measure (ACL2-COUNT X) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). Note, however, that the unmeasured variable ANS is being instantiated. When applied to the goal at hand the above induction scheme produces the following four nontautological subgoals. Subgoal *1/4 (IMPLIES (AND (NOT (OR (ZP X) (NOT (PRINT-BASE-P BASE)))) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (FLOOR X BASE) BASE (CONS (DIGIT-TO-CHAR (MOD X BASE)) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). By the simple :definitions FLOOR and PRINT-BASE-P we reduce the conjecture to Subgoal *1/4' (IMPLIES (AND (NOT (OR (ZP X) (NOT (MEMBER BASE '(2 8 10 16))))) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (LET ((Q (* X (/ BASE)))) (LET ((D (DENOMINATOR Q)) (N (NUMERATOR Q))) (COND ((EQUAL D 1) N) ((< N 0) (+ (- (NONNEGATIVE-INTEGER-QUOTIENT (- N) D)) -1)) (T (NONNEGATIVE-INTEGER-QUOTIENT N D))))) BASE (CONS (DIGIT-TO-CHAR (MOD X BASE)) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). This simplifies, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :congruence rule IFF-IMPLIES-EQUAL-NOT, the :definitions FLOOR, MEMBER, MOD and NOT, the :executable-counterparts of CAR, CDR, CONSP and UNARY-/, primitive type reasoning and the :rewrite rule COMMUTATIVITY- OF-*, to the following eight conjectures. Subgoal *1/4.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 2) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS (DIGIT-TO-CHAR (+ X (- (* 2 (NUMERATOR (* 1/2 X)))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.8.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.8.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/2 X)) 1) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 1)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 2)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 3)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 4)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 5)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 6)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 7)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 8)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 9)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 10)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 11)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 12)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 13)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 14)) (NOT (EQUAL (+ X (- (* 2 (NUMERATOR (* 1/2 X))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/2 X)) 2 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 2) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS (DIGIT-TO-CHAR (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.7.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.7.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/2 X)) 1)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 1)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 2)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 3)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 4)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 5)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 6)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 7)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 8)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 9)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 10)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 11)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 12)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 13)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 14)) (NOT (EQUAL (+ X (- (* 2 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X)))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/2 X)) (DENOMINATOR (* 1/2 X))) 2 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 10) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS (DIGIT-TO-CHAR (+ X (- (* 10 (NUMERATOR (* 1/10 X)))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.6.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.6.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/10 X)) 1) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 1)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 2)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 3)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 4)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 5)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 6)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 7)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 8)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 9)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 10)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 11)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 12)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 13)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 14)) (NOT (EQUAL (+ X (- (* 10 (NUMERATOR (* 1/10 X))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/10 X)) 10 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 10) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS (DIGIT-TO-CHAR (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). [SGC for 2839 CONS pages..(10776 writable)..(T=1).GC finished] This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.5.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.5.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/10 X)) 1)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 1)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 2)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 3)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 4)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 5)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 6)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 7)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 8)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 9)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 10)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 11)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 12)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 13)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 14)) (NOT (EQUAL (+ X (- (* 10 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X)))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/10 X)) (DENOMINATOR (* 1/10 X))) 10 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 8) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS (DIGIT-TO-CHAR (+ X (- (* 8 (NUMERATOR (* 1/8 X)))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.4.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.4.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/8 X)) 1) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 1)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 2)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 3)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 4)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 5)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 6)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 7)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 8)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 9)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 10)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 11)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 12)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 13)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 14)) (NOT (EQUAL (+ X (- (* 8 (NUMERATOR (* 1/8 X))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/8 X)) 8 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 8) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS (DIGIT-TO-CHAR (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.3.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.3.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/8 X)) 1)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 1)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 2)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 3)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 4)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 5)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 6)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 7)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 8)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 9)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 10)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 11)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 12)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 13)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 14)) (NOT (EQUAL (+ X (- (* 8 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X)))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/8 X)) (DENOMINATOR (* 1/8 X))) 8 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 16) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS (DIGIT-TO-CHAR (+ X (- (* 16 (NUMERATOR (* 1/16 X)))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.2.16 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.15 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.14 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.13 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.12 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.11 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.10 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.9 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.8 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.7 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.6 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.5 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.4 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.3 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.2 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.2.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL (DENOMINATOR (* 1/16 X)) 1) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 1)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 2)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 3)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 4)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 5)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 6)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 7)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 8)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 9)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 10)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 11)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 12)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 13)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 14)) (NOT (EQUAL (+ X (- (* 16 (NUMERATOR (* 1/16 X))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NUMERATOR (* 1/16 X)) 16 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of EQUAL, PRINT-BASE-P and UNARY-/, the :rewrite rule COMMUTATIVITY-OF- * and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1 (IMPLIES (AND (NOT (ZP X)) (EQUAL BASE 16) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS (DIGIT-TO-CHAR (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))))))) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). This simplifies, using the :definition DIGIT-TO-CHAR and the :executable- counterpart of EQUAL, to the following 16 conjectures. Subgoal *1/4.1.16 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 1) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\1 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.15 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 2) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\2 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.14 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 3) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\3 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.13 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 4) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\4 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.12 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 5) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\5 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.11 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 6) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\6 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.10 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 7) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\7 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.9 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 8) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\8 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.8 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 9) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\9 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.7 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 10) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\A ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.6 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 11) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\B ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.5 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 12) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\C ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.4 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 13) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\D ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.3 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 14) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\E ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.2 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 15) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\F ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions EXPLODE-NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of DIGIT-TO-CHAR, PRINT- BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY- OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/4.1.1 (IMPLIES (AND (NOT (ZP X)) (NOT (EQUAL (DENOMINATOR (* 1/16 X)) 1)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 1)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 2)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 3)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 4)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 5)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 6)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 7)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 8)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 9)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 10)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 11)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 12)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 13)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 14)) (NOT (EQUAL (+ X (- (* 16 (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X)))))) 15)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER (NONNEGATIVE-INTEGER-QUOTIENT (NUMERATOR (* 1/16 X)) (DENOMINATOR (* 1/16 X))) 16 (CONS #\0 ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :definitions DIGIT-TO-CHAR, EXPLODE- NONNEGATIVE-INTEGER, FLOOR and MOD, the :executable-counterparts of PRINT-BASE-P and UNARY-/, primitive type reasoning, the :rewrite rule COMMUTATIVITY-OF-* and the :type-prescription rule CHARACTER-LISTP. Subgoal *1/3 (IMPLIES (AND (NOT (OR (ZP X) (NOT (PRINT-BASE-P BASE)))) (NOT (CHARACTER-LISTP (CONS (DIGIT-TO-CHAR (MOD X BASE)) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). By the simple :definition PRINT-BASE-P we reduce the conjecture to Subgoal *1/3' (IMPLIES (AND (NOT (OR (ZP X) (NOT (MEMBER BASE '(2 8 10 16))))) (NOT (CHARACTER-LISTP (CONS (DIGIT-TO-CHAR (MOD X BASE)) ANS))) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :congruence rule IFF-IMPLIES-EQUAL- NOT, the :definitions CHARACTER-LISTP, FLOOR, MEMBER, MOD and NOT, the :executable-counterparts of CAR, CDR, CONSP and UNARY-/, primitive type reasoning, the :forward-chaining rules ATOM-LISTP-FORWARD-TO-TRUE- LISTP, CHARACTER-LISTP-FORWARD-TO-EQLABLE-LISTP and EQLABLE-LISTP-FORWARD- TO-ATOM-LISTP, the :rewrite rules CAR-CONS, CDR-CONS and COMMUTATIVITY- OF-* and the :type-prescription rules ATOM-LISTP, CHARACTER-LISTP, DIGIT-TO-CHAR and EQLABLE-LISTP. Subgoal *1/2 (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P BASE))) (NOT (NULL ANS)) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). By the simple :definitions NULL and PRINT-BASE-P we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (OR (ZP X) (NOT (MEMBER BASE '(2 8 10 16)))) ANS (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :congruence rule IFF-IMPLIES-EQUAL- NOT, the :definitions EXPLODE-NONNEGATIVE-INTEGER, MEMBER, NOT and PRINT-BASE-P, the :executable-counterparts of CAR, CDR and CONSP, primitive type reasoning, the :forward-chaining rules ATOM-LISTP-FORWARD-TO-TRUE- LISTP, CHARACTER-LISTP-FORWARD-TO-EQLABLE-LISTP and EQLABLE-LISTP-FORWARD- TO-ATOM-LISTP and the :type-prescription rules ATOM-LISTP, CHARACTER- LISTP and EQLABLE-LISTP. Subgoal *1/1 (IMPLIES (AND (OR (ZP X) (NOT (PRINT-BASE-P BASE))) (NULL ANS) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). By the simple :definitions NULL and PRINT-BASE-P we reduce the conjecture to Subgoal *1/1' (IMPLIES (AND (OR (ZP X) (NOT (MEMBER BASE '(2 8 10 16)))) (NOT ANS) (CHARACTER-LISTP ANS)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X BASE ANS))). But simplification reduces this to T, using the :compound-recognizer rule ZP-COMPOUND-RECOGNIZER, the :congruence rule IFF-IMPLIES-EQUAL- NOT, the :definitions EXPLODE-NONNEGATIVE-INTEGER, MEMBER, NOT and PRINT-BASE-P, the :executable-counterparts of CAR, CDR, CHARACTER-LISTP, CONSP, EQUAL and NOT and primitive type reasoning. That completes the proof of *1. Q.E.D. The storage of CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER depends upon the :type-prescription rule CHARACTER-LISTP. Summary Form: ( DEFTHM CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER ...) Rules: ((:COMPOUND-RECOGNIZER ZP-COMPOUND-RECOGNIZER) (:CONGRUENCE IFF-IMPLIES-EQUAL-NOT) (:DEFINITION CHARACTER-LISTP) (:DEFINITION DIGIT-TO-CHAR) (:DEFINITION EXPLODE-NONNEGATIVE-INTEGER) (:DEFINITION FLOOR) (:DEFINITION MEMBER) (:DEFINITION MOD) (:DEFINITION NOT) (:DEFINITION NULL) (:DEFINITION PRINT-BASE-P) (:EXECUTABLE-COUNTERPART CAR) (:EXECUTABLE-COUNTERPART CDR) (:EXECUTABLE-COUNTERPART CHARACTER-LISTP) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART DIGIT-TO-CHAR) (:EXECUTABLE-COUNTERPART EQUAL) (:EXECUTABLE-COUNTERPART NOT) (:EXECUTABLE-COUNTERPART PRINT-BASE-P) (:EXECUTABLE-COUNTERPART UNARY-/) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:FORWARD-CHAINING ATOM-LISTP-FORWARD-TO-TRUE-LISTP) (:FORWARD-CHAINING CHARACTER-LISTP-FORWARD-TO-EQLABLE-LISTP) (:FORWARD-CHAINING EQLABLE-LISTP-FORWARD-TO-ATOM-LISTP) (:INDUCTION EXPLODE-NONNEGATIVE-INTEGER) (:REWRITE CAR-CONS) (:REWRITE CDR-CONS) (:REWRITE COMMUTATIVITY-OF-*) (:TYPE-PRESCRIPTION ATOM-LISTP) (:TYPE-PRESCRIPTION CHARACTER-LISTP) (:TYPE-PRESCRIPTION DIGIT-TO-CHAR) (:TYPE-PRESCRIPTION EQLABLE-LISTP)) Warnings: None Time: 1.69 seconds (prove: 1.46, print: 0.23, other: 0.00) CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER ACL2 !>>(DEFTHM CHARACTER-LISTP-EXPLODE-ATOM (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))) This simplifies, using the :definition MEMBER-EQ, the :executable- counterparts of CAR, CDR and CONSP and primitive type reasoning, to the following four conjectures. Subgoal 4 (IMPLIES (EQUAL BASE 2) (CHARACTER-LISTP (EXPLODE-ATOM X 2))). This simplifies, using trivial observations, to Subgoal 4' (CHARACTER-LISTP (EXPLODE-ATOM X 2)). Name the formula above *1. Subgoal 3 (IMPLIES (EQUAL BASE 10) (CHARACTER-LISTP (EXPLODE-ATOM X 10))). This simplifies, using trivial observations, to Subgoal 3' (CHARACTER-LISTP (EXPLODE-ATOM X 10)). Normally we would attempt to prove this formula by induction. However, we prefer in this instance to focus on the original input conjecture rather than this simplified special case. We therefore abandon our previous work on this conjecture and reassign the name *1 to the original conjecture. (See :DOC otf-flg.) Perhaps we can prove *1 by induction. One induction scheme is suggested by this conjecture. We will induct according to a scheme suggested by (EXPLODE-ATOM X BASE). This suggestion was produced using the :induction rule EXPLODE-ATOM. If we let (:P BASE X) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (NOT (STRINGP X))) (:P BASE X)) (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (STRINGP X)) (:P BASE X)) (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (CHARACTERP X)) (:P BASE X)) (IMPLIES (AND (NOT (RATIONALP X)) (COMPLEX-RATIONALP X) (:P BASE (REALPART X)) (:P BASE (IMAGPART X))) (:P BASE X)) (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (:P BASE (NUMERATOR X))) (:P BASE X)) (IMPLIES (AND (RATIONALP X) (INTEGERP X) (NOT (EQL 10 BASE))) (:P BASE X)) (IMPLIES (AND (RATIONALP X) (INTEGERP X) (EQL 10 BASE)) (:P BASE X))). This induction is justified by the same argument used to admit EXPLODE- ATOM, namely, the measure (ACL2-COUNT X) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). When applied to the goal at hand the above induction scheme produces the following seven nontautological subgoals. Subgoal *1/7 (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (NOT (STRINGP X))) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))). By case analysis we reduce the conjecture to Subgoal *1/7' (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (NOT (STRINGP X)) (MEMBER-EQ BASE '(2 8 10 16))) (CHARACTER-LISTP (EXPLODE-ATOM X BASE))). But simplification reduces this to T, using the :definitions EXPLODE- ATOM and MEMBER-EQ, the :executable-counterparts of CAR, CDR and CONSP, primitive type reasoning and the :rewrite rule CHARACTER-LISTP-COERCE. Subgoal *1/6 (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (STRINGP X)) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))). By case analysis we reduce the conjecture to Subgoal *1/6' (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (NOT (CHARACTERP X)) (STRINGP X) (MEMBER-EQ BASE '(2 8 10 16))) (CHARACTER-LISTP (EXPLODE-ATOM X BASE))). But simplification reduces this to T, using the :definitions EXPLODE- ATOM and MEMBER-EQ, the :executable-counterparts of CAR, CDR and CONSP, primitive type reasoning and the :rewrite rule CHARACTER-LISTP-COERCE. Subgoal *1/5 (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (CHARACTERP X)) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))). By case analysis we reduce the conjecture to Subgoal *1/5' (IMPLIES (AND (NOT (RATIONALP X)) (NOT (COMPLEX-RATIONALP X)) (CHARACTERP X) (MEMBER-EQ BASE '(2 8 10 16))) (CHARACTER-LISTP (EXPLODE-ATOM X BASE))). But simplification reduces this to T, using the :definitions CHARACTER- LISTP, EXPLODE-ATOM and MEMBER-EQ, the :executable-counterparts of CAR, CDR, CHARACTER-LISTP and CONSP, primitive type reasoning and the :rewrite rules CAR-CONS and CDR-CONS. Subgoal *1/4 (IMPLIES (AND (NOT (RATIONALP X)) (COMPLEX-RATIONALP X) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM (REALPART X) BASE))) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM (IMAGPART X) BASE)))) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))). By case analysis we reduce the conjecture to Subgoal *1/4' (IMPLIES (AND (NOT (RATIONALP X)) (COMPLEX-RATIONALP X) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM (REALPART X) BASE))) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM (IMAGPART X) BASE))) (MEMBER-EQ BASE '(2 8 10 16))) (CHARACTER-LISTP (EXPLODE-ATOM X BASE))). This simplifies, using the :definition MEMBER-EQ, the :executable- counterparts of CAR, CDR, CONSP, MEMBER-EQ and NOT and primitive type reasoning, to the following four conjectures. Subgoal *1/4.4 (IMPLIES (AND (COMPLEX-RATIONALP X) (EQUAL BASE 2) (CHARACTER-LISTP (EXPLODE-ATOM (REALPART X) 2)) (CHARACTER-LISTP (EXPLODE-ATOM (IMAGPART X) 2))) (CHARACTER-LISTP (EXPLODE-ATOM X 2))). But simplification reduces this to T, using the :definitions CHARACTER- LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning, the :forward-chaining rules ATOM-LISTP-FORWARD-TO-TRUE-LISTP, CHARACTER-LISTP-FORWARD-TO-EQLABLE- LISTP and EQLABLE-LISTP-FORWARD-TO-ATOM-LISTP, the :rewrite rules CAR- CONS, CDR-CONS and CHARACTER-LISTP-APPEND and the :type-prescription rules ATOM-LISTP, CHARACTER-LISTP and EQLABLE-LISTP. Subgoal *1/4.3 (IMPLIES (AND (COMPLEX-RATIONALP X) (EQUAL BASE 10) (CHARACTER-LISTP (EXPLODE-ATOM (REALPART X) 10)) (CHARACTER-LISTP (EXPLODE-ATOM (IMAGPART X) 10))) (CHARACTER-LISTP (EXPLODE-ATOM X 10))). But simplification reduces this to T, using the :definitions CHARACTER- LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning, the :forward-chaining rules ATOM-LISTP-FORWARD-TO-TRUE-LISTP, CHARACTER-LISTP-FORWARD-TO-EQLABLE- LISTP and EQLABLE-LISTP-FORWARD-TO-ATOM-LISTP, the :rewrite rules CAR- CONS, CDR-CONS and CHARACTER-LISTP-APPEND and the :type-prescription rules ATOM-LISTP, CHARACTER-LISTP and EQLABLE-LISTP. Subgoal *1/4.2 (IMPLIES (AND (COMPLEX-RATIONALP X) (EQUAL BASE 8) (CHARACTER-LISTP (EXPLODE-ATOM (REALPART X) 8)) (CHARACTER-LISTP (EXPLODE-ATOM (IMAGPART X) 8))) (CHARACTER-LISTP (EXPLODE-ATOM X 8))). [SGC for 5727 CONS pages..(13762 writable)..(T=3).GC finished] But simplification reduces this to T, using the :definitions CHARACTER- LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning, the :forward-chaining rules ATOM-LISTP-FORWARD-TO-TRUE-LISTP, CHARACTER-LISTP-FORWARD-TO-EQLABLE- LISTP and EQLABLE-LISTP-FORWARD-TO-ATOM-LISTP, the :rewrite rules CAR- CONS, CDR-CONS and CHARACTER-LISTP-APPEND and the :type-prescription rules ATOM-LISTP, CHARACTER-LISTP and EQLABLE-LISTP. Subgoal *1/4.1 (IMPLIES (AND (COMPLEX-RATIONALP X) (EQUAL BASE 16) (CHARACTER-LISTP (EXPLODE-ATOM (REALPART X) 16)) (CHARACTER-LISTP (EXPLODE-ATOM (IMAGPART X) 16))) (CHARACTER-LISTP (EXPLODE-ATOM X 16))). But simplification reduces this to T, using the :definitions CHARACTER- LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning, the :forward-chaining rules ATOM-LISTP-FORWARD-TO-TRUE-LISTP, CHARACTER-LISTP-FORWARD-TO-EQLABLE- LISTP and EQLABLE-LISTP-FORWARD-TO-ATOM-LISTP, the :rewrite rules CAR- CONS, CDR-CONS and CHARACTER-LISTP-APPEND and the :type-prescription rules ATOM-LISTP, CHARACTER-LISTP and EQLABLE-LISTP. Subgoal *1/3 (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM (NUMERATOR X) BASE)))) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))). By case analysis we reduce the conjecture to Subgoal *1/3' (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM (NUMERATOR X) BASE))) (MEMBER-EQ BASE '(2 8 10 16))) (CHARACTER-LISTP (EXPLODE-ATOM X BASE))). This simplifies, using the :definition MEMBER-EQ, the :executable- counterparts of CAR, CDR, CONSP, MEMBER-EQ and NOT and primitive type reasoning, to the following four conjectures. Subgoal *1/3.4 (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (EQUAL BASE 2) (CHARACTER-LISTP (EXPLODE-ATOM (NUMERATOR X) 2))) (CHARACTER-LISTP (EXPLODE-ATOM X 2))). But simplification reduces this to T, using the :definitions BINARY- APPEND, CHARACTER-LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP, CHARACTERP and EQUAL, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, CHARACTER-LISTP-APPEND, CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER and TRUE-LISTP-EXPLODE- NONNEGATIVE-INTEGER. Subgoal *1/3.3 (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (EQUAL BASE 10) (CHARACTER-LISTP (EXPLODE-ATOM (NUMERATOR X) 10))) (CHARACTER-LISTP (EXPLODE-ATOM X 10))). But simplification reduces this to T, using the :definitions BINARY- APPEND, CHARACTER-LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP, CHARACTERP and EQUAL, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, CHARACTER-LISTP-APPEND, CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER and TRUE-LISTP-EXPLODE- NONNEGATIVE-INTEGER. Subgoal *1/3.2 (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (EQUAL BASE 8) (CHARACTER-LISTP (EXPLODE-ATOM (NUMERATOR X) 8))) (CHARACTER-LISTP (EXPLODE-ATOM X 8))). But simplification reduces this to T, using the :definitions BINARY- APPEND, CHARACTER-LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP, CHARACTERP and EQUAL, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, CHARACTER-LISTP-APPEND, CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER and TRUE-LISTP-EXPLODE- NONNEGATIVE-INTEGER. Subgoal *1/3.1 (IMPLIES (AND (RATIONALP X) (NOT (INTEGERP X)) (EQUAL BASE 16) (CHARACTER-LISTP (EXPLODE-ATOM (NUMERATOR X) 16))) (CHARACTER-LISTP (EXPLODE-ATOM X 16))). But simplification reduces this to T, using the :definitions BINARY- APPEND, CHARACTER-LISTP and EXPLODE-ATOM, the :executable-counterparts of CHARACTER-LISTP, CHARACTERP and EQUAL, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS, CHARACTER-LISTP-APPEND, CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER and TRUE-LISTP-EXPLODE- NONNEGATIVE-INTEGER. Subgoal *1/2 (IMPLIES (AND (RATIONALP X) (INTEGERP X) (NOT (EQL 10 BASE))) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))). By the simple :definition EQL we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (RATIONALP X) (INTEGERP X) (NOT (EQUAL 10 BASE)) (MEMBER-EQ BASE '(2 8 10 16))) (CHARACTER-LISTP (EXPLODE-ATOM X BASE))). This simplifies, using the :definitions CHARACTER-LISTP, EXPLODE-ATOM and MEMBER-EQ, the :executable-counterparts of CAR, CDR, CHARACTERP, CONSP and EQUAL, primitive type reasoning and the :rewrite rules CAR- CONS and CDR-CONS, to the following six conjectures. Subgoal *1/2.6 (IMPLIES (AND (INTEGERP X) (EQUAL BASE 2) (< X 0)) (CHARACTER-LISTP (CONS #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 2 NIL)))). But simplification reduces this to T, using the :definition CHARACTER- LISTP, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS and CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.5 (IMPLIES (AND (INTEGERP X) (EQUAL BASE 2) (<= 0 X)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 2 NIL))). But simplification reduces this to T, using the :executable-counterpart of CHARACTER-LISTP and the :rewrite rule CHARACTER-LISTP-EXPLODE-NONNEGATIVE- INTEGER. Subgoal *1/2.4 (IMPLIES (AND (INTEGERP X) (EQUAL BASE 16) (< X 0)) (CHARACTER-LISTP (CONS #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 16 NIL)))). But simplification reduces this to T, using the :definition CHARACTER- LISTP, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS and CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.3 (IMPLIES (AND (INTEGERP X) (EQUAL BASE 16) (<= 0 X)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 16 NIL))). But simplification reduces this to T, using the :executable-counterpart of CHARACTER-LISTP and the :rewrite rule CHARACTER-LISTP-EXPLODE-NONNEGATIVE- INTEGER. Subgoal *1/2.2 (IMPLIES (AND (INTEGERP X) (EQUAL BASE 8) (< X 0)) (CHARACTER-LISTP (CONS #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 8 NIL)))). But simplification reduces this to T, using the :definition CHARACTER- LISTP, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS and CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/2.1 (IMPLIES (AND (INTEGERP X) (EQUAL BASE 8) (<= 0 X)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 8 NIL))). But simplification reduces this to T, using the :executable-counterpart of CHARACTER-LISTP and the :rewrite rule CHARACTER-LISTP-EXPLODE-NONNEGATIVE- INTEGER. Subgoal *1/1 (IMPLIES (AND (RATIONALP X) (INTEGERP X) (EQL 10 BASE)) (IMPLIES (MEMBER-EQ BASE '(2 8 10 16)) (CHARACTER-LISTP (EXPLODE-ATOM X BASE)))). By the simple :definition EQL we reduce the conjecture to Subgoal *1/1' (IMPLIES (AND (RATIONALP X) (INTEGERP X) (EQUAL 10 BASE) (MEMBER-EQ BASE '(2 8 10 16))) (CHARACTER-LISTP (EXPLODE-ATOM X BASE))). This simplifies, using the :definition EXPLODE-ATOM and the :executable- counterparts of EQUAL, MEMBER-EQ and NOT, to the following two conjectures. Subgoal *1/1.2 (IMPLIES (AND (INTEGERP X) (< X 0)) (CHARACTER-LISTP (CONS #\- (EXPLODE-NONNEGATIVE-INTEGER (- X) 10 NIL)))). But simplification reduces this to T, using the :definition CHARACTER- LISTP, the :executable-counterparts of CHARACTER-LISTP and CHARACTERP, primitive type reasoning and the :rewrite rules CAR-CONS, CDR-CONS and CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER. Subgoal *1/1.1 (IMPLIES (AND (INTEGERP X) (<= 0 X)) (CHARACTER-LISTP (EXPLODE-NONNEGATIVE-INTEGER X 10 NIL))). But simplification reduces this to T, using the :executable-counterpart of CHARACTER-LISTP and the :rewrite rule CHARACTER-LISTP-EXPLODE-NONNEGATIVE- INTEGER. That completes the proof of *1. Q.E.D. The storage of CHARACTER-LISTP-EXPLODE-ATOM depends upon the :type- prescription rule CHARACTER-LISTP. Summary Form: ( DEFTHM CHARACTER-LISTP-EXPLODE-ATOM ...) Rules: ((:DEFINITION BINARY-APPEND) (:DEFINITION CHARACTER-LISTP) (:DEFINITION EQL) (:DEFINITION EXPLODE-ATOM) (:DEFINITION MEMBER-EQ) (:DEFINITION NOT) (:EXECUTABLE-COUNTERPART CAR) (:EXECUTABLE-COUNTERPART CDR) (:EXECUTABLE-COUNTERPART CHARACTER-LISTP) (:EXECUTABLE-COUNTERPART CHARACTERP) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART EQUAL) (:EXECUTABLE-COUNTERPART MEMBER-EQ) (:EXECUTABLE-COUNTERPART NOT) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:FORWARD-CHAINING ATOM-LISTP-FORWARD-TO-TRUE-LISTP) (:FORWARD-CHAINING CHARACTER-LISTP-FORWARD-TO-EQLABLE-LISTP) (:FORWARD-CHAINING EQLABLE-LISTP-FORWARD-TO-ATOM-LISTP) (:INDUCTION EXPLODE-ATOM) (:REWRITE CAR-CONS) (:REWRITE CDR-CONS) (:REWRITE CHARACTER-LISTP-APPEND) (:REWRITE CHARACTER-LISTP-COERCE) (:REWRITE CHARACTER-LISTP-EXPLODE-NONNEGATIVE-INTEGER) (:REWRITE TRUE-LISTP-EXPLODE-NONNEGATIVE-INTEGER) (:TYPE-PRESCRIPTION ATOM-LISTP) (:TYPE-PRESCRIPTION CHARACTER-LISTP) (:TYPE-PRESCRIPTION EQLABLE-LISTP)) Warnings: None Time: 0.69 seconds (prove: 0.67, print: 0.02, other: 0.00) CHARACTER-LISTP-EXPLODE-ATOM ACL2 !>>(DEFTHM GOOD-ATOM-LISTP-IMPLIES-CHARACTER-LISTP-PACKN1* (IMPLIES (GOOD-ATOM-LISTP LST) (CHARACTER-LISTP (PACKN1* LST)))) Name the formula above *1. Perhaps we can prove *1 by induction. Two induction schemes are suggested by this conjecture. These merge into one derived induction scheme. We will induct according to a scheme suggested by (PACKN1* LST). This suggestion was produced using the :induction rules GOOD-ATOM-LISTP and PACKN1*. If we let (:P LST) denote *1 above then the induction scheme we'll use is (AND (IMPLIES (AND (NOT (ENDP LST)) (:P (CDR LST))) (:P LST)) (IMPLIES (ENDP LST) (:P LST))). This induction is justified by the same argument used to admit PACKN1*, namely, the measure (ACL2-COUNT LST) is decreasing according to the relation O< (which is known to be well-founded on the domain recognized by O-P). When applied to the goal at hand the above induction scheme produces the following three nontautological subgoals. Subgoal *1/3 (IMPLIES (AND (NOT (ENDP LST)) (CHARACTER-LISTP (PACKN1* (CDR LST))) (GOOD-ATOM-LISTP LST)) (CHARACTER-LISTP (PACKN1* LST))). By the simple :definition ENDP we reduce the conjecture to Subgoal *1/3' (IMPLIES (AND (CONSP LST) (CHARACTER-LISTP (PACKN1* (CDR LST))) (GOOD-ATOM-LISTP LST)) (CHARACTER-LISTP (PACKN1* LST))). But simplification reduces this to T, using the :definitions BINARY- APPEND, CHARACTER-LISTP, EXPLODE-ATOM, GOOD-ATOM-LISTP and PACKN1*, the :executable-counterparts of CONSP and MEMBER-EQ, primitive type reasoning, the :forward-chaining rules ATOM-LISTP-FORWARD-TO-TRUE-LISTP, CHARACTER-LISTP-FORWARD-TO-EQLABLE-LISTP and EQLABLE-LISTP-FORWARD- TO-ATOM-LISTP, the :rewrite rules CAR-CONS, CDR-CONS, CHARACTER-LISTP- APPEND, CHARACTER-LISTP-COERCE, CHARACTER-LISTP-EXPLODE-ATOM and TRUE- LISTP-EXPLODE-ATOM and the :type-prescription rules ATOM-LISTP, CHARACTER- LISTP, EQLABLE-LISTP and PACKN1*. Subgoal *1/2 (IMPLIES (AND (NOT (ENDP LST)) (NOT (GOOD-ATOM-LISTP (CDR LST))) (GOOD-ATOM-LISTP LST)) (CHARACTER-LISTP (PACKN1* LST))). By the simple :definition ENDP we reduce the conjecture to Subgoal *1/2' (IMPLIES (AND (CONSP LST) (NOT (GOOD-ATOM-LISTP (CDR LST))) (GOOD-ATOM-LISTP LST)) (CHARACTER-LISTP (PACKN1* LST))). But simplification reduces this to T, using the :definition GOOD-ATOM- LISTP. Subgoal *1/1 (IMPLIES (AND (ENDP LST) (GOOD-ATOM-LISTP LST)) (CHARACTER-LISTP (PACKN1* LST))). By the simple :definition ENDP we reduce the conjecture to Subgoal *1/1' (IMPLIES (AND (NOT (CONSP LST)) (GOOD-ATOM-LISTP LST)) (CHARACTER-LISTP (PACKN1* LST))). But simplification reduces this to T, using the :definition GOOD-ATOM- LISTP, the :executable-counterparts of CHARACTER-LISTP, CONSP and PACKN1* and primitive type reasoning. That completes the proof of *1. Q.E.D. The storage of GOOD-ATOM-LISTP-IMPLIES-CHARACTER-LISTP-PACKN1* depends upon the :type-prescription rule CHARACTER-LISTP. Summary Form: ( DEFTHM GOOD-ATOM-LISTP-IMPLIES-CHARACTER-LISTP-PACKN1* ...) Rules: ((:DEFINITION BINARY-APPEND) (:DEFINITION CHARACTER-LISTP) (:DEFINITION ENDP) (:DEFINITION EXPLODE-ATOM) (:DEFINITION GOOD-ATOM-LISTP) (:DEFINITION NOT) (:DEFINITION PACKN1*) (:EXECUTABLE-COUNTERPART CHARACTER-LISTP) (:EXECUTABLE-COUNTERPART CONSP) (:EXECUTABLE-COUNTERPART MEMBER-EQ) (:EXECUTABLE-COUNTERPART PACKN1*) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:FORWARD-CHAINING ATOM-LISTP-FORWARD-TO-TRUE-LISTP) (:FORWARD-CHAINING CHARACTER-LISTP-FORWARD-TO-EQLABLE-LISTP) (:FORWARD-CHAINING EQLABLE-LISTP-FORWARD-TO-ATOM-LISTP) (:INDUCTION GOOD-ATOM-LISTP) (:INDUCTION PACKN1*) (:REWRITE CAR-CONS) (:REWRITE CDR-CONS) (:REWRITE CHARACTER-LISTP-APPEND) (:REWRITE CHARACTER-LISTP-COERCE) (:REWRITE CHARACTER-LISTP-EXPLODE-ATOM) (:REWRITE TRUE-LISTP-EXPLODE-ATOM) (:TYPE-PRESCRIPTION ATOM-LISTP) (:TYPE-PRESCRIPTION CHARACTER-LISTP) (:TYPE-PRESCRIPTION EQLABLE-LISTP) (:TYPE-PRESCRIPTION PACKN1*)) Warnings: None Time: 0.02 seconds (prove: 0.02, print: 0.00, other: 0.00) GOOD-ATOM-LISTP-IMPLIES-CHARACTER-LISTP-PACKN1* ACL2 !>>(DEFUN PACKN* (LST) (DECLARE (XARGS :GUARD (GOOD-ATOM-LISTP LST))) (INTERN (COERCE (PACKN1* LST) 'STRING) "ACL2")) Since PACKN* is non-recursive, its admission is trivial. We observe that the type of PACKN* is described by the theorem (SYMBOLP (PACKN* LST)). We used the :type-prescription rule SYMBOLP-INTERN-IN-PACKAGE-OF-SYMBOL. The non-trivial part of the guard conjecture for PACKN*, given primitive type reasoning, is Goal (IMPLIES (GOOD-ATOM-LISTP LST) (CHARACTER-LISTP (PACKN1* LST))). But simplification reduces this to T, using the :rewrite rule GOOD- ATOM-LISTP-IMPLIES-CHARACTER-LISTP-PACKN1* and the :type-prescription rule GOOD-ATOM-LISTP. Q.E.D. That completes the proof of the guard theorem for PACKN*. PACKN* is compliant with Common Lisp. Summary Form: ( DEFUN PACKN* ...) Rules: ((:DEFINITION NOT) (:FAKE-RUNE-FOR-TYPE-SET NIL) (:REWRITE GOOD-ATOM-LISTP-IMPLIES-CHARACTER-LISTP-PACKN1*) (:TYPE-PRESCRIPTION GOOD-ATOM-LISTP) (:TYPE-PRESCRIPTION SYMBOLP-INTERN-IN-PACKAGE-OF-SYMBOL)) Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) PACKN* ACL2 !>>Bye. :EOF ACL2 !>Bye. Attempting to exit Lisp. If this fails to work, type :q and then try again. sundance:/u/www/users/moore/acl2/seminar/2006.02.15-kaufmann> acl2 GCL (GNU Common Lisp) 2.6.6 CLtL1 Jan 19 2005 20:24:14 Source License: LGPL(gcl,gmp), GPL(unexec,bfd) Binary License: GPL due to GPL'ed components: (BFD UNEXEC) Modifications of this banner must retain notice of a compatible license Dedicated to the memory of W. Schelter Use (help) to get some basic information on how to use GCL. ACL2 Version 2.9.4 built January 30, 2006 23:10:57. Copyright (C) 2006 University of Texas at Austin ACL2 comes with ABSOLUTELY NO WARRANTY. This is free software and you are welcome to redistribute it under certain conditions. For details, see the GNU General Public License. Initialized with (INITIALIZE-ACL2 'INCLUDE-BOOK *ACL2-PASS-2-FILES*). See the documentation topic note-2-9-4 for recent changes. Note: We have modified the prompt in some underlying Lisps to further distinguish it from the ACL2 prompt. NOTE!! Proof trees are disabled in ACL2. To enable them in emacs, look under the ACL2 source directory in interface/emacs/README.doc; and, to turn on proof trees, execute :START-PROOF-TREE in the ACL2 command loop. Look in the ACL2 documentation under PROOF-TREE. ACL2 Version 2.9.4. Level 1. Cbd "/v/filer2/moore/public_html/acl2/seminar/2006.02.15-kaufmann/". Type :help for help. Type (good-bye) to quit completely out of ACL2. ACL2 !>(encapsulate ((p1 (u x) t) (bad (x) t) (p2 (x y z) t) (bar (x y) t) (foo (x y) t) (poo (x y) t) (prop (u) t)) (local (defun p1 (u x) (declare (ignore u x)) nil)) (local (defun bad (x) (declare (ignore x)) nil)) (local (defun p2 (x y z) (declare (ignore x y z)) nil)) (local (defun bar (x y) (declare (ignore x y)) nil)) (local (defun foo (x y) (declare (ignore x y)) nil)) (local (defun poo (x y) (declare (ignore x y)) nil)) (local (defun prop (u) (declare (ignore u)) t)) (defthm foo-poo (implies (syntaxp (equal y 'y3)) (equal (foo x y) (poo x y)))) (defthm lemma-1 (implies (and (p1 u x) (bad x) (p2 x y z) (bar x y) (equal x x) ; admittedly silly! (foo x y)) (prop u)) :rule-classes ((:rewrite :match-free :all)))) To verify that the nine encapsulated events correctly extend the current theory we will evaluate them. The theory thus constructed is only ephemeral. Encapsulated Events: ACL2 !>>(LOCAL (DEFUN P1 (U X) (DECLARE (IGNORE U X)) NIL)) Since P1 is non-recursive, its admission is trivial. We observe that the type of P1 is described by the theorem (EQUAL (P1 U X) NIL). Summary Form: ( DEFUN P1 ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) P1 ACL2 !>>(LOCAL (DEFUN BAD (X) (DECLARE (IGNORE X)) NIL)) [SGC for 21 STRING pages..(8311 writable)..(T=2).GC finished] Since BAD is non-recursive, its admission is trivial. We observe that the type of BAD is described by the theorem (EQUAL (BAD X) NIL). Summary Form: ( DEFUN BAD ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) BAD ACL2 !>>(LOCAL (DEFUN P2 (X Y Z) (DECLARE (IGNORE X Y Z)) NIL)) [SGC for 21 STRING pages..(8312 writable)..(T=1).GC finished] Since P2 is non-recursive, its admission is trivial. We observe that the type of P2 is described by the theorem (EQUAL (P2 X Y Z) NIL). Summary Form: ( DEFUN P2 ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) P2 ACL2 !>>(LOCAL (DEFUN BAR (X Y) (DECLARE (IGNORE X Y)) NIL)) Since BAR is non-recursive, its admission is trivial. We observe that the type of BAR is described by the theorem (EQUAL (BAR X Y) NIL). Summary Form: ( DEFUN BAR ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) BAR ACL2 !>>(LOCAL (DEFUN FOO (X Y) (DECLARE (IGNORE X Y)) NIL)) Since FOO is non-recursive, its admission is trivial. We observe that the type of FOO is described by the theorem (EQUAL (FOO X Y) NIL). Summary Form: ( DEFUN FOO ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) FOO ACL2 !>>(LOCAL (DEFUN POO (X Y) (DECLARE (IGNORE X Y)) NIL)) Since POO is non-recursive, its admission is trivial. We observe that the type of POO is described by the theorem (EQUAL (POO X Y) NIL). Summary Form: ( DEFUN POO ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) POO ACL2 !>>(LOCAL (DEFUN PROP (U) (DECLARE (IGNORE U)) T)) Since PROP is non-recursive, its admission is trivial. We observe that the type of PROP is described by the theorem (PROP U). Summary Form: ( DEFUN PROP ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) PROP ACL2 !>>(DEFTHM FOO-POO (IMPLIES (SYNTAXP (EQUAL Y 'Y3)) (EQUAL (FOO X Y) (POO X Y)))) ACL2 Warning [Non-rec] in ( DEFTHM FOO-POO ...): A :REWRITE rule generated from FOO-POO will be triggered only by terms containing the non-recursive function symbol FOO. Unless this function is disabled, this rule is unlikely ever to be used. ACL2 Warning [Subsume] in ( DEFTHM FOO-POO ...): The previously added rule FOO subsumes a newly proposed :REWRITE rule generated from FOO- POO, in the sense that the old rule rewrites a more general target. Because the new rule will be tried first, it may nonetheless find application. But we reduce the conjecture to T, by primitive type reasoning and the :type-prescription rules FOO and POO. Q.E.D. Summary Form: ( DEFTHM FOO-POO ...) Rules: ((:FAKE-RUNE-FOR-TYPE-SET NIL) (:TYPE-PRESCRIPTION FOO) (:TYPE-PRESCRIPTION POO)) Warnings: Subsume and Non-rec Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) FOO-POO ACL2 !>>(DEFTHM LEMMA-1 (IMPLIES (AND (P1 U X) (BAD X) (P2 X Y Z) (BAR X Y) (EQUAL X X) (FOO X Y)) (PROP U)) :RULE-CLASSES ((:REWRITE :MATCH-FREE :ALL))) ACL2 Warning [Non-rec] in ( DEFTHM LEMMA-1 ...): A :REWRITE rule generated from LEMMA-1 will be triggered only by terms containing the non-recursive function symbol PROP. Unless this function is disabled, this rule is unlikely ever to be used. ACL2 Warning [Non-rec] in ( DEFTHM LEMMA-1 ...): As noted, we will instantiate the free variables, X, Z and Y, of a :REWRITE rule generated from LEMMA-1, by searching for the set of hypotheses shown above. However, these hypotheses mention the function symbols P1 and P2, which are defun'd non-recursively. Unless disabled, these function symbols are unlikely to occur in the conjecture being proved and hence the search for the required hypotheses will likely fail. ACL2 Warning [Subsume] in ( DEFTHM LEMMA-1 ...): The previously added rule PROP subsumes a newly proposed :REWRITE rule generated from LEMMA- 1, in the sense that the old rule rewrites a more general target. Because the new rule will be tried first, it may nonetheless find application. But we reduce the conjecture to T, by the :type-prescription rule P1. Q.E.D. The storage of LEMMA-1 depends upon the :type-prescription rule PROP. Summary Form: ( DEFTHM LEMMA-1 ...) Rules: ((:TYPE-PRESCRIPTION P1) (:TYPE-PRESCRIPTION PROP)) Warnings: Subsume and Non-rec Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) LEMMA-1 End of Encapsulated Events. Having verified that the encapsulated events validate the signatures of the ENCAPSULATE event, we discard the ephemeral theory and extend the original theory as directed by the signatures and the non-LOCAL events. The following constraint is associated with every one of the functions P1, BAD, P2, BAR, FOO, POO and PROP: (AND (IMPLIES (SYNTAXP (EQUAL Y 'Y3)) (EQUAL (FOO X Y) (POO X Y))) (IMPLIES (AND (P1 U X) (BAD X) (P2 X Y Z) (BAR X Y) (EQUAL X X) (FOO X Y)) (PROP U))) Summary Form: ( ENCAPSULATE ((P1 ...) ...) ...) Rules: NIL Warnings: Subsume and Non-rec Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01) T ACL2 !>(thm (implies (and (p1 u0 x1) (bad x1) (bad x3) (bar x3 y1) (bar x3 y3) (p1 u0 x2) (p1 u0 x3) (p2 x3 y1 z1) (p2 x3 y3 z1)) (prop u0))) Name the formula above *1. No induction schemes are suggested by *1. Consequently, the proof attempt has failed. Summary Form: ( THM ...) Rules: NIL Warnings: None Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00) ******** FAILED ******** See :DOC failure ******** FAILED ******** ACL2 !>:brr t The monitored runes are: NIL T ACL2 !>:monitor (:rewrite lemma-1) t (((:REWRITE LEMMA-1) 'T)) ACL2 !>(thm (implies (and (p1 u0 x1) (bad x1) (bad x3) (bar x3 y1) (bar x3 y3) (p1 u0 x2) (p1 u0 x3) (p2 x3 y1 z1) (p2 x3 y3 z1)) (prop u0))) (1 Breaking (:REWRITE LEMMA-1) on (PROP U0): 1 ACL2 >:target (PROP U0) 1 ACL2 >:path 1. Simplifying the clause ((NOT (P1 U0 X1)) (NOT (BAD X1)) (NOT (BAD X3)) (NOT (BAR X3 Y1)) (NOT (BAR X3 Y3)) (NOT (P1 U0 X2)) (NOT (P1 U0 X3)) (NOT (P2 X3 Y1 Z1)) (NOT (P2 X3 Y3 Z1)) (PROP U0)) 2. Rewriting (to simplify) the atom of the tenth literal, (PROP U0), 3. Attempting to apply (:REWRITE LEMMA-1) to (PROP U0) 1 ACL2 >:eval 1x (:REWRITE LEMMA-1) failed because :HYP 1 contains free variables. The following display summarizes the attempts to relieve hypotheses by binding free variables; see :DOC free-variables and see :DOC set- brr-term-evisc-tuple. [1] X : X1 Failed because :HYP 3 contains free variables Y and Z, for which no suitable bindings were found. [1] X : X2 Failed because :HYP 2 rewrote to (BAD X2). [1] X : X3 [3] Z : Z1 Y : Y1 Failed because :HYP 6 rewrote to (FOO X3 Y1). [3] Z : Z1 Y : Y3 Failed because :HYP 6 rewrote to (POO X3 Y3). 1 ACL2 >:failure-reason :HYP 1 contains free variables. The following display summarizes the attempts to relieve hypotheses by binding free variables; see :DOC free-variables and see :DOC set-brr-term-evisc-tuple. [1] X : X1 Failed because :HYP 3 contains free variables Y and Z, for which no suitable bindings were found. [1] X : X2 Failed because :HYP 2 rewrote to (BAD X2). [1] X : X3 [3] Z : Z1 Y : Y1 Failed because :HYP 6 rewrote to (FOO X3 Y1). [3] Z : Z1 Y : Y3 Failed because :HYP 6 rewrote to (POO X3 Y3). 1 ACL2 >(set-brr-term-evisc-tuple '(nil 2 2 nil)) 1 ACL2 >:failure-reason :HYP 1 contains free variables. The following display summarizes the attempts to relieve hypotheses by binding free variables; see :DOC free-variables and see :DOC set-brr-term-evisc-tuple. [1] X : X1 Failed because :HYP 3 contains free variables Y and Z, for which no suitable bindings were found. [1] X : X2 Failed because :HYP 2 rewrote to (BAD X2). [1] X : X3 [3] Z : Z1 Y : Y1 Failed because :HYP 6 rewrote to (FOO X3 ...). [3] Z : Z1 Y : Y3 Failed because :HYP 6 rewrote to (POO X3 ...). 1 ACL2 >(set-free-vars-display-limit 4) 1 ACL2 >:failure-reason :HYP 1 contains free variables. The following display summarizes the attempts to relieve hypotheses by binding free variables; see :DOC free-variables and see :DOC set-brr-term-evisc-tuple. [1] X : X1 Failed because :HYP 3 contains free variables Y and Z, for which no suitable bindings were found. [1] X : X2 Failed because :HYP 2 rewrote to (BAD X2). [1] X : X3 [3] Z : Z1 Y : Y1 Failed because :HYP 6 rewrote to (FOO X3 ...). [3] Z : Z1 Y : Y3 Failed because :HYP 6 rewrote to (POO X3 ...). 1 ACL2 >(set-free-vars-display-limit 2) 1 ACL2 >:failure-reason :HYP 1 contains free variables. The following display summarizes the attempts to relieve hypotheses by binding free variables; see :DOC free-variables and see :DOC set-brr-term-evisc-tuple. Also, if you want to avoid ``reasons elided'' notes below, then evaluate (assign free-vars-display-limit k) for larger k (currently 2, default 30); then :failure-reason will show the first k failure sub-reasons before eliding. Note that you may want to do this evaluation outside break-rewrite, so that it persists. [1] X : X1 Failed because :HYP 3 contains free variables Y and Z, for which no suitable bindings were found. [1] X : X2 Failed because :HYP 2 rewrote to (BAD X2). [1] X : X3 Failed because :HYP 3 contains free variables (further reasons elided, as noted above). 1 ACL2 >#. Here is the current pstack [see :DOC pstack]: (REWRITE-ATM SIMPLIFY-CLAUSE WATERFALL) Abort to ACL2 top-level ACL2 Version 2.9.4. Level 1. Cbd "/v/filer2/moore/public_html/acl2/seminar/2006.02.15-kaufmann/". Type :help for help. Type (good-bye) to quit completely out of ACL2. ACL2 !>