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 (G