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))