(NOTE-LIB "piton" T) Loading ./fm9001-piton/piton.lib Finished loading ./fm9001-piton/piton.lib Loading ./fm9001-piton/piton.o Loading ./fm9001-piton/0piton.o Finished loading ./fm9001-piton/0piton.o Loading ./fm9001-piton/1piton.o Finished loading ./fm9001-piton/1piton.o Loading ./fm9001-piton/2piton.o Finished loading ./fm9001-piton/2piton.o Loading ./fm9001-piton/3piton.o Finished loading ./fm9001-piton/3piton.o Loading ./fm9001-piton/4piton.o Finished loading ./fm9001-piton/4piton.o Loading ./fm9001-piton/5piton.o Finished loading ./fm9001-piton/5piton.o Finished loading ./fm9001-piton/piton.o (#./fm9001-piton/piton.lib #./fm9001-piton/piton) (ENABLE PLUS-0) [ 0.0 0.0 0.0 ] PLUS-0-ON5 (ENABLE COMMUTATIVITY-OF-PLUS) [ 0.0 0.0 0.0 ] COMMUTATIVITY-OF-PLUS-ON4 (ENABLE COMMUTATIVITY2-OF-PLUS) [ 0.0 0.0 0.0 ] COMMUTATIVITY2-OF-PLUS-ON2 (ENABLE ASSOCIATIVITY-OF-PLUS) [ 0.0 0.0 0.0 ] ASSOCIATIVITY-OF-PLUS-ON5 (PROVE-LEMMA PLUS-ADD1-1 (REWRITE) (EQUAL (PLUS (ADD1 X) Y) (ADD1 (PLUS X Y)))) WARNING: the previously added lemma, COMMUTATIVITY-OF-PLUS, could be applied whenever the newly proposed PLUS-ADD1-1 could! This conjecture simplifies, using linear arithmetic, to: T. Q.E.D. [ 0.0 0.0 0.0 ] PLUS-ADD1-1 (PROVE-LEMMA PLUS-ADD1-2 (REWRITE) (EQUAL (PLUS X (ADD1 Y)) (ADD1 (PLUS X Y)))) WARNING: the previously added lemma, COMMUTATIVITY-OF-PLUS, could be applied whenever the newly proposed PLUS-ADD1-2 could! This conjecture simplifies, using linear arithmetic, to: T. Q.E.D. [ 0.0 0.0 0.0 ] PLUS-ADD1-2 (ENABLE EQUAL-PLUS-0) [ 0.0 0.0 0.0 ] EQUAL-PLUS-0-ON2 (ENABLE TIMES-0) [ 0.0 0.0 0.0 ] TIMES-0-ON (ENABLE TIMES-ADD1) [ 0.0 0.0 0.0 ] TIMES-ADD1-ON1 (ENABLE TIMES-DISTRIBUTES-OVER-PLUS) [ 0.0 0.0 0.0 ] TIMES-DISTRIBUTES-OVER-PLUS-ON3 (ENABLE COMMUTATIVITY-OF-TIMES) [ 0.0 0.0 0.0 ] COMMUTATIVITY-OF-TIMES-ON1 (ENABLE COMMUTATIVITY2-OF-TIMES) [ 0.0 0.0 0.0 ] COMMUTATIVITY2-OF-TIMES-ON1 (ENABLE ASSOCIATIVITY-OF-TIMES) [ 0.0 0.0 0.0 ] ASSOCIATIVITY-OF-TIMES-ON3 (ENABLE EQUAL-TIMES-0) [ 0.0 0.0 0.0 ] EQUAL-TIMES-0-ON1 (ENABLE DIFFERENCE-ELIM) [ 0.0 0.0 0.0 ] DIFFERENCE-ELIM-ON3 (PROVE-LEMMA DIFFERENCE-ELIM-REWRITE1 (REWRITE) (IMPLIES (AND (NUMBERP X) (NOT (LESSP X Y))) (EQUAL (PLUS Y (DIFFERENCE X Y)) X))) WARNING: the previously added lemma, COMMUTATIVITY-OF-PLUS, could be applied whenever the newly proposed DIFFERENCE-ELIM-REWRITE1 could! This conjecture simplifies, using linear arithmetic, to: T. Q.E.D. [ 0.0 0.0 0.0 ] DIFFERENCE-ELIM-REWRITE1 (ENABLE LESSP-REMAINDER) [ 0.0 0.0 0.0 ] LESSP-REMAINDER-ON1 (PROVE-LEMMA LESSP-REMAINDER-LINEAR (REWRITE) (IMPLIES (NOT (ZEROP Y)) (LESSP (REMAINDER X Y) Y))) WARNING: Note that the proposed lemma LESSP-REMAINDER-LINEAR is to be stored as zero type prescription rules, zero compound recognizer rules, one linear rule, and zero replacement rules. This formula can be simplified, using the abbreviations ZEROP, NOT, and IMPLIES, to: (IMPLIES (AND (NOT (EQUAL Y 0)) (NUMBERP Y)) (LESSP (REMAINDER X Y) Y)), which simplifies, appealing to the lemma LESSP-REMAINDER, to: T. Q.E.D. [ 0.0 0.0 0.0 ] LESSP-REMAINDER-LINEAR (ENABLE REMAINDER-QUOTIENT-ELIM) [ 0.0 0.0 0.0 ] REMAINDER-QUOTIENT-ELIM-ON2 (ENABLE PLUS-REMAINDER-TIMES-QUOTIENT) [ 0.0 0.0 0.0 ] PLUS-REMAINDER-TIMES-QUOTIENT-ON (ENABLE LESSP-QUOTIENT) [ 0.0 0.0 0.0 ] LESSP-QUOTIENT-ON1 (PROVE-LEMMA LESSP-QUOTIENT-LINEAR (REWRITE) (IMPLIES (AND (NOT (ZEROP X)) (NOT (EQUAL Y 1))) (LESSP (QUOTIENT X Y) X))) WARNING: Note that the proposed lemma LESSP-QUOTIENT-LINEAR is to be stored as zero type prescription rules, zero compound recognizer rules, one linear rule, and zero replacement rules. This formula can be simplified, using the abbreviations ZEROP, NOT, AND, and IMPLIES, to the new conjecture: (IMPLIES (AND (NOT (EQUAL X 0)) (NUMBERP X) (NOT (EQUAL Y 1))) (LESSP (QUOTIENT X Y) X)), which simplifies, applying LESSP-QUOTIENT, to: T. Q.E.D. [ 0.0 0.0 0.0 ] LESSP-QUOTIENT-LINEAR (ENABLE NOT-LESSP-QUOTIENT) [ 0.0 0.0 0.0 ] NOT-LESSP-QUOTIENT-ON1 (PROVE-LEMMA NOT-LESSP-TIMES (REWRITE) (IMPLIES (NOT (ZEROP X)) (NOT (LESSP (TIMES X Y) Y)))) WARNING: Note that the proposed lemma NOT-LESSP-TIMES is to be stored as zero type prescription rules, zero compound recognizer rules, one linear rule, and zero replacement rules. This formula can be simplified, using the abbreviations ZEROP, NOT, and IMPLIES, to: (IMPLIES (AND (NOT (EQUAL X 0)) (NUMBERP X)) (NOT (LESSP (TIMES X Y) Y))), which we will name *1. We will appeal to induction. There are two plausible inductions. However, only one is unflawed. We will induct according to the following scheme: (AND (IMPLIES (ZEROP X) (p X Y)) (IMPLIES (AND (NOT (ZEROP X)) (p (SUB1 X) Y)) (p X Y))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP can be used to show that the measure (COUNT X) decreases according to the well-founded relation LESSP in each induction step of the scheme. The above induction scheme produces three new conjectures: Case 3. (IMPLIES (AND (ZEROP X) (NOT (EQUAL X 0)) (NUMBERP X)) (NOT (LESSP (TIMES X Y) Y))), which simplifies, opening up the definition of ZEROP, to: T. Case 2. (IMPLIES (AND (NOT (ZEROP X)) (EQUAL (SUB1 X) 0) (NOT (EQUAL X 0)) (NUMBERP X)) (NOT (LESSP (TIMES X Y) Y))), which simplifies, rewriting with EQUAL-TIMES-0 and PLUS-0, and opening up the functions ZEROP, TIMES, and EQUAL, to the following two new goals: Case 2.2. (IMPLIES (AND (EQUAL (SUB1 X) 0) (NOT (EQUAL X 0)) (NUMBERP X) (NOT (NUMBERP Y))) (NOT (LESSP 0 Y))). However this again simplifies, opening up the definition of LESSP, to: T. Case 2.1. (IMPLIES (AND (EQUAL (SUB1 X) 0) (NOT (EQUAL X 0)) (NUMBERP X) (NUMBERP Y)) (NOT (LESSP Y Y))), which again simplifies, using linear arithmetic, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP X)) (NOT (LESSP (TIMES (SUB1 X) Y) Y)) (NOT (EQUAL X 0)) (NUMBERP X)) (NOT (LESSP (TIMES X Y) Y))), which simplifies, opening up the definitions of ZEROP and TIMES, to the conjecture: (IMPLIES (AND (NOT (LESSP (TIMES (SUB1 X) Y) Y)) (NOT (EQUAL X 0)) (NUMBERP X)) (NOT (LESSP (PLUS Y (TIMES (SUB1 X) Y)) Y))). But this again simplifies, using linear arithmetic, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.0 ] NOT-LESSP-TIMES (DEFN NAT->BIGN (N BASE SIZE) (IF (ZEROP SIZE) NIL (CONS (TAG 'NAT (REMAINDER N BASE)) (NAT->BIGN (QUOTIENT N BASE) BASE (SUB1 SIZE))))) Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP establish that the measure (COUNT SIZE) decreases according to the well-founded relation LESSP in each recursive call. Hence, NAT->BIGN is accepted under the principle of definition. From the definition we can conclude that: (OR (LITATOM (NAT->BIGN N BASE SIZE)) (LISTP (NAT->BIGN N BASE SIZE))) is a theorem. [ 0.0 0.0 0.0 ] NAT->BIGN (DEFN BIGN->NAT (A BASE) (IF (NLISTP A) 0 (PLUS (UNTAG (CAR A)) (TIMES BASE (BIGN->NAT (CDR A) BASE))))) Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP establish that the measure (COUNT A) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIGN->NAT is accepted under the principle of definition. From the definition we can conclude that (NUMBERP (BIGN->NAT A BASE)) is a theorem. [ 0.0 0.0 0.0 ] BIGN->NAT (DEFN BIGNP (A BASE) (IF (NLISTP A) (EQUAL A NIL) (AND (LISTP (CAR A)) (EQUAL (TYPE (CAR A)) 'NAT) (NUMBERP (UNTAG (CAR A))) (LESSP (UNTAG (CAR A)) BASE) (EQUAL (CDDR (CAR A)) NIL) (BIGNP (CDR A) BASE)))) Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP establish that the measure (COUNT A) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIGNP is accepted under the definitional principle. Observe that: (OR (FALSEP (BIGNP A BASE)) (TRUEP (BIGNP A BASE))) is a theorem. [ 0.0 0.0 0.0 ] BIGNP (PROVE-LEMMA BIGNP-NAT->BIGN (REWRITE) (IMPLIES (NOT (ZEROP BASE)) (BIGNP (NAT->BIGN N BASE SIZE) BASE))) This conjecture can be simplified, using the abbreviations ZEROP, NOT, and IMPLIES, to: (IMPLIES (AND (NOT (EQUAL BASE 0)) (NUMBERP BASE)) (BIGNP (NAT->BIGN N BASE SIZE) BASE)). Give the above formula the name *1. Perhaps we can prove it by induction. There is only one plausible induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP SIZE) (p N BASE SIZE)) (IMPLIES (AND (NOT (ZEROP SIZE)) (p (QUOTIENT N BASE) BASE (SUB1 SIZE))) (p N BASE SIZE))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT SIZE) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for N. The above induction scheme produces the following two new conjectures: Case 2. (IMPLIES (AND (ZEROP SIZE) (NOT (EQUAL BASE 0)) (NUMBERP BASE)) (BIGNP (NAT->BIGN N BASE SIZE) BASE)). This simplifies, expanding the functions ZEROP, EQUAL, NAT->BIGN, LISTP, and BIGNP, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP SIZE)) (BIGNP (NAT->BIGN (QUOTIENT N BASE) BASE (SUB1 SIZE)) BASE) (NOT (EQUAL BASE 0)) (NUMBERP BASE)) (BIGNP (NAT->BIGN N BASE SIZE) BASE)). This simplifies, applying LESSP-REMAINDER, CDR-CONS, and CAR-CONS, and opening up the definitions of ZEROP, NAT->BIGN, TAG, UNTAG, EQUAL, TYPE, and BIGNP, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.0 ] BIGNP-NAT->BIGN (PROVE-LEMMA LENGTH-NAT->BIGN (REWRITE) (IMPLIES (NOT (ZEROP BASE)) (EQUAL (LENGTH (NAT->BIGN N BASE SIZE)) (FIX SIZE)))) This conjecture can be simplified, using the abbreviations ZEROP, NOT, and IMPLIES, to the goal: (IMPLIES (AND (NOT (EQUAL BASE 0)) (NUMBERP BASE)) (EQUAL (LENGTH (NAT->BIGN N BASE SIZE)) (FIX SIZE))). This simplifies, opening up the definition of FIX, to the following two new goals: Case 2. (IMPLIES (AND (NOT (EQUAL BASE 0)) (NUMBERP BASE) (NOT (NUMBERP SIZE))) (EQUAL (LENGTH (NAT->BIGN N BASE SIZE)) 0)). However this again simplifies, expanding NAT->BIGN, LENGTH, and EQUAL, to: T. Case 1. (IMPLIES (AND (NOT (EQUAL BASE 0)) (NUMBERP BASE) (NUMBERP SIZE)) (EQUAL (LENGTH (NAT->BIGN N BASE SIZE)) SIZE)), which we will name *1. Perhaps we can prove it by induction. There is only one plausible induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP SIZE) (p N BASE SIZE)) (IMPLIES (AND (NOT (ZEROP SIZE)) (p (QUOTIENT N BASE) BASE (SUB1 SIZE))) (p N BASE SIZE))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT SIZE) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for N. The above induction scheme produces the following two new goals: Case 2. (IMPLIES (AND (ZEROP SIZE) (NOT (EQUAL BASE 0)) (NUMBERP BASE) (NUMBERP SIZE)) (EQUAL (LENGTH (NAT->BIGN N BASE SIZE)) SIZE)). This simplifies, expanding the definitions of ZEROP, NUMBERP, EQUAL, NAT->BIGN, and LENGTH, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP SIZE)) (EQUAL (LENGTH (NAT->BIGN (QUOTIENT N BASE) BASE (SUB1 SIZE))) (SUB1 SIZE)) (NOT (EQUAL BASE 0)) (NUMBERP BASE) (NUMBERP SIZE)) (EQUAL (LENGTH (NAT->BIGN N BASE SIZE)) SIZE)). This simplifies, appealing to the lemmas ADD1-SUB1 and CDR-CONS, and expanding the functions ZEROP, NAT->BIGN, TAG, and LENGTH, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.0 ] LENGTH-NAT->BIGN (PROVE-LEMMA LESSP-QUOTIENT-TIMES (REWRITE) (IMPLIES (LESSP N (TIMES B E)) (EQUAL (LESSP (QUOTIENT N B) E) T))) . Appealing to the lemma REMAINDER-QUOTIENT-ELIM, we now replace N by (PLUS Z (TIMES B X)) to eliminate (QUOTIENT N B) and (REMAINDER N B). We employ LESSP-REMAINDER, the type restriction lemma noted when QUOTIENT was introduced, and the type restriction lemma noted when REMAINDER was introduced to constrain the new variables. The result is four new formulas: Case 4. (IMPLIES (AND (NOT (NUMBERP N)) (LESSP N (TIMES B E))) (LESSP (QUOTIENT N B) E)), which further simplifies, appealing to the lemma EQUAL-TIMES-0, and opening up the definitions of LESSP, QUOTIENT, and EQUAL, to: T. Case 3. (IMPLIES (AND (EQUAL B 0) (LESSP N (TIMES B E))) (LESSP (QUOTIENT N B) E)), which further simplifies, using linear arithmetic, to: T. Case 2. (IMPLIES (AND (NOT (NUMBERP B)) (LESSP N (TIMES B E))) (LESSP (QUOTIENT N B) E)), which further simplifies, expanding the definitions of TIMES, EQUAL, and LESSP, to: T. Case 1. (IMPLIES (AND (NUMBERP X) (NUMBERP Z) (EQUAL (LESSP Z B) (NOT (ZEROP B))) (NUMBERP B) (NOT (EQUAL B 0)) (LESSP (PLUS Z (TIMES B X)) (TIMES B E))) (LESSP X E)), which further simplifies, expanding the functions ZEROP and NOT, to: (IMPLIES (AND (NUMBERP X) (NUMBERP Z) (LESSP Z B) (NUMBERP B) (NOT (EQUAL B 0)) (LESSP (PLUS Z (TIMES B X)) (TIMES B E))) (LESSP X E)), which we would usually push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it. So now let us consider: (IMPLIES (LESSP N (TIMES B E)) (EQUAL (LESSP (QUOTIENT N B) E) T)), which we named *1 above. We will appeal to induction. There are four plausible inductions, two of which are unflawed. So we will choose the one suggested by the largest number of nonprimitive recursive functions. We will induct according to the following scheme: (AND (IMPLIES (ZEROP B) (p N B E)) (IMPLIES (AND (NOT (ZEROP B)) (LESSP N B)) (p N B E)) (IMPLIES (AND (NOT (ZEROP B)) (NOT (LESSP N B)) (p (DIFFERENCE N B) B E)) (p N B E))). Linear arithmetic, the lemmas COUNT-NUMBERP and COUNT-NOT-LESSP, and the definition of ZEROP can be used to establish that the measure (COUNT N) decreases according to the well-founded relation LESSP in each induction step of the scheme. The above induction scheme produces four new goals: Case 4. (IMPLIES (AND (ZEROP B) (LESSP N (TIMES B E))) (EQUAL (LESSP (QUOTIENT N B) E) T)), which simplifies, expanding the definitions of ZEROP, EQUAL, TIMES, and LESSP, to: T. Case 3. (IMPLIES (AND (NOT (ZEROP B)) (LESSP N B) (LESSP N (TIMES B E))) (EQUAL (LESSP (QUOTIENT N B) E) T)), which simplifies, expanding the definitions of ZEROP, QUOTIENT, EQUAL, and LESSP, to two new conjectures: Case 3.2. (IMPLIES (AND (NOT (EQUAL B 0)) (NUMBERP B) (LESSP N B) (LESSP N (TIMES B E))) (NOT (EQUAL E 0))), which again simplifies, applying TIMES-0, and opening up the functions ZEROP, EQUAL, and LESSP, to: T. Case 3.1. (IMPLIES (AND (NOT (EQUAL B 0)) (NUMBERP B) (LESSP N B) (LESSP N (TIMES B E))) (NUMBERP E)). But this again simplifies, applying the lemma TIMES-0, and expanding the definitions of ZEROP, EQUAL, and LESSP, to: T. Case 2. (IMPLIES (AND (NOT (ZEROP B)) (NOT (LESSP N B)) (NOT (LESSP (DIFFERENCE N B) (TIMES B E))) (LESSP N (TIMES B E))) (EQUAL (LESSP (QUOTIENT N B) E) T)), which simplifies, using linear arithmetic, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP B)) (NOT (LESSP N B)) (EQUAL (LESSP (QUOTIENT (DIFFERENCE N B) B) E) T) (LESSP N (TIMES B E))) (EQUAL (LESSP (QUOTIENT N B) E) T)), which simplifies, appealing to the lemma SUB1-ADD1, and expanding the definitions of ZEROP, QUOTIENT, and LESSP, to three new goals: Case 1.3. (IMPLIES (AND (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP N B)) (LESSP (QUOTIENT (DIFFERENCE N B) B) E) (LESSP N (TIMES B E))) (NOT (EQUAL E 0))), which again simplifies, using linear arithmetic, to: T. Case 1.2. (IMPLIES (AND (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP N B)) (LESSP (QUOTIENT (DIFFERENCE N B) B) E) (LESSP N (TIMES B E))) (NUMBERP E)), which again simplifies, using linear arithmetic, rewriting with NOT-LESSP-TIMES and TIMES-0, and opening up ZEROP, to: T. Case 1.1. (IMPLIES (AND (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP N B)) (LESSP (QUOTIENT (DIFFERENCE N B) B) E) (LESSP N (TIMES B E))) (LESSP (QUOTIENT (DIFFERENCE N B) B) (SUB1 E))). This again simplifies, using linear arithmetic, to two new formulas: Case 1.1.2. (IMPLIES (AND (NOT (NUMBERP E)) (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP N B)) (LESSP (QUOTIENT (DIFFERENCE N B) B) E) (LESSP N (TIMES B E))) (LESSP (QUOTIENT (DIFFERENCE N B) B) (SUB1 E))), which again simplifies, using linear arithmetic, applying NOT-LESSP-TIMES and TIMES-0, and unfolding the definition of ZEROP, to: T. Case 1.1.1. (IMPLIES (AND (NUMBERP E) (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP N B)) (LESSP (QUOTIENT (DIFFERENCE N B) B) (PLUS 1 (QUOTIENT (DIFFERENCE N B) B))) (LESSP N (TIMES B (PLUS 1 (QUOTIENT (DIFFERENCE N B) B))))) (LESSP (QUOTIENT (DIFFERENCE N B) B) (SUB1 (PLUS 1 (QUOTIENT (DIFFERENCE N B) B))))). However this again simplifies, appealing to the lemmas PLUS-0, PLUS-ADD1-1, SUB1-ADD1, EQUAL-TIMES-0, COMMUTATIVITY-OF-TIMES, and TIMES-ADD1, and unfolding ZEROP, LESSP, PLUS, SUB1, NUMBERP, EQUAL, and TIMES, to: (IMPLIES (AND (NUMBERP E) (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP N B)) (LESSP (SUB1 (QUOTIENT (DIFFERENCE N B) B)) (QUOTIENT (DIFFERENCE N B) B)) (LESSP N (PLUS B (TIMES B (QUOTIENT (DIFFERENCE N B) B))))) (LESSP (QUOTIENT (DIFFERENCE N B) B) (QUOTIENT (DIFFERENCE N B) B))). Appealing to the lemmas DIFFERENCE-ELIM, REMAINDER-QUOTIENT-ELIM, and SUB1-ELIM, we now replace N by (PLUS B X) to eliminate (DIFFERENCE N B), X by (PLUS V (TIMES B Z)) to eliminate (QUOTIENT X B) and (REMAINDER X B), and Z by (ADD1 X) to eliminate (SUB1 Z). We employ the type restriction lemma noted when DIFFERENCE was introduced, LESSP-REMAINDER, the type restriction lemma noted when QUOTIENT was introduced, the type restriction lemma noted when REMAINDER was introduced, and the type restriction lemma noted when SUB1 was introduced to constrain the new variables. The result is three new conjectures: Case 1.1.1.3. (IMPLIES (AND (NOT (NUMBERP N)) (NUMBERP E) (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP N B)) (LESSP (SUB1 (QUOTIENT (DIFFERENCE N B) B)) (QUOTIENT (DIFFERENCE N B) B)) (LESSP N (PLUS B (TIMES B (QUOTIENT (DIFFERENCE N B) B))))) (LESSP (QUOTIENT (DIFFERENCE N B) B) (QUOTIENT (DIFFERENCE N B) B))), which further simplifies, opening up the function LESSP, to: T. Case 1.1.1.2. (IMPLIES (AND (EQUAL Z 0) (NUMBERP Z) (NUMBERP V) (EQUAL (LESSP V B) (NOT (ZEROP B))) (NUMBERP E) (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP (PLUS B V (TIMES B Z)) B)) (LESSP (SUB1 Z) Z) (LESSP (PLUS B V (TIMES B Z)) (PLUS B (TIMES B Z)))) (LESSP Z Z)), which further simplifies, using linear arithmetic, to: T. Case 1.1.1.1. (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (NUMBERP V) (EQUAL (LESSP V B) (NOT (ZEROP B))) (NUMBERP E) (NOT (EQUAL B 0)) (NUMBERP B) (NOT (LESSP (PLUS B V (TIMES B (ADD1 X))) B)) (LESSP X (ADD1 X)) (LESSP (PLUS B V (TIMES B (ADD1 X))) (PLUS B (TIMES B (ADD1 X))))) (LESSP (ADD1 X) (ADD1 X))), which further simplifies, using linear arithmetic, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.1 0.1 ] LESSP-QUOTIENT-TIMES (PROVE-LEMMA BIGN->NAT->BIGN (REWRITE) (IMPLIES (AND (NUMBERP N) (LESSP 1 BASE) (LESSP N (EXP BASE SIZE))) (EQUAL (BIGN->NAT (NAT->BIGN N BASE SIZE) BASE) N))) Call the conjecture *1. Let us appeal to the induction principle. Four inductions are suggested by terms in the conjecture. They merge into three likely candidate inductions. However, only one is unflawed. We will induct according to the following scheme: (AND (IMPLIES (ZEROP SIZE) (p N BASE SIZE)) (IMPLIES (AND (NOT (ZEROP SIZE)) (p (QUOTIENT N BASE) BASE (SUB1 SIZE))) (p N BASE SIZE))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP establish that the measure (COUNT SIZE) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for N. The above induction scheme produces three new goals: Case 3. (IMPLIES (AND (ZEROP SIZE) (NUMBERP N) (LESSP 1 BASE) (LESSP N (EXP BASE SIZE))) (EQUAL (BIGN->NAT (NAT->BIGN N BASE SIZE) BASE) N)), which simplifies, unfolding the functions ZEROP, EQUAL, EXP, NAT->BIGN, LISTP, and BIGN->NAT, to two new goals: Case 3.2. (IMPLIES (AND (EQUAL SIZE 0) (NUMBERP N) (LESSP 1 BASE) (LESSP N 1)) (EQUAL 0 N)), which again simplifies, using linear arithmetic, to: T. Case 3.1. (IMPLIES (AND (NOT (NUMBERP SIZE)) (NUMBERP N) (LESSP 1 BASE) (LESSP N 1)) (EQUAL 0 N)), which again simplifies, using linear arithmetic, to: T. Case 2. (IMPLIES (AND (NOT (ZEROP SIZE)) (NOT (LESSP (QUOTIENT N BASE) (EXP BASE (SUB1 SIZE)))) (NUMBERP N) (LESSP 1 BASE) (LESSP N (EXP BASE SIZE))) (EQUAL (BIGN->NAT (NAT->BIGN N BASE SIZE) BASE) N)), which simplifies, applying CDR-CONS and CAR-CONS, and opening up the functions ZEROP, EXP, NAT->BIGN, TAG, UNTAG, and BIGN->NAT, to: (IMPLIES (AND (NOT (EQUAL SIZE 0)) (NUMBERP SIZE) (NOT (LESSP (QUOTIENT N BASE) (EXP BASE (SUB1 SIZE)))) (NUMBERP N) (LESSP 1 BASE) (LESSP N (TIMES BASE (EXP BASE (SUB1 SIZE))))) (EQUAL (PLUS (REMAINDER N BASE) (TIMES BASE (BIGN->NAT (NAT->BIGN (QUOTIENT N BASE) BASE (SUB1 SIZE)) BASE))) N)), which again simplifies, applying LESSP-QUOTIENT-TIMES, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP SIZE)) (EQUAL (BIGN->NAT (NAT->BIGN (QUOTIENT N BASE) BASE (SUB1 SIZE)) BASE) (QUOTIENT N BASE)) (NUMBERP N) (LESSP 1 BASE) (LESSP N (EXP BASE SIZE))) (EQUAL (BIGN->NAT (NAT->BIGN N BASE SIZE) BASE) N)). This simplifies, appealing to the lemmas PLUS-REMAINDER-TIMES-QUOTIENT, CDR-CONS, and CAR-CONS, and opening up the functions ZEROP, EXP, NAT->BIGN, TAG, UNTAG, and BIGN->NAT, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.1 0.0 ] BIGN->NAT->BIGN (DEFN TV->NAT (C) (IF C 1 0)) Note that (NUMBERP (TV->NAT C)) is a theorem. [ 0.0 0.0 0.0 ] TV->NAT (DEFN BIG-ADD-ARRAY (A B C BASE) (IF (NLISTP A) NIL (CONS (TAG 'NAT (REMAINDER (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)))) Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP can be used to establish that the measure (COUNT A) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIG-ADD-ARRAY is accepted under the definitional principle. Observe that: (OR (LITATOM (BIG-ADD-ARRAY A B C BASE)) (LISTP (BIG-ADD-ARRAY A B C BASE))) is a theorem. [ 0.0 0.0 0.0 ] BIG-ADD-ARRAY (DEFN BIG-ADD-CARRY-OUT (A B C BASE) (IF (NLISTP A) (BOOL C) (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE))) Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP establish that the measure (COUNT A) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIG-ADD-CARRY-OUT is accepted under the definitional principle. Note that: (LISTP (BIG-ADD-CARRY-OUT A B C BASE)) is a theorem. [ 0.0 0.0 0.0 ] BIG-ADD-CARRY-OUT (ENABLE DIFFERENCE-X-X) [ 0.0 0.0 0.0 ] DIFFERENCE-X-X-ON3 (PROVE-LEMMA REMAINDER-CARRYOUT1 (REWRITE) (IMPLIES (AND (LESSP I BASE) (LESSP J BASE) (NOT (LESSP (ADD1 (PLUS I J)) BASE))) (EQUAL (REMAINDER (ADD1 (PLUS I J)) BASE) (DIFFERENCE (ADD1 (PLUS I J)) BASE))) ((EXPAND (REMAINDER (ADD1 (PLUS I J)) BASE) (REMAINDER (DIFFERENCE (PLUS I J) (SUB1 BASE)) BASE)))) This conjecture simplifies, appealing to the lemma SUB1-ADD1, and opening up LESSP, EQUAL, REMAINDER, and DIFFERENCE, to the formula: (IMPLIES (AND (LESSP I BASE) (LESSP J BASE) (NOT (LESSP (PLUS I J) (SUB1 BASE))) (NOT (EQUAL BASE 0)) (NUMBERP BASE) (NOT (LESSP (DIFFERENCE (PLUS I J) (SUB1 BASE)) BASE))) (EQUAL (REMAINDER (DIFFERENCE (DIFFERENCE (PLUS I J) (SUB1 BASE)) BASE) BASE) (DIFFERENCE (PLUS I J) (SUB1 BASE)))). This again simplifies, using linear arithmetic, to: T. Q.E.D. [ 0.0 0.0 0.0 ] REMAINDER-CARRYOUT1 (PROVE-LEMMA REMAINDER-CARRYOUT0 (REWRITE) (IMPLIES (AND (LESSP I BASE) (LESSP J BASE) (NOT (LESSP (PLUS I J) BASE))) (EQUAL (REMAINDER (PLUS I J) BASE) (DIFFERENCE (PLUS I J) BASE))) ((EXPAND (REMAINDER (PLUS I J) BASE) (REMAINDER (DIFFERENCE (PLUS I J) BASE) BASE)))) This conjecture simplifies, opening up the function REMAINDER, to three new formulas: Case 3. (IMPLIES (AND (LESSP I BASE) (LESSP J BASE) (NOT (LESSP (PLUS I J) BASE)) (NOT (EQUAL BASE 0)) (NUMBERP BASE) (NOT (LESSP (DIFFERENCE (PLUS I J) BASE) BASE))) (EQUAL (REMAINDER (DIFFERENCE (DIFFERENCE (PLUS I J) BASE) BASE) BASE) (DIFFERENCE (PLUS I J) BASE))), which again simplifies, using linear arithmetic, to: T. Case 2. (IMPLIES (AND (LESSP I BASE) (LESSP J BASE) (NOT (LESSP (PLUS I J) BASE)) (EQUAL BASE 0)) (EQUAL (PLUS I J) (DIFFERENCE (PLUS I J) BASE))), which again simplifies, using linear arithmetic, to: T. Case 1. (IMPLIES (AND (LESSP I BASE) (LESSP J BASE) (NOT (LESSP (PLUS I J) BASE)) (NOT (NUMBERP BASE))) (EQUAL (PLUS I J) (DIFFERENCE (PLUS I J) BASE))), which again simplifies, unfolding the function LESSP, to: T. Q.E.D. [ 0.0 0.0 0.0 ] REMAINDER-CARRYOUT0 (PROVE-LEMMA INTERPRETATION-OF-BIG-ADD-RESULTS NIL (IMPLIES (AND (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))) ((DISABLE LESSP))) This conjecture can be simplified, using the abbreviations AND, IMPLIES, UNTAG, and TAG, to the formula: (IMPLIES (AND (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (LIST 'NAT (BOOL-TO-NAT (CADR (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))). This simplifies, applying COMMUTATIVITY-OF-PLUS and COMMUTATIVITY2-OF-PLUS, and opening up the functions BOOL-TO-NAT and TV->NAT, to four new formulas: Case 4. (IMPLIES (AND (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE) (NOT C) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B C BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) '((NAT 1))) BASE) (PLUS 0 (BIGN->NAT A BASE) (BIGN->NAT B BASE)))), which again simplifies, rewriting with the lemma PLUS-0, and expanding ZEROP, to the formula: (IMPLIES (AND (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE)))). Name the above subgoal *1. Case 3. (IMPLIES (AND (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE) (NOT C) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B C BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) '((NAT 0))) BASE) (PLUS 0 (BIGN->NAT A BASE) (BIGN->NAT B BASE)))). But this again simplifies, rewriting with PLUS-0, and expanding ZEROP, to: (IMPLIES (AND (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE)))), which we would normally push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it. So now let us return to: (IMPLIES (AND (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))). We named this *1. We will try to prove it by induction. Eight inductions are suggested by terms in the conjecture. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (NLISTP A) (p A B C BASE)) (IMPLIES (AND (NOT (NLISTP A)) (p (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) (p A B C BASE))). Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP can be used to establish that the measure (COUNT A) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instances chosen for B and C. The above induction scheme generates the following five new goals: Case 5. (IMPLIES (AND (NLISTP A) (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))). This simplifies, appealing to the lemmas CDR-CONS, CAR-CONS, TIMES-0, and PLUS-0, and unfolding the functions NLISTP, BIGNP, TYPE, UNTAG, LENGTH, EQUAL, LISTP, BIG-ADD-ARRAY, BOOL, TAG, BIG-ADD-CARRY-OUT, BOOL-TO-NAT, APPEND, BIGN->NAT, ZEROP, and TV->NAT, to the following two new conjectures: Case 5.2. (IMPLIES (AND (NOT (LISTP A)) (EQUAL A NIL) (NOT (LISTP B)) (EQUAL B NIL) (NUMBERP BASE) (LESSP 1 BASE) (NOT C)) (EQUAL (CADR '(BOOL F)) 'F)). This again simplifies, opening up the functions LISTP, CDR, CAR, and EQUAL, to: T. Case 5.1. (IMPLIES (AND (NOT (LISTP A)) (EQUAL A NIL) (NOT (LISTP B)) (EQUAL B NIL) (NUMBERP BASE) (LESSP 1 BASE) C) (NOT (EQUAL (CADR '(BOOL T)) 'F))), which again simplifies, expanding LISTP, CDR, CAR, and EQUAL, to: T. Case 4. (IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR A) BASE)) (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))), which simplifies, expanding NLISTP, BIGNP, TYPE, and UNTAG, to: T. Case 3. (IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR B) BASE)) (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))), which simplifies, opening up the definitions of NLISTP, BIGNP, TYPE, UNTAG, and LENGTH, to: T. Case 2. (IMPLIES (AND (NOT (NLISTP A)) (NOT (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B)))) (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))), which simplifies, applying ADD1-EQUAL, and expanding the functions NLISTP, BIGNP, TYPE, UNTAG, and LENGTH, to: T. Case 1. (IMPLIES (AND (NOT (NLISTP A)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)))))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) (TV->NAT (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE))))) (BIGNP A BASE) (BIGNP B BASE) (EQUAL (LENGTH A) (LENGTH B)) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (BOOL-TO-NAT (UNTAG (BIG-ADD-CARRY-OUT A B C BASE)))))) BASE) (PLUS (BIGN->NAT A BASE) (BIGN->NAT B BASE) (TV->NAT C)))). This simplifies, applying ADD1-EQUAL, PLUS-0, PLUS-ADD1-2, SUB1-ADD1, REMAINDER-CARRYOUT1, COMMUTATIVITY2-OF-PLUS, and ASSOCIATIVITY-OF-PLUS, and opening up the functions NLISTP, UNTAG, BOOL-TO-NAT, TAG, TV->NAT, NOT, BIGNP, TYPE, LENGTH, BIG-ADD-ARRAY, ZEROP, REMAINDER, DIFFERENCE, BIG-ADD-CARRY-OUT, and BIGN->NAT, to 32 new formulas: Case 1.32. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.31. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.30. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.29. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, rewriting with PLUS-0, PLUS-ADD1-2, CDR-CONS, and CAR-CONS, and unfolding the functions ZEROP, APPEND, UNTAG, and BIGN->NAT, to the new formula: (IMPLIES (AND (LISTP A) C (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (PLUS (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE)) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 1))) BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which further simplifies, rewriting with PLUS-0, PLUS-ADD1-2, TIMES-DISTRIBUTES-OVER-PLUS, TIMES-ADD1, COMMUTATIVITY-OF-PLUS, and COMMUTATIVITY2-OF-PLUS, and opening up UNTAG, TV->NAT, ZEROP, and NOT, to: (IMPLIES (AND (LISTP A) C (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 1))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (PLUS BASE (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)) (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP (PLUS (CADAR A) (CADAR B)) (SUB1 BASE)) (LISTP A) C (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 1))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (PLUS BASE (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)) (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). However this again simplifies, using linear arithmetic, to: T. Case 1.28. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.27. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, appealing to the lemmas PLUS-0, PLUS-ADD1-2, CDR-CONS, and CAR-CONS, and unfolding the functions ZEROP, APPEND, UNTAG, and BIGN->NAT, to the conjecture: (IMPLIES (AND (LISTP A) C (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (PLUS (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE)) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 0))) BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). However this further simplifies, rewriting with the lemmas PLUS-0 and PLUS-ADD1-2, and expanding the functions UNTAG, TV->NAT, ZEROP, NOT, and EQUAL, to: T. Case 1.26. (IMPLIES (AND (LISTP A) (NOT C) (NOT (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, rewriting with PLUS-0 and PLUS-ADD1-2, and opening up the functions ZEROP, UNTAG, TV->NAT, and NOT, to the new goal: (IMPLIES (AND (LISTP A) (NOT (LESSP (PLUS (CADAR A) (CADAR B)) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 1))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, applying the lemmas PLUS-0, REMAINDER-CARRYOUT0, CDR-CONS, CAR-CONS, COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, TIMES-ADD1, and TIMES-DISTRIBUTES-OVER-PLUS, and expanding the definitions of ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, TAG, BIG-ADD-ARRAY, APPEND, and BIGN->NAT, to the formula: (IMPLIES (AND (LISTP A) (NOT (LESSP (PLUS (CADAR A) (CADAR B)) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 1))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (PLUS BASE (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)) (DIFFERENCE (PLUS (CADAR A) (CADAR B)) BASE)) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))). This again simplifies, using linear arithmetic, to: T. Case 1.25. (IMPLIES (AND (LISTP A) (NOT C) (NOT (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, appealing to the lemmas PLUS-0 and PLUS-ADD1-2, and expanding ZEROP, UNTAG, TV->NAT, and NOT, to the goal: (IMPLIES (AND (LISTP A) (NOT (LESSP (PLUS (CADAR A) (CADAR B)) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 1))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))). But this again simplifies, rewriting with the lemma PLUS-0, and expanding ZEROP, TV->NAT, UNTAG, and BIG-ADD-CARRY-OUT, to: T. Case 1.24. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.23. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.22. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.21. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, appealing to the lemmas PLUS-0, PLUS-ADD1-2, CDR-CONS, and CAR-CONS, and opening up the functions ZEROP, APPEND, UNTAG, and BIGN->NAT, to: (IMPLIES (AND (LISTP A) C (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (PLUS (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE)) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 1))) BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). This further simplifies, rewriting with PLUS-0 and PLUS-ADD1-2, and expanding the definitions of UNTAG, TV->NAT, ZEROP, and NOT, to: T. Case 1.20. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). This again simplifies, using linear arithmetic, to: T. Case 1.19. (IMPLIES (AND (LISTP A) C (NOT (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, applying PLUS-0, PLUS-ADD1-2, CDR-CONS, and CAR-CONS, and unfolding the definitions of ZEROP, APPEND, UNTAG, and BIGN->NAT, to the new conjecture: (IMPLIES (AND (LISTP A) C (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (PLUS (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE)) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 0))) BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which further simplifies, rewriting with the lemmas PLUS-0, PLUS-ADD1-2, TIMES-DISTRIBUTES-OVER-PLUS, TIMES-ADD1, COMMUTATIVITY-OF-PLUS, and COMMUTATIVITY2-OF-PLUS, and opening up UNTAG, TV->NAT, ZEROP, NOT, and EQUAL, to: (IMPLIES (AND (LISTP A) C (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 0))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (PLUS BASE (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)) (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). However this again simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP (PLUS (CADAR A) (CADAR B)) (SUB1 BASE)) (LISTP A) C (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 0))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (PLUS BASE (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)) (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). But this again simplifies, using linear arithmetic, to: T. Case 1.18. (IMPLIES (AND (LISTP A) (NOT C) (NOT (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, applying PLUS-0 and PLUS-ADD1-2, and unfolding the definitions of ZEROP, UNTAG, TV->NAT, and NOT, to the new formula: (IMPLIES (AND (LISTP A) (NOT (LESSP (PLUS (CADAR A) (CADAR B)) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 0))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, rewriting with PLUS-0, and opening up the definitions of ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, and EQUAL, to: T. Case 1.17. (IMPLIES (AND (LISTP A) (NOT C) (NOT (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 1)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))). However this again simplifies, rewriting with PLUS-0 and PLUS-ADD1-2, and opening up the definitions of ZEROP, UNTAG, TV->NAT, and NOT, to the new goal: (IMPLIES (AND (LISTP A) (NOT (LESSP (PLUS (CADAR A) (CADAR B)) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 0))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, rewriting with PLUS-0, REMAINDER-CARRYOUT0, CDR-CONS, CAR-CONS, COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, TIMES-ADD1, and TIMES-DISTRIBUTES-OVER-PLUS, and expanding ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, EQUAL, TAG, BIG-ADD-ARRAY, APPEND, and BIGN->NAT, to: (IMPLIES (AND (LISTP A) (NOT (LESSP (PLUS (CADAR A) (CADAR B)) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE) '((NAT 0))) BASE) (ADD1 (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (PLUS BASE (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)) (DIFFERENCE (PLUS (CADAR A) (CADAR B)) BASE)) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, using linear arithmetic, to: T. Case 1.16. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, rewriting with the lemmas PLUS-0, PLUS-ADD1-2, CDR-CONS, CAR-CONS, PLUS-ADD1-1, ASSOCIATIVITY-OF-PLUS, and ADD1-EQUAL, and unfolding ZEROP, APPEND, UNTAG, and BIGN->NAT, to: (IMPLIES (AND (LISTP A) C (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F))) (EQUAL (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 1))) BASE))) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))). However this further simplifies, applying PLUS-0, PLUS-ADD1-2, and TIMES-DISTRIBUTES-OVER-PLUS, and unfolding the functions UNTAG, TV->NAT, ZEROP, and NOT, to: T. Case 1.15. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). However this again simplifies, applying PLUS-0, PLUS-ADD1-2, CDR-CONS, CAR-CONS, PLUS-ADD1-1, ASSOCIATIVITY-OF-PLUS, and ADD1-EQUAL, and expanding the functions ZEROP, APPEND, UNTAG, and BIGN->NAT, to: (IMPLIES (AND (LISTP A) C (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 0))) BASE))) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which further simplifies, rewriting with PLUS-0 and PLUS-ADD1-2, and expanding the definitions of UNTAG, TV->NAT, ZEROP, NOT, and EQUAL, to: T. Case 1.14. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). This again simplifies, using linear arithmetic, to: T. Case 1.13. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.12. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.11. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.10. (IMPLIES (AND (LISTP A) (NOT C) (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, rewriting with PLUS-0, and opening up the definitions of ZEROP, UNTAG, TV->NAT, and NOT, to: (IMPLIES (AND (LISTP A) (LESSP (PLUS (CADAR A) (CADAR B)) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, applying PLUS-0, CDR-CONS, CAR-CONS, ASSOCIATIVITY-OF-PLUS, and TIMES-DISTRIBUTES-OVER-PLUS, and expanding the definitions of ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, TAG, REMAINDER, BIG-ADD-ARRAY, APPEND, and BIGN->NAT, to: T. Case 1.9. (IMPLIES (AND (LISTP A) (NOT C) (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))). However this again simplifies, rewriting with PLUS-0, and expanding the functions ZEROP, UNTAG, TV->NAT, and NOT, to: (IMPLIES (AND (LISTP A) (LESSP (PLUS (CADAR A) (CADAR B)) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 1))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, applying the lemma PLUS-0, and opening up ZEROP, TV->NAT, UNTAG, and BIG-ADD-CARRY-OUT, to: T. Case 1.8. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, applying PLUS-0, PLUS-ADD1-2, CDR-CONS, CAR-CONS, PLUS-ADD1-1, ASSOCIATIVITY-OF-PLUS, and ADD1-EQUAL, and opening up ZEROP, APPEND, UNTAG, and BIGN->NAT, to the new conjecture: (IMPLIES (AND (LISTP A) C (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F))) (EQUAL (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 1))) BASE))) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which further simplifies, rewriting with PLUS-0 and PLUS-ADD1-2, and opening up the definitions of UNTAG, TV->NAT, ZEROP, and NOT, to: T. Case 1.7. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). This again simplifies, rewriting with PLUS-0, PLUS-ADD1-2, CDR-CONS, CAR-CONS, PLUS-ADD1-1, ASSOCIATIVITY-OF-PLUS, and ADD1-EQUAL, and unfolding ZEROP, APPEND, UNTAG, and BIGN->NAT, to: (IMPLIES (AND (LISTP A) C (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F)) (EQUAL (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 0))) BASE))) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which further simplifies, applying PLUS-0, PLUS-ADD1-2, and TIMES-DISTRIBUTES-OVER-PLUS, and expanding the definitions of UNTAG, TV->NAT, ZEROP, NOT, and EQUAL, to: T. Case 1.6. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))). This again simplifies, using linear arithmetic, to: T. Case 1.5. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F)) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 1))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.4. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (EQUAL BASE 0)) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (ADD1 (PLUS (CADAR A) (CADAR B)))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.3. (IMPLIES (AND (LISTP A) C (LESSP (PLUS (CADAR A) (CADAR B) 1) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (LESSP (ADD1 (PLUS (CADAR A) (CADAR B))) BASE)) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) T BASE)) 'F) (NOT (EQUAL BASE 0))) (EQUAL (BIGN->NAT (APPEND (CONS (LIST 'NAT (DIFFERENCE (PLUS (CADAR A) (CADAR B)) (SUB1 BASE))) (BIG-ADD-ARRAY (CDR A) (CDR B) T BASE)) '((NAT 0))) BASE) (ADD1 (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE)))))), which again simplifies, using linear arithmetic, to: T. Case 1.2. (IMPLIES (AND (LISTP A) (NOT C) (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, applying PLUS-0, and unfolding the functions ZEROP, UNTAG, TV->NAT, and NOT, to: (IMPLIES (AND (LISTP A) (LESSP (PLUS (CADAR A) (CADAR B)) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F))) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 1))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, applying the lemma PLUS-0, and opening up the definitions of ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, and EQUAL, to: T. Case 1.1. (IMPLIES (AND (LISTP A) (NOT C) (LESSP (PLUS (CADAR A) (CADAR B) 0) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE)) BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE) 0)) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, rewriting with PLUS-0, and opening up the functions ZEROP, UNTAG, TV->NAT, and NOT, to the new formula: (IMPLIES (AND (LISTP A) (LESSP (PLUS (CADAR A) (CADAR B)) BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT (CDR A) (CDR B) F BASE)) 'F) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY (CDR A) (CDR B) F BASE) '((NAT 0))) BASE) (PLUS (BIGN->NAT (CDR A) BASE) (BIGN->NAT (CDR B) BASE))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (LISTP B) (LISTP (CAR B)) (EQUAL (CAAR B) 'NAT) (NUMBERP (CADAR B)) (LESSP (CADAR B) BASE) (EQUAL (CDDAR B) NIL) (BIGNP (CDR B) BASE) (EQUAL (LENGTH (CDR A)) (LENGTH (CDR B))) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (CADR (BIG-ADD-CARRY-OUT A B F BASE)) 'F)) (EQUAL (BIGN->NAT (APPEND (BIG-ADD-ARRAY A B F BASE) '((NAT 0))) BASE) (PLUS (CADAR A) (CADAR B) (TIMES BASE (BIGN->NAT (CDR A) BASE)) (TIMES BASE (BIGN->NAT (CDR B) BASE))))), which again simplifies, rewriting with PLUS-0, CDR-CONS, CAR-CONS, ASSOCIATIVITY-OF-PLUS, and TIMES-DISTRIBUTES-OVER-PLUS, and unfolding ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, EQUAL, TAG, REMAINDER, BIG-ADD-ARRAY, APPEND, and BIGN->NAT, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 7.5 1.3 ] INTERPRETATION-OF-BIG-ADD-RESULTS (DISABLE TV->NAT) [ 0.0 0.0 0.0 ] TV->NAT-OFF (PROVE-LEMMA EQUAL-LESSP-N-1 (REWRITE) (EQUAL (LESSP N 1) (ZEROP N))) This simplifies, unfolding ZEROP, to three new formulas: Case 3. (IMPLIES (AND (NOT (EQUAL N 0)) (NUMBERP N)) (EQUAL (LESSP N 1) F)), which again simplifies, obviously, to: (IMPLIES (AND (NOT (EQUAL N 0)) (NUMBERP N)) (NOT (LESSP N 1))), which again simplifies, using linear arithmetic, to: T. Case 2. (IMPLIES (EQUAL N 0) (EQUAL (LESSP N 1) T)), which again simplifies, expanding the functions LESSP and EQUAL, to: T. Case 1. (IMPLIES (NOT (NUMBERP N)) (EQUAL (LESSP N 1) T)), which again simplifies, unfolding the functions NUMBERP, EQUAL, and LESSP, to: T. Q.E.D. [ 0.0 0.0 0.0 ] EQUAL-LESSP-N-1 (DEFN BIG-ADD-ARRAY-LOOP (I A-ARRAY B-ARRAY N C BASE) (IF (ZEROP (SUB1 N)) (PUT (TAG 'NAT (REMAINDER (PLUS (UNTAG (GET I A-ARRAY)) (UNTAG (GET I B-ARRAY)) (TV->NAT C)) BASE)) I A-ARRAY) (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (TAG 'NAT (REMAINDER (PLUS (UNTAG (GET I A-ARRAY)) (UNTAG (GET I B-ARRAY)) (TV->NAT C)) BASE)) I A-ARRAY) B-ARRAY (SUB1 N) (NOT (LESSP (PLUS (UNTAG (GET I A-ARRAY)) (UNTAG (GET I B-ARRAY)) (TV->NAT C)) BASE)) BASE))) Linear arithmetic, the lemmas COUNT-NUMBERP, COUNT-NOT-LESSP, SUB1-NNUMBERP, and EQUAL-LESSP-N-1, and the definitions of ZEROP, EQUAL, and SUB1 can be used to establish that the measure (COUNT N) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIG-ADD-ARRAY-LOOP is accepted under the principle of definition. From the definition we can conclude that: (LISTP (BIG-ADD-ARRAY-LOOP I A-ARRAY B-ARRAY N C BASE)) is a theorem. [ 0.0 0.0 0.0 ] BIG-ADD-ARRAY-LOOP (DEFN BIG-ADD-CARRY-OUT-LOOP (I A-ARRAY B-ARRAY N C BASE) (IF (ZEROP (SUB1 N)) (BOOL (NOT (LESSP (PLUS (UNTAG (GET I A-ARRAY)) (UNTAG (GET I B-ARRAY)) (TV->NAT C)) BASE))) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (TAG 'NAT (REMAINDER (PLUS (UNTAG (GET I A-ARRAY)) (UNTAG (GET I B-ARRAY)) (TV->NAT C)) BASE)) I A-ARRAY) B-ARRAY (SUB1 N) (NOT (LESSP (PLUS (UNTAG (GET I A-ARRAY)) (UNTAG (GET I B-ARRAY)) (TV->NAT C)) BASE)) BASE))) Linear arithmetic, the lemmas COUNT-NUMBERP, COUNT-NOT-LESSP, SUB1-NNUMBERP, and EQUAL-LESSP-N-1, and the definitions of ZEROP, EQUAL, and SUB1 establish that the measure (COUNT N) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIG-ADD-CARRY-OUT-LOOP is accepted under the principle of definition. Note that (LISTP (BIG-ADD-CARRY-OUT-LOOP I A-ARRAY B-ARRAY N C BASE)) is a theorem. [ 0.0 0.0 0.0 ] BIG-ADD-CARRY-OUT-LOOP (DEFN NTH-CDR (I A) (IF (ZEROP I) A (NTH-CDR (SUB1 I) (CDR A)))) Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT I) decreases according to the well-founded relation LESSP in each recursive call. Hence, NTH-CDR is accepted under the principle of definition. [ 0.0 0.0 0.0 ] NTH-CDR (PROVE-LEMMA GET-IS-CAR-NTH-CDR (REWRITE) (EQUAL (GET I A) (CAR (NTH-CDR I A)))) Name the conjecture *1. Perhaps we can prove it by induction. There are two plausible inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP I) (p I A)) (IMPLIES (AND (NOT (ZEROP I)) (p (SUB1 I) (CDR A))) (p I A))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP establish that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for A. The above induction scheme produces the following two new goals: Case 2. (IMPLIES (ZEROP I) (EQUAL (GET I A) (CAR (NTH-CDR I A)))). This simplifies, expanding ZEROP, EQUAL, GET, and NTH-CDR, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP I)) (EQUAL (GET (SUB1 I) (CDR A)) (CAR (NTH-CDR (SUB1 I) (CDR A))))) (EQUAL (GET I A) (CAR (NTH-CDR I A)))). This simplifies, unfolding ZEROP, GET, and NTH-CDR, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.0 ] GET-IS-CAR-NTH-CDR (ENABLE LENGTH-PUT) [ 0.0 0.0 0.0 ] LENGTH-PUT-ON2 (PROVE-LEMMA NTH-CDR-ADD1 (REWRITE) (EQUAL (NTH-CDR (ADD1 I) X) (CDR (NTH-CDR I X)))) This conjecture simplifies, applying SUB1-ADD1, and unfolding the function NTH-CDR, to two new goals: Case 2. (IMPLIES (NOT (NUMBERP I)) (EQUAL (NTH-CDR 0 (CDR X)) (CDR (NTH-CDR I X)))), which again simplifies, expanding the definitions of EQUAL and NTH-CDR, to: T. Case 1. (IMPLIES (NUMBERP I) (EQUAL (NTH-CDR I (CDR X)) (CDR (NTH-CDR I X)))). Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate (CDR X) and (CAR X). We would thus like to prove the following two new conjectures: Case 1.2. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP I)) (EQUAL (NTH-CDR I (CDR X)) (CDR (NTH-CDR I X)))). But this further simplifies, rewriting with the lemma CDR-NLISTP, to the goal: (IMPLIES (AND (NOT (LISTP X)) (NUMBERP I)) (EQUAL (NTH-CDR I 0) (CDR (NTH-CDR I X)))), which we would usually push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it. So now let us consider: (EQUAL (NTH-CDR (ADD1 I) X) (CDR (NTH-CDR I X))). We gave this the name *1 above. Perhaps we can prove it by induction. There is only one plausible induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP I) (p I X)) (IMPLIES (AND (NOT (ZEROP I)) (p (SUB1 I) (CDR X))) (p I X))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for X. The above induction scheme leads to the following two new formulas: Case 2. (IMPLIES (ZEROP I) (EQUAL (NTH-CDR (ADD1 I) X) (CDR (NTH-CDR I X)))). This simplifies, rewriting with SUB1-TYPE-RESTRICTION, and expanding the functions ZEROP, ADD1, EQUAL, and NTH-CDR, to two new goals: Case 2.2. (IMPLIES (EQUAL I 0) (EQUAL (NTH-CDR 1 X) (CDR X))), which again simplifies, clearly, to: (EQUAL (NTH-CDR 1 X) (CDR X)). Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate (CDR X) and (CAR X). We would thus like to prove the following two new formulas: Case 2.2.2. (IMPLIES (NOT (LISTP X)) (EQUAL (NTH-CDR 1 X) (CDR X))). But this further simplifies, rewriting with the lemma CDR-NLISTP, and opening up the functions NTH-CDR, SUB1, NUMBERP, and EQUAL, to: T. Case 2.2.1. (EQUAL (NTH-CDR 1 (CONS V Z)) Z), which further simplifies, rewriting with the lemma CDR-CONS, and opening up the functions SUB1, NUMBERP, EQUAL, and NTH-CDR, to: T. Case 2.1. (IMPLIES (NOT (NUMBERP I)) (EQUAL (NTH-CDR 1 X) (CDR X))). Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate (CDR X) and (CAR X). We thus obtain the following two new goals: Case 2.1.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (NUMBERP I))) (EQUAL (NTH-CDR 1 X) (CDR X))). However this further simplifies, applying the lemma CDR-NLISTP, and expanding the functions NTH-CDR, SUB1, NUMBERP, and EQUAL, to: T. Case 2.1.1. (IMPLIES (NOT (NUMBERP I)) (EQUAL (NTH-CDR 1 (CONS V Z)) Z)), which further simplifies, rewriting with CDR-CONS, and unfolding the definitions of SUB1, NUMBERP, EQUAL, and NTH-CDR, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP I)) (EQUAL (NTH-CDR (ADD1 (SUB1 I)) (CDR X)) (CDR (NTH-CDR (SUB1 I) (CDR X))))) (EQUAL (NTH-CDR (ADD1 I) X) (CDR (NTH-CDR I X)))). This simplifies, applying ADD1-SUB1 and SUB1-ADD1, and opening up the definitions of ZEROP and NTH-CDR, to: T. That finishes the proof of *1. Q.E.D. [ 0.1 0.0 0.0 ] NTH-CDR-ADD1 (PROVE-LEMMA NTH-CDR-PUT-AT (REWRITE) (IMPLIES (LESSP I (LENGTH A)) (EQUAL (NTH-CDR I (PUT VAL I A)) (CONS VAL (CDR (NTH-CDR I A)))))) Call the conjecture *1. We will try to prove it by induction. The recursive terms in the conjecture suggest five inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A)))) (p I VAL A)) (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (OR (EQUAL I 0) (NOT (NUMBERP I)))) (p I VAL A)) (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (p (SUB1 I) VAL (CDR A))) (p I VAL A))). Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions of OR and NOT can be used to prove that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for A. The above induction scheme leads to the following four new goals: Case 4. (IMPLIES (AND (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A)))) (LESSP I (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL I A)) (CONS VAL (CDR (NTH-CDR I A))))). This simplifies, opening up the definitions of LENGTH, NOT, OR, EQUAL, and LESSP, to: T. Case 3. (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (OR (EQUAL I 0) (NOT (NUMBERP I))) (LESSP I (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL I A)) (CONS VAL (CDR (NTH-CDR I A))))). This simplifies, expanding LENGTH, NOT, OR, EQUAL, LESSP, PUT, and NTH-CDR, to: T. Case 2. (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (LESSP I (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL I A)) (CONS VAL (CDR (NTH-CDR I A))))). This simplifies, rewriting with the lemma SUB1-ADD1, and unfolding LENGTH, NOT, OR, and LESSP, to: T. Case 1. (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (EQUAL (NTH-CDR (SUB1 I) (PUT VAL (SUB1 I) (CDR A))) (CONS VAL (CDR (NTH-CDR (SUB1 I) (CDR A))))) (LESSP I (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL I A)) (CONS VAL (CDR (NTH-CDR I A))))). This simplifies, rewriting with SUB1-ADD1 and CDR-CONS, and expanding the functions LENGTH, NOT, OR, LESSP, PUT, and NTH-CDR, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.1 ] NTH-CDR-PUT-AT (DEFN HINT1 (I A B C BASE) (IF (LESSP I (LENGTH A)) (HINT1 (ADD1 I) (PUT (TAG 'NAT (REMAINDER (PLUS (UNTAG (GET I A)) (UNTAG (GET I B)) (TV->NAT C)) BASE)) I A) B (NOT (LESSP (PLUS (UNTAG (GET I A)) (UNTAG (GET I B)) (TV->NAT C)) BASE)) BASE) T) ((LESSP (DIFFERENCE (LENGTH A) I)))) Linear arithmetic, the lemmas SUB1-ADD1, LENGTH-PUT, COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and GET-IS-CAR-NTH-CDR, and the definitions of DIFFERENCE, TAG, UNTAG, EQUAL, and LESSP can be used to show that the measure (DIFFERENCE (LENGTH A) I) decreases according to the well-founded relation LESSP in each recursive call. Hence, HINT1 is accepted under the definitional principle. Note that (TRUEP (HINT1 I A B C BASE)) is a theorem. [ 0.0 0.0 0.0 ] HINT1 (PROVE-LEMMA LISTP-NTH-CDR (REWRITE) (EQUAL (LISTP (NTH-CDR I A)) (LESSP I (LENGTH A)))) Name the conjecture *1. We will appeal to induction. The recursive terms in the conjecture suggest three inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP I) (p I A)) (IMPLIES (AND (NOT (ZEROP I)) (p (SUB1 I) (CDR A))) (p I A))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for A. The above induction scheme produces the following two new formulas: Case 2. (IMPLIES (ZEROP I) (EQUAL (LISTP (NTH-CDR I A)) (LESSP I (LENGTH A)))). This simplifies, expanding the definitions of ZEROP, EQUAL, NTH-CDR, LENGTH, and LESSP, to the following six new conjectures: Case 2.6. (IMPLIES (AND (EQUAL I 0) (LISTP A) (NOT (EQUAL (ADD1 (LENGTH (CDR A))) 0))) (EQUAL (LISTP A) T)). This again simplifies, trivially, to: T. Case 2.5. (IMPLIES (AND (EQUAL I 0) (NOT (LISTP A))) (EQUAL (LISTP A) F)). This again simplifies, trivially, to: T. Case 2.4. (IMPLIES (AND (EQUAL I 0) (EQUAL (ADD1 (LENGTH (CDR A))) 0)) (EQUAL (LISTP A) F)). But this again simplifies, using linear arithmetic, to: T. Case 2.3. (IMPLIES (AND (NOT (NUMBERP I)) (LISTP A) (NOT (EQUAL (ADD1 (LENGTH (CDR A))) 0))) (EQUAL (LISTP A) T)), which again simplifies, obviously, to: T. Case 2.2. (IMPLIES (AND (NOT (NUMBERP I)) (NOT (LISTP A))) (EQUAL (LISTP A) F)). This again simplifies, obviously, to: T. Case 2.1. (IMPLIES (AND (NOT (NUMBERP I)) (EQUAL (ADD1 (LENGTH (CDR A))) 0)) (EQUAL (LISTP A) F)). However this again simplifies, using linear arithmetic, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP I)) (EQUAL (LISTP (NTH-CDR (SUB1 I) (CDR A))) (LESSP (SUB1 I) (LENGTH (CDR A))))) (EQUAL (LISTP (NTH-CDR I A)) (LESSP I (LENGTH A)))), which simplifies, expanding the functions ZEROP, NTH-CDR, and LENGTH, to two new goals: Case 1.2. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL (LISTP (NTH-CDR (SUB1 I) (CDR A))) (LESSP (SUB1 I) (LENGTH (CDR A)))) (NOT (LISTP A))) (EQUAL (LESSP (SUB1 I) (LENGTH (CDR A))) (LESSP I 0))), which again simplifies, expanding EQUAL and LESSP, to the conjecture: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL (LISTP (NTH-CDR (SUB1 I) (CDR A))) (LESSP (SUB1 I) (LENGTH (CDR A)))) (NOT (LISTP A))) (NOT (LESSP (SUB1 I) (LENGTH (CDR A))))). This again simplifies, trivially, to the new formula: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (LISTP (NTH-CDR (SUB1 I) (CDR A))) (NOT (LISTP A))) (NOT (LESSP (SUB1 I) (LENGTH (CDR A))))), which further simplifies, appealing to the lemma CDR-NLISTP, and opening up LENGTH, EQUAL, and LESSP, to: T. Case 1.1. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL (LISTP (NTH-CDR (SUB1 I) (CDR A))) (LESSP (SUB1 I) (LENGTH (CDR A)))) (LISTP A)) (EQUAL (LESSP (SUB1 I) (LENGTH (CDR A))) (LESSP I (ADD1 (LENGTH (CDR A)))))), which again simplifies, applying SUB1-ADD1, and unfolding the function LESSP, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.0 ] LISTP-NTH-CDR (PROVE-LEMMA NTH-CDR-PUT-BEFORE (REWRITE) (IMPLIES (AND (LESSP J I) (LESSP J (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL J A)) (NTH-CDR I A)))) Name the conjecture *1. Perhaps we can prove it by induction. There are seven plausible inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (OR (EQUAL I 0) (NOT (NUMBERP I))) (p I VAL J A)) (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (OR (EQUAL J 0) (NOT (NUMBERP J)))) (p I VAL J A)) (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (OR (EQUAL J 0) (NOT (NUMBERP J)))) (p (SUB1 I) VAL (SUB1 J) (CDR A))) (p I VAL J A))). Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions of OR and NOT establish that the measure (COUNT J) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instances chosen for A and I. The above induction scheme leads to the following five new formulas: Case 5. (IMPLIES (AND (OR (EQUAL I 0) (NOT (NUMBERP I))) (LESSP J I) (LESSP J (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL J A)) (NTH-CDR I A))). This simplifies, opening up the definitions of NOT, OR, EQUAL, and LESSP, to: T. Case 4. (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (OR (EQUAL J 0) (NOT (NUMBERP J))) (LESSP J I) (LESSP J (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL J A)) (NTH-CDR I A))). This simplifies, expanding NOT, OR, EQUAL, LESSP, LENGTH, PUT, and NTH-CDR, to the following two new formulas: Case 4.2. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL J 0) (LISTP A) (NOT (EQUAL (ADD1 (LENGTH (CDR A))) 0))) (EQUAL (NTH-CDR I (CONS VAL (CDR A))) (NTH-CDR (SUB1 I) (CDR A)))). However this again simplifies, rewriting with the lemma CDR-CONS, and opening up the definition of NTH-CDR, to: T. Case 4.1. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (NOT (NUMBERP J)) (LISTP A) (NOT (EQUAL (ADD1 (LENGTH (CDR A))) 0))) (EQUAL (NTH-CDR I (CONS VAL (CDR A))) (NTH-CDR (SUB1 I) (CDR A)))), which again simplifies, appealing to the lemma CDR-CONS, and unfolding the function NTH-CDR, to: T. Case 3. (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (OR (EQUAL J 0) (NOT (NUMBERP J)))) (NOT (LESSP (SUB1 J) (SUB1 I))) (LESSP J I) (LESSP J (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL J A)) (NTH-CDR I A))), which simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP J 1) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (OR (EQUAL J 0) (NOT (NUMBERP J)))) (NOT (LESSP (SUB1 J) (SUB1 I))) (LESSP J I) (LESSP J (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL J A)) (NTH-CDR I A))). However this again simplifies, rewriting with EQUAL-LESSP-N-1, and unfolding NOT, OR, EQUAL, and NUMBERP, to: T. Case 2. (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (OR (EQUAL J 0) (NOT (NUMBERP J)))) (NOT (LESSP (SUB1 J) (LENGTH (CDR A)))) (LESSP J I) (LESSP J (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL J A)) (NTH-CDR I A))). This simplifies, rewriting with CAR-NLISTP, and expanding the functions NOT, OR, LESSP, LENGTH, PUT, and NTH-CDR, to two new goals: Case 2.2. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (NOT (EQUAL J 0)) (NUMBERP J) (NOT (LESSP (SUB1 J) (LENGTH (CDR A)))) (LESSP (SUB1 J) (SUB1 I)) (NOT (LISTP A)) (LESSP J 0)) (EQUAL (NTH-CDR I (CONS 0 (PUT VAL (SUB1 J) (CDR A)))) (NTH-CDR (SUB1 I) (CDR A)))), which again simplifies, using linear arithmetic, to: T. Case 2.1. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (NOT (EQUAL J 0)) (NUMBERP J) (NOT (LESSP (SUB1 J) (LENGTH (CDR A)))) (LESSP (SUB1 J) (SUB1 I)) (LISTP A) (LESSP J (ADD1 (LENGTH (CDR A))))) (EQUAL (NTH-CDR I (CONS (CAR A) (PUT VAL (SUB1 J) (CDR A)))) (NTH-CDR (SUB1 I) (CDR A)))), which again simplifies, using linear arithmetic, to: T. Case 1. (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (OR (EQUAL J 0) (NOT (NUMBERP J)))) (EQUAL (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A))) (NTH-CDR (SUB1 I) (CDR A))) (LESSP J I) (LESSP J (LENGTH A))) (EQUAL (NTH-CDR I (PUT VAL J A)) (NTH-CDR I A))), which simplifies, rewriting with CAR-NLISTP and CDR-CONS, and expanding the definitions of NOT, OR, LESSP, LENGTH, PUT, and NTH-CDR, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.1 0.0 ] NTH-CDR-PUT-BEFORE (PROVE-LEMMA DIFFERENCE-EQUAL-1 (REWRITE) (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP I (SUB1 (LENGTH A))))) (EQUAL (DIFFERENCE (LENGTH A) I) 1))) This conjecture simplifies, using linear arithmetic, to the formula: (IMPLIES (AND (LESSP (LENGTH A) I) (LESSP I (LENGTH A)) (NOT (LESSP I (SUB1 (LENGTH A))))) (EQUAL (DIFFERENCE (LENGTH A) I) 1)). This again simplifies, using linear arithmetic, to: T. Q.E.D. [ 0.0 0.0 0.0 ] DIFFERENCE-EQUAL-1 (PROVE-LEMMA BIG-ADD-ARRAY-LOOP-ON-LIST-OF-LENGTH-1 (REWRITE) (EQUAL (BIG-ADD-ARRAY-LOOP I A B 1 C BASE) (PUT (TAG 'NAT (REMAINDER (PLUS (UNTAG (GET I A)) (UNTAG (GET I B)) (TV->NAT C)) BASE)) I A))) This conjecture can be simplified, using the abbreviations GET-IS-CAR-NTH-CDR, UNTAG, and TAG, to: (EQUAL (BIG-ADD-ARRAY-LOOP I A B 1 C BASE) (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A)). This simplifies, rewriting with COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and GET-IS-CAR-NTH-CDR, and expanding the functions TAG, UNTAG, EQUAL, SUB1, and BIG-ADD-ARRAY-LOOP, to: T. Q.E.D. [ 0.0 0.1 0.0 ] BIG-ADD-ARRAY-LOOP-ON-LIST-OF-LENGTH-1 (ENABLE EQUAL-LENGTH-0) [ 0.0 0.0 0.0 ] EQUAL-LENGTH-0-ON4 (PROVE-LEMMA EQUAL-LENGTH-1 (REWRITE) (EQUAL (EQUAL (LENGTH A) 1) (AND (LISTP A) (NLISTP (CDR A))))) This conjecture simplifies, expanding the definitions of LENGTH, NLISTP, and AND, to the following two new formulas: Case 2. (IMPLIES (AND (LISTP A) (NOT (EQUAL (ADD1 (LENGTH (CDR A))) 1))) (LISTP (CDR A))). This again simplifies, expanding the functions LENGTH, ADD1, and EQUAL, to: T. Case 1. (IMPLIES (AND (LISTP A) (EQUAL (ADD1 (LENGTH (CDR A))) 1)) (NOT (LISTP (CDR A)))), which again simplifies, applying EQUAL-LENGTH-0 and ADD1-EQUAL, and unfolding the definition of NUMBERP, to: T. Q.E.D. [ 0.0 0.0 0.0 ] EQUAL-LENGTH-1 (PROVE-LEMMA NLISTP-CDR-NTH-CDR (REWRITE) (EQUAL (LISTP (CDR (NTH-CDR I A))) (LESSP I (SUB1 (LENGTH A))))) Give the conjecture the name *1. We will appeal to induction. There are three plausible inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP I) (p I A)) (IMPLIES (AND (NOT (ZEROP I)) (p (SUB1 I) (CDR A))) (p I A))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP establish that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for A. The above induction scheme produces the following two new formulas: Case 2. (IMPLIES (ZEROP I) (EQUAL (LISTP (CDR (NTH-CDR I A))) (LESSP I (SUB1 (LENGTH A))))). This simplifies, opening up ZEROP, EQUAL, NTH-CDR, LENGTH, and LESSP, to the following eight new formulas: Case 2.8. (IMPLIES (AND (EQUAL I 0) (LISTP A) (NOT (EQUAL (SUB1 (ADD1 (LENGTH (CDR A)))) 0))) (EQUAL (LISTP (CDR A)) T)). This again simplifies, applying SUB1-ADD1 and EQUAL-LENGTH-0, to: T. Case 2.7. (IMPLIES (AND (EQUAL I 0) (NOT (LISTP A)) (NOT (EQUAL (SUB1 0) 0))) (EQUAL (LISTP (CDR A)) T)). This again simplifies, unfolding the functions SUB1 and EQUAL, to: T. Case 2.6. (IMPLIES (AND (EQUAL I 0) (LISTP A) (EQUAL (SUB1 (ADD1 (LENGTH (CDR A)))) 0)) (EQUAL (LISTP (CDR A)) F)), which again simplifies, appealing to the lemmas SUB1-ADD1 and EQUAL-LENGTH-0, to: T. Case 2.5. (IMPLIES (AND (EQUAL I 0) (NOT (LISTP A)) (EQUAL (SUB1 0) 0)) (EQUAL (LISTP (CDR A)) F)), which again simplifies, rewriting with CDR-NLISTP, and opening up the functions SUB1, EQUAL, and LISTP, to: T. Case 2.4. (IMPLIES (AND (NOT (NUMBERP I)) (LISTP A) (NOT (EQUAL (SUB1 (ADD1 (LENGTH (CDR A)))) 0))) (EQUAL (LISTP (CDR A)) T)). But this again simplifies, appealing to the lemmas SUB1-ADD1 and EQUAL-LENGTH-0, to: T. Case 2.3. (IMPLIES (AND (NOT (NUMBERP I)) (NOT (LISTP A)) (NOT (EQUAL (SUB1 0) 0))) (EQUAL (LISTP (CDR A)) T)), which again simplifies, opening up SUB1 and EQUAL, to: T. Case 2.2. (IMPLIES (AND (NOT (NUMBERP I)) (LISTP A) (EQUAL (SUB1 (ADD1 (LENGTH (CDR A)))) 0)) (EQUAL (LISTP (CDR A)) F)), which again simplifies, applying SUB1-ADD1 and EQUAL-LENGTH-0, to: T. Case 2.1. (IMPLIES (AND (NOT (NUMBERP I)) (NOT (LISTP A)) (EQUAL (SUB1 0) 0)) (EQUAL (LISTP (CDR A)) F)). But this again simplifies, applying the lemma CDR-NLISTP, and unfolding the definitions of SUB1, EQUAL, and LISTP, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP I)) (EQUAL (LISTP (CDR (NTH-CDR (SUB1 I) (CDR A)))) (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A)))))) (EQUAL (LISTP (CDR (NTH-CDR I A))) (LESSP I (SUB1 (LENGTH A))))), which simplifies, expanding the functions ZEROP, NTH-CDR, and LENGTH, to two new formulas: Case 1.2. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL (LISTP (CDR (NTH-CDR (SUB1 I) (CDR A)))) (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A))))) (NOT (LISTP A))) (EQUAL (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A)))) (LESSP I (SUB1 0)))), which again simplifies, expanding SUB1, EQUAL, and LESSP, to: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL (LISTP (CDR (NTH-CDR (SUB1 I) (CDR A)))) (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A))))) (NOT (LISTP A))) (NOT (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A)))))). This again simplifies, trivially, to: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (LISTP (CDR (NTH-CDR (SUB1 I) (CDR A)))) (NOT (LISTP A))) (NOT (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A)))))), which further simplifies, using linear arithmetic, applying the lemmas CDR-NLISTP and LISTP-NTH-CDR, and expanding the functions LENGTH and LISTP, to: T. Case 1.1. (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL (LISTP (CDR (NTH-CDR (SUB1 I) (CDR A)))) (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A))))) (LISTP A)) (EQUAL (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A)))) (LESSP I (SUB1 (ADD1 (LENGTH (CDR A))))))), which again simplifies, rewriting with SUB1-ADD1 and EQUAL-LENGTH-0, and unfolding the definition of LESSP, to: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (EQUAL (LISTP (CDR (NTH-CDR (SUB1 I) (CDR A)))) (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A))))) (LISTP A) (NOT (LISTP (CDR A)))) (EQUAL (LESSP (SUB1 I) (SUB1 (LENGTH (CDR A)))) F)), which again simplifies, applying LISTP-NTH-CDR, EQUAL-LENGTH-0, and CDR-NLISTP, and unfolding LESSP, LISTP, and EQUAL, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.7 ] NLISTP-CDR-NTH-CDR (PROVE-LEMMA BIG-ADD-ARRAY-ON-LIST-OF-LENGTH-1 (REWRITE) (IMPLIES (AND (LISTP A) (NLISTP (CDR A))) (EQUAL (BIG-ADD-ARRAY A B C BASE) (LIST (TAG 'NAT (REMAINDER (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE))))) ((EXPAND (BIG-ADD-ARRAY A B C BASE)))) This formula can be simplified, using the abbreviations NLISTP, AND, IMPLIES, UNTAG, and TAG, to the new goal: (IMPLIES (AND (LISTP A) (NOT (LISTP (CDR A)))) (EQUAL (BIG-ADD-ARRAY A B C BASE) (LIST (LIST 'NAT (REMAINDER (PLUS (CADAR A) (CADAR B) (TV->NAT C)) BASE))))), which simplifies, appealing to the lemmas COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and expanding the definitions of BIG-ADD-ARRAY, UNTAG, REMAINDER, and TAG, to: (IMPLIES (AND (LISTP A) (NOT (LISTP (CDR A))) (LESSP (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE)) (EQUAL (LIST (LIST 'NAT (PLUS (TV->NAT C) (CADAR A) (CADAR B)))) (LIST (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE))))). But this again simplifies, unfolding the function REMAINDER, to: T. Q.E.D. [ 0.0 0.1 0.0 ] BIG-ADD-ARRAY-ON-LIST-OF-LENGTH-1 (PROVE-LEMMA DIFFERENCE-ADD1-NEW (REWRITE) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))) This formula simplifies, using linear arithmetic, to the following three new goals: Case 3. (IMPLIES (LESSP (LENGTH A) (ADD1 I)) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))). But this again simplifies, rewriting with SUB1-ADD1, EQUAL-LENGTH-0, and SUB1-TYPE-RESTRICTION, and opening up LESSP, LENGTH, EQUAL, DIFFERENCE, and SUB1, to the following four new formulas: Case 3.4. (IMPLIES (AND (NOT (NUMBERP I)) (LESSP (SUB1 (LENGTH A)) 0) (NOT (LISTP A))) (EQUAL (DIFFERENCE (LENGTH A) 1) (SUB1 0))). However this again simplifies, expanding LENGTH, SUB1, and LESSP, to: T. Case 3.3. (IMPLIES (AND (NOT (NUMBERP I)) (LESSP (SUB1 (LENGTH A)) 0) (LISTP A)) (EQUAL (DIFFERENCE (LENGTH A) 1) (SUB1 (LENGTH A)))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL (LENGTH A) 0) (NOT (NUMBERP I)) (LESSP (SUB1 (LENGTH A)) 0) (LISTP A)) (EQUAL (DIFFERENCE (LENGTH A) 1) (SUB1 (LENGTH A)))). However this again simplifies, applying EQUAL-LENGTH-0, to: T. Case 3.2. (IMPLIES (AND (NUMBERP I) (LESSP (SUB1 (LENGTH A)) I) (NOT (LISTP A))) (EQUAL 0 (SUB1 (DIFFERENCE (LENGTH A) I)))). But this again simplifies, expanding the functions LENGTH, SUB1, EQUAL, LESSP, and DIFFERENCE, to: T. Case 3.1. (IMPLIES (AND (NUMBERP I) (LESSP (SUB1 (LENGTH A)) I) (LISTP A)) (EQUAL (DIFFERENCE (SUB1 (LENGTH A)) I) (SUB1 (DIFFERENCE (LENGTH A) I)))), which we will name *1. Case 2. (IMPLIES (NOT (LESSP I (LENGTH A))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))). But this again simplifies, rewriting with the lemmas SUB1-ADD1 and EQUAL-LENGTH-0, and opening up the function DIFFERENCE, to three new goals: Case 2.3. (IMPLIES (AND (NOT (LESSP I (LENGTH A))) (NOT (LISTP A))) (EQUAL 0 (SUB1 (DIFFERENCE (LENGTH A) I)))), which again simplifies, opening up the functions LENGTH, EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 2.2. (IMPLIES (AND (NOT (LESSP I (LENGTH A))) (LISTP A) (NUMBERP I)) (EQUAL (DIFFERENCE (SUB1 (LENGTH A)) I) (SUB1 (DIFFERENCE (LENGTH A) I)))), which we would normally push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it. So now let us return to: (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I))), named *1. Let us appeal to the induction principle. Three inductions are suggested by terms in the conjecture. They merge into two likely candidate inductions, both of which are unflawed. However, one of these is more likely than the other. We will induct according to the following scheme: (AND (IMPLIES (AND (LISTP A) (p (CDR A) I)) (p A I)) (IMPLIES (NOT (LISTP A)) (p A I))). Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure (COUNT A) decreases according to the well-founded relation LESSP in each induction step of the scheme. The above induction scheme produces the following two new conjectures: Case 2. (IMPLIES (AND (LISTP A) (EQUAL (DIFFERENCE (LENGTH (CDR A)) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I)))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))). This simplifies, using linear arithmetic, to the following three new formulas: Case 2.3. (IMPLIES (AND (LESSP (LENGTH A) (ADD1 I)) (LISTP A) (EQUAL (DIFFERENCE (LENGTH (CDR A)) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I)))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))). This again simplifies, rewriting with SUB1-ADD1, SUB1-TYPE-RESTRICTION, and EQUAL-LENGTH-0, and expanding the functions LENGTH, LESSP, DIFFERENCE, SUB1, NUMBERP, and EQUAL, to the following four new goals: Case 2.3.4. (IMPLIES (AND (NUMBERP I) (LESSP (LENGTH (CDR A)) I) (LISTP A) (NOT (LISTP (CDR A))) (EQUAL 0 (SUB1 (DIFFERENCE (LENGTH (CDR A)) I))) (NOT (EQUAL I 0))) (EQUAL 0 (SUB1 0))). This again simplifies, applying the lemma EQUAL-LENGTH-0, and expanding the functions LESSP, DIFFERENCE, SUB1, and EQUAL, to: T. Case 2.3.3. (IMPLIES (AND (NUMBERP I) (LESSP (LENGTH (CDR A)) I) (LISTP A) (NOT (LISTP (CDR A))) (EQUAL 0 (SUB1 (DIFFERENCE (LENGTH (CDR A)) I))) (EQUAL I 0)) (EQUAL 0 (SUB1 (ADD1 (LENGTH (CDR A)))))), which again simplifies, using linear arithmetic, to: T. Case 2.3.2. (IMPLIES (AND (NUMBERP I) (LESSP (LENGTH (CDR A)) I) (LISTP A) (LISTP (CDR A)) (EQUAL (DIFFERENCE (SUB1 (LENGTH (CDR A))) I) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I))) (NOT (EQUAL I 0))) (EQUAL (DIFFERENCE (LENGTH (CDR A)) I) (SUB1 (DIFFERENCE (LENGTH (CDR A)) (SUB1 I))))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate (CDR A) and (CAR A). We would thus like to prove: (IMPLIES (AND (NUMBERP I) (LESSP (LENGTH X) I) (LISTP X) (EQUAL (DIFFERENCE (SUB1 (LENGTH X)) I) (SUB1 (DIFFERENCE (LENGTH X) I))) (NOT (EQUAL I 0))) (EQUAL (DIFFERENCE (LENGTH X) I) (SUB1 (DIFFERENCE (LENGTH X) (SUB1 I))))). Applying the lemma SUB1-ELIM, replace I by (ADD1 Z) to eliminate (SUB1 I). We rely upon the type restriction lemma noted when SUB1 was introduced to restrict the new variable. This produces: (IMPLIES (AND (NUMBERP Z) (LESSP (LENGTH X) (ADD1 Z)) (LISTP X) (EQUAL (DIFFERENCE (SUB1 (LENGTH X)) (ADD1 Z)) (SUB1 (DIFFERENCE (LENGTH X) (ADD1 Z)))) (NOT (EQUAL (ADD1 Z) 0))) (EQUAL (DIFFERENCE (LENGTH X) (ADD1 Z)) (SUB1 (DIFFERENCE (LENGTH X) Z)))), which further simplifies, rewriting with the lemmas SUB1-ADD1 and EQUAL-LENGTH-0, and expanding the functions LESSP, DIFFERENCE, and EQUAL, to three new goals: Case 2.3.2.3. (IMPLIES (AND (NUMBERP Z) (LESSP (SUB1 (LENGTH X)) Z) (LISTP X) (NOT (EQUAL (SUB1 (LENGTH X)) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 (LENGTH X))) Z) (SUB1 (DIFFERENCE (SUB1 (LENGTH X)) Z)))) (EQUAL (DIFFERENCE (SUB1 (LENGTH X)) Z) (SUB1 (DIFFERENCE (LENGTH X) Z)))), which we generalize by replacing (LENGTH X) by Y. We restrict the new variable by recalling the type restriction lemma noted when LENGTH was introduced. We thus obtain: (IMPLIES (AND (NUMBERP Y) (NUMBERP Z) (LESSP (SUB1 Y) Z) (LISTP X) (NOT (EQUAL (SUB1 Y) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 Y)) Z) (SUB1 (DIFFERENCE (SUB1 Y) Z)))) (EQUAL (DIFFERENCE (SUB1 Y) Z) (SUB1 (DIFFERENCE Y Z)))). Applying the lemmas SUB1-ELIM and DIFFERENCE-ELIM, replace Y by (ADD1 V) to eliminate (SUB1 Y), V by (ADD1 W) to eliminate (SUB1 V), and W by (PLUS Z V) to eliminate (DIFFERENCE W Z). We employ the type restriction lemma noted when SUB1 was introduced and the type restriction lemma noted when DIFFERENCE was introduced to restrict the new variables. We thus obtain the following three new formulas: Case 2.3.2.3.3. (IMPLIES (AND (EQUAL Y 0) (NUMBERP Y) (NUMBERP Z) (LESSP (SUB1 Y) Z) (LISTP X) (NOT (EQUAL (SUB1 Y) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 Y)) Z) (SUB1 (DIFFERENCE (SUB1 Y) Z)))) (EQUAL (DIFFERENCE (SUB1 Y) Z) (SUB1 (DIFFERENCE Y Z)))). But this finally simplifies, expanding NUMBERP, SUB1, EQUAL, and LESSP, to: T. Case 2.3.2.3.2. (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NOT (EQUAL (ADD1 (ADD1 W)) 0)) (NUMBERP Z) (LESSP (ADD1 W) Z) (LISTP X) (NOT (EQUAL (ADD1 W) 0)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE (ADD1 W) Z)))) (EQUAL (DIFFERENCE (ADD1 W) Z) (SUB1 (DIFFERENCE (ADD1 (ADD1 W)) Z)))), which further simplifies, appealing to the lemma SUB1-ADD1, and unfolding the functions LESSP and DIFFERENCE, to two new goals: Case 2.3.2.3.2.2. (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (LISTP X) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which has an irrelevant term in it. By eliminating the term we get: (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which we will finally name *1.1. Case 2.3.2.3.2.1. (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (LISTP X) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (EQUAL (SUB1 Z) 0)) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (ADD1 W)))). But this finally simplifies, using linear arithmetic, to: T. Case 2.3.2.3.1. (IMPLIES (AND (NUMBERP V) (NOT (LESSP (PLUS Z V) Z)) (NOT (EQUAL (ADD1 (ADD1 (PLUS Z V))) 0)) (NUMBERP Z) (LESSP (ADD1 (PLUS Z V)) Z) (LISTP X) (NOT (EQUAL (ADD1 (PLUS Z V)) 0)) (EQUAL V (SUB1 (DIFFERENCE (ADD1 (PLUS Z V)) Z)))) (EQUAL (DIFFERENCE (ADD1 (PLUS Z V)) Z) (SUB1 (DIFFERENCE (ADD1 (ADD1 (PLUS Z V))) Z)))), which finally simplifies, using linear arithmetic, to: T. Case 2.3.2.2. (IMPLIES (AND (NUMBERP Z) (LESSP (SUB1 (LENGTH X)) Z) (LISTP X) (EQUAL (SUB1 (LENGTH X)) 0) (EQUAL 0 (SUB1 (DIFFERENCE (SUB1 (LENGTH X)) Z))) (NOT (EQUAL Z 0))) (EQUAL 0 (SUB1 0))), which finally simplifies, expanding EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 2.3.2.1. (IMPLIES (AND (NUMBERP Z) (LESSP (SUB1 (LENGTH X)) Z) (LISTP X) (EQUAL (SUB1 (LENGTH X)) 0) (EQUAL 0 (SUB1 (DIFFERENCE (SUB1 (LENGTH X)) Z))) (EQUAL Z 0)) (EQUAL 0 (SUB1 (LENGTH X)))), which finally simplifies, obviously, to: T. Case 2.3.1. (IMPLIES (AND (NUMBERP I) (LESSP (LENGTH (CDR A)) I) (LISTP A) (LISTP (CDR A)) (EQUAL (DIFFERENCE (SUB1 (LENGTH (CDR A))) I) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I))) (EQUAL I 0)) (EQUAL (DIFFERENCE (LENGTH (CDR A)) I) (SUB1 (ADD1 (LENGTH (CDR A)))))). But this again simplifies, using linear arithmetic, to: T. Case 2.2. (IMPLIES (AND (NOT (LESSP I (LENGTH A))) (LISTP A) (EQUAL (DIFFERENCE (LENGTH (CDR A)) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I)))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))), which again simplifies, applying SUB1-ADD1 and EQUAL-LENGTH-0, and opening up LENGTH, LESSP, DIFFERENCE, SUB1, and EQUAL, to the new conjecture: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (LISTP A) (LISTP (CDR A)) (EQUAL (DIFFERENCE (SUB1 (LENGTH (CDR A))) I) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I)))) (EQUAL (DIFFERENCE (LENGTH (CDR A)) I) (SUB1 (DIFFERENCE (LENGTH (CDR A)) (SUB1 I))))). Applying the lemma SUB1-ELIM, replace I by (ADD1 X) to eliminate (SUB1 I). We use the type restriction lemma noted when SUB1 was introduced to restrict the new variable. We would thus like to prove: (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (NOT (LESSP X (LENGTH (CDR A)))) (LISTP A) (LISTP (CDR A)) (EQUAL (DIFFERENCE (SUB1 (LENGTH (CDR A))) (ADD1 X)) (SUB1 (DIFFERENCE (LENGTH (CDR A)) (ADD1 X))))) (EQUAL (DIFFERENCE (LENGTH (CDR A)) (ADD1 X)) (SUB1 (DIFFERENCE (LENGTH (CDR A)) X)))), which further simplifies, rewriting with SUB1-ADD1 and EQUAL-LENGTH-0, and unfolding DIFFERENCE and EQUAL, to the following three new conjectures: Case 2.2.3. (IMPLIES (AND (NUMBERP X) (NOT (LESSP X (LENGTH (CDR A)))) (LISTP A) (LISTP (CDR A)) (NOT (EQUAL (SUB1 (LENGTH (CDR A))) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 (LENGTH (CDR A)))) X) (SUB1 (DIFFERENCE (SUB1 (LENGTH (CDR A))) X)))) (EQUAL (DIFFERENCE (SUB1 (LENGTH (CDR A))) X) (SUB1 (DIFFERENCE (LENGTH (CDR A)) X)))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS V Z) to eliminate (CDR A) and (CAR A). We must thus prove: (IMPLIES (AND (NUMBERP X) (NOT (LESSP X (LENGTH Z))) (LISTP Z) (NOT (EQUAL (SUB1 (LENGTH Z)) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 (LENGTH Z))) X) (SUB1 (DIFFERENCE (SUB1 (LENGTH Z)) X)))) (EQUAL (DIFFERENCE (SUB1 (LENGTH Z)) X) (SUB1 (DIFFERENCE (LENGTH Z) X)))). We will try to prove the above formula by generalizing it, replacing (LENGTH Z) by Y. We restrict the new variable by recalling the type restriction lemma noted when LENGTH was introduced. We thus obtain: (IMPLIES (AND (NUMBERP Y) (NUMBERP X) (NOT (LESSP X Y)) (LISTP Z) (NOT (EQUAL (SUB1 Y) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 Y)) X) (SUB1 (DIFFERENCE (SUB1 Y) X)))) (EQUAL (DIFFERENCE (SUB1 Y) X) (SUB1 (DIFFERENCE Y X)))). Applying the lemmas SUB1-ELIM and DIFFERENCE-ELIM, replace Y by (ADD1 V) to eliminate (SUB1 Y), V by (ADD1 W) to eliminate (SUB1 V), and W by (PLUS X V) to eliminate (DIFFERENCE W X). We employ the type restriction lemma noted when SUB1 was introduced and the type restriction lemma noted when DIFFERENCE was introduced to restrict the new variables. We would thus like to prove the following three new conjectures: Case 2.2.3.3. (IMPLIES (AND (EQUAL Y 0) (NUMBERP Y) (NUMBERP X) (NOT (LESSP X Y)) (LISTP Z) (NOT (EQUAL (SUB1 Y) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 Y)) X) (SUB1 (DIFFERENCE (SUB1 Y) X)))) (EQUAL (DIFFERENCE (SUB1 Y) X) (SUB1 (DIFFERENCE Y X)))). This finally simplifies, expanding the definitions of NUMBERP, EQUAL, LESSP, and SUB1, to: T. Case 2.2.3.2. (IMPLIES (AND (LESSP W X) (NUMBERP W) (NOT (EQUAL (ADD1 (ADD1 W)) 0)) (NUMBERP X) (NOT (LESSP X (ADD1 (ADD1 W)))) (LISTP Z) (NOT (EQUAL (ADD1 W) 0)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE (ADD1 W) X)))) (EQUAL (DIFFERENCE (ADD1 W) X) (SUB1 (DIFFERENCE (ADD1 (ADD1 W)) X)))), which further simplifies, rewriting with the lemma SUB1-ADD1, and expanding LESSP and DIFFERENCE, to: (IMPLIES (AND (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (LISTP Z) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))). Eliminate the irrelevant term. We would thus like to prove: (IMPLIES (AND (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which we will finally name *1.2. Case 2.2.3.1. (IMPLIES (AND (NUMBERP V) (NOT (LESSP (PLUS X V) X)) (NOT (EQUAL (ADD1 (ADD1 (PLUS X V))) 0)) (NUMBERP X) (NOT (LESSP X (ADD1 (ADD1 (PLUS X V))))) (LISTP Z) (NOT (EQUAL (ADD1 (PLUS X V)) 0)) (EQUAL V (SUB1 (DIFFERENCE (ADD1 (PLUS X V)) X)))) (EQUAL (DIFFERENCE (ADD1 (PLUS X V)) X) (SUB1 (DIFFERENCE (ADD1 (ADD1 (PLUS X V))) X)))). However this finally simplifies, using linear arithmetic, to: T. Case 2.2.2. (IMPLIES (AND (NUMBERP X) (NOT (LESSP X (LENGTH (CDR A)))) (LISTP A) (LISTP (CDR A)) (EQUAL (SUB1 (LENGTH (CDR A))) 0) (EQUAL 0 (SUB1 (DIFFERENCE (SUB1 (LENGTH (CDR A))) X))) (NOT (EQUAL X 0))) (EQUAL 0 (SUB1 0))), which again simplifies, using linear arithmetic, to two new conjectures: Case 2.2.2.2. (IMPLIES (AND (NOT (LESSP X 0)) (NUMBERP X) (NOT (LESSP X (LENGTH (CDR A)))) (LISTP A) (LISTP (CDR A)) (EQUAL (SUB1 (LENGTH (CDR A))) 0) (EQUAL 0 (SUB1 (DIFFERENCE 0 X))) (NOT (EQUAL X 0))) (EQUAL 0 (SUB1 0))), which finally simplifies, rewriting with the lemma EQUAL-LENGTH-0, and opening up the functions EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 2.2.2.1. (IMPLIES (AND (LESSP 0 X) (NUMBERP X) (NOT (LESSP X (LENGTH (CDR A)))) (LISTP A) (LISTP (CDR A)) (EQUAL (SUB1 (LENGTH (CDR A))) 0) (EQUAL 0 (SUB1 (DIFFERENCE 0 X))) (NOT (EQUAL X 0))) (EQUAL 0 (SUB1 0))), which finally simplifies, rewriting with EQUAL-LENGTH-0, and opening up the definitions of EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 2.2.1. (IMPLIES (AND (NUMBERP X) (NOT (LESSP X (LENGTH (CDR A)))) (LISTP A) (LISTP (CDR A)) (EQUAL (SUB1 (LENGTH (CDR A))) 0) (EQUAL 0 (SUB1 (DIFFERENCE (SUB1 (LENGTH (CDR A))) X))) (EQUAL X 0)) (EQUAL 0 (SUB1 (LENGTH (CDR A))))). This again simplifies, trivially, to: T. Case 2.1. (IMPLIES (AND (LESSP (LENGTH A) I) (LISTP A) (EQUAL (DIFFERENCE (LENGTH (CDR A)) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I)))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))). However this again simplifies, applying the lemmas SUB1-ADD1 and EQUAL-LENGTH-0, and expanding the definitions of LENGTH, LESSP, DIFFERENCE, SUB1, and EQUAL, to the conjecture: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (LESSP (LENGTH (CDR A)) (SUB1 I)) (LISTP A) (LISTP (CDR A)) (EQUAL (DIFFERENCE (SUB1 (LENGTH (CDR A))) I) (SUB1 (DIFFERENCE (LENGTH (CDR A)) I)))) (EQUAL (DIFFERENCE (LENGTH (CDR A)) I) (SUB1 (DIFFERENCE (LENGTH (CDR A)) (SUB1 I))))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A). This generates: (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I) (LESSP (LENGTH X) (SUB1 I)) (LISTP X) (EQUAL (DIFFERENCE (SUB1 (LENGTH X)) I) (SUB1 (DIFFERENCE (LENGTH X) I)))) (EQUAL (DIFFERENCE (LENGTH X) I) (SUB1 (DIFFERENCE (LENGTH X) (SUB1 I))))). Appealing to the lemma SUB1-ELIM, we now replace I by (ADD1 Z) to eliminate (SUB1 I). We rely upon the type restriction lemma noted when SUB1 was introduced to constrain the new variable. This generates the conjecture: (IMPLIES (AND (NUMBERP Z) (NOT (EQUAL (ADD1 Z) 0)) (LESSP (LENGTH X) Z) (LISTP X) (EQUAL (DIFFERENCE (SUB1 (LENGTH X)) (ADD1 Z)) (SUB1 (DIFFERENCE (LENGTH X) (ADD1 Z))))) (EQUAL (DIFFERENCE (LENGTH X) (ADD1 Z)) (SUB1 (DIFFERENCE (LENGTH X) Z)))). However this further simplifies, appealing to the lemmas SUB1-ADD1 and EQUAL-LENGTH-0, and unfolding the definitions of DIFFERENCE and EQUAL, to three new formulas: Case 2.1.3. (IMPLIES (AND (NUMBERP Z) (LESSP (LENGTH X) Z) (LISTP X) (NOT (EQUAL (SUB1 (LENGTH X)) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 (LENGTH X))) Z) (SUB1 (DIFFERENCE (SUB1 (LENGTH X)) Z)))) (EQUAL (DIFFERENCE (SUB1 (LENGTH X)) Z) (SUB1 (DIFFERENCE (LENGTH X) Z)))), which we generalize by replacing (LENGTH X) by Y. We restrict the new variable by recalling the type restriction lemma noted when LENGTH was introduced. We would thus like to prove: (IMPLIES (AND (NUMBERP Y) (NUMBERP Z) (LESSP Y Z) (LISTP X) (NOT (EQUAL (SUB1 Y) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 Y)) Z) (SUB1 (DIFFERENCE (SUB1 Y) Z)))) (EQUAL (DIFFERENCE (SUB1 Y) Z) (SUB1 (DIFFERENCE Y Z)))). Applying the lemmas SUB1-ELIM and DIFFERENCE-ELIM, replace Y by (ADD1 V) to eliminate (SUB1 Y), V by (ADD1 W) to eliminate (SUB1 V), and W by (PLUS Z V) to eliminate (DIFFERENCE W Z). We rely upon the type restriction lemma noted when SUB1 was introduced and the type restriction lemma noted when DIFFERENCE was introduced to restrict the new variables. This produces the following three new conjectures: Case 2.1.3.3. (IMPLIES (AND (EQUAL Y 0) (NUMBERP Y) (NUMBERP Z) (LESSP Y Z) (LISTP X) (NOT (EQUAL (SUB1 Y) 0)) (EQUAL (DIFFERENCE (SUB1 (SUB1 Y)) Z) (SUB1 (DIFFERENCE (SUB1 Y) Z)))) (EQUAL (DIFFERENCE (SUB1 Y) Z) (SUB1 (DIFFERENCE Y Z)))). This finally simplifies, unfolding the definitions of NUMBERP, EQUAL, LESSP, and SUB1, to: T. Case 2.1.3.2. (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NOT (EQUAL (ADD1 (ADD1 W)) 0)) (NUMBERP Z) (LESSP (ADD1 (ADD1 W)) Z) (LISTP X) (NOT (EQUAL (ADD1 W) 0)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE (ADD1 W) Z)))) (EQUAL (DIFFERENCE (ADD1 W) Z) (SUB1 (DIFFERENCE (ADD1 (ADD1 W)) Z)))), which further simplifies, rewriting with SUB1-ADD1, and opening up the functions LESSP and DIFFERENCE, to: (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (LISTP X) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which has an irrelevant term in it. By eliminating the term we get: (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which we will finally name *1.3. Case 2.1.3.1. (IMPLIES (AND (NUMBERP V) (NOT (LESSP (PLUS Z V) Z)) (NOT (EQUAL (ADD1 (ADD1 (PLUS Z V))) 0)) (NUMBERP Z) (LESSP (ADD1 (ADD1 (PLUS Z V))) Z) (LISTP X) (NOT (EQUAL (ADD1 (PLUS Z V)) 0)) (EQUAL V (SUB1 (DIFFERENCE (ADD1 (PLUS Z V)) Z)))) (EQUAL (DIFFERENCE (ADD1 (PLUS Z V)) Z) (SUB1 (DIFFERENCE (ADD1 (ADD1 (PLUS Z V))) Z)))). However this finally simplifies, using linear arithmetic, to: T. Case 2.1.2. (IMPLIES (AND (NUMBERP Z) (LESSP (LENGTH X) Z) (LISTP X) (EQUAL (SUB1 (LENGTH X)) 0) (EQUAL 0 (SUB1 (DIFFERENCE (SUB1 (LENGTH X)) Z))) (NOT (EQUAL Z 0))) (EQUAL 0 (SUB1 0))), which again simplifies, using linear arithmetic, to two new conjectures: Case 2.1.2.2. (IMPLIES (AND (NOT (LESSP Z 0)) (NUMBERP Z) (LESSP (LENGTH X) Z) (LISTP X) (EQUAL (SUB1 (LENGTH X)) 0) (EQUAL 0 (SUB1 (DIFFERENCE 0 Z))) (NOT (EQUAL Z 0))) (EQUAL 0 (SUB1 0))), which finally simplifies, rewriting with the lemma EQUAL-LENGTH-0, and opening up the functions EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 2.1.2.1. (IMPLIES (AND (LESSP 0 Z) (NUMBERP Z) (LESSP (LENGTH X) Z) (LISTP X) (EQUAL (SUB1 (LENGTH X)) 0) (EQUAL 0 (SUB1 (DIFFERENCE 0 Z))) (NOT (EQUAL Z 0))) (EQUAL 0 (SUB1 0))), which finally simplifies, applying EQUAL-LENGTH-0, and opening up the definitions of EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 2.1.1. (IMPLIES (AND (NUMBERP Z) (LESSP (LENGTH X) Z) (LISTP X) (EQUAL (SUB1 (LENGTH X)) 0) (EQUAL 0 (SUB1 (DIFFERENCE (SUB1 (LENGTH X)) Z))) (EQUAL Z 0)) (EQUAL 0 (SUB1 (LENGTH X)))). This finally simplifies, obviously, to: T. Case 1. (IMPLIES (NOT (LISTP A)) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))). This simplifies, using linear arithmetic, to the following three new goals: Case 1.3. (IMPLIES (AND (LESSP (LENGTH A) (ADD1 I)) (NOT (LISTP A))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))). This again simplifies, opening up the definitions of LENGTH, EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 1.2. (IMPLIES (AND (NOT (LESSP I (LENGTH A))) (NOT (LISTP A))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))), which again simplifies, opening up the definitions of LENGTH, EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. Case 1.1. (IMPLIES (AND (LESSP (LENGTH A) I) (NOT (LISTP A))) (EQUAL (DIFFERENCE (LENGTH A) (ADD1 I)) (SUB1 (DIFFERENCE (LENGTH A) I)))), which again simplifies, unfolding the functions LENGTH, EQUAL, LESSP, DIFFERENCE, and SUB1, to: T. So next consider: (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which we named *1.3 above. Let us appeal to the induction principle. There are eight plausible inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (OR (EQUAL Z 0) (NOT (NUMBERP Z))) (p W Z)) (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (OR (EQUAL W 0) (NOT (NUMBERP W)))) (p W Z)) (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (p (SUB1 W) (SUB1 Z))) (p W Z))). Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions of OR and NOT can be used to prove that the measure (COUNT W) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for Z. The above induction scheme produces the following seven new goals: Case 7. (IMPLIES (AND (OR (EQUAL Z 0) (NOT (NUMBERP Z))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))). This simplifies, opening up the functions NOT and OR, to: T. Case 6. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (OR (EQUAL W 0) (NOT (NUMBERP W))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))). This simplifies, unfolding the definitions of NOT, OR, EQUAL, LESSP, NUMBERP, DIFFERENCE, and SUB1, to: T. Case 5. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 Z))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))). This simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 Z))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, expanding NOT, OR, EQUAL, and NUMBERP, to: T. Case 4. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (EQUAL (SUB1 (SUB1 Z)) 0) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, using linear arithmetic, to: T. Case 3. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 (SUB1 (SUB1 Z))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 (SUB1 (SUB1 Z))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))). This again simplifies, unfolding NOT, OR, EQUAL, and NUMBERP, to: T. Case 2. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, using linear arithmetic, to four new goals: Case 2.4. (IMPLIES (AND (LESSP (SUB1 W) (SUB1 Z)) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, unfolding the functions NOT, OR, LESSP, and DIFFERENCE, to: T. Case 2.3. (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, unfolding the definitions of NOT, OR, EQUAL, and NUMBERP, to: T. Case 2.2. (IMPLIES (AND (NOT (LESSP (SUB1 (SUB1 Z)) (SUB1 W))) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, opening up the definitions of NOT, OR, LESSP, and DIFFERENCE, to: T. Case 2.1. (IMPLIES (AND (LESSP (SUB1 W) (SUB1 (SUB1 Z))) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, expanding NOT, OR, LESSP, and DIFFERENCE, to: T. Case 1. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (NOT (EQUAL (SUB1 Z) 0)) (LESSP W (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z))))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, expanding the definitions of NOT, OR, LESSP, and DIFFERENCE, to: T. That finishes the proof of *1.3. So next consider: (IMPLIES (AND (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which we named *1.2 above. We will try to prove it by induction. There are eight plausible inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (OR (EQUAL X 0) (NOT (NUMBERP X))) (p W X)) (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (OR (EQUAL W 0) (NOT (NUMBERP W)))) (p W X)) (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (p (SUB1 W) (SUB1 X))) (p W X))). Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions of OR and NOT inform us that the measure (COUNT W) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for X. The above induction scheme generates seven new goals: Case 7. (IMPLIES (AND (OR (EQUAL X 0) (NOT (NUMBERP X))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which simplifies, unfolding NOT and OR, to: T. Case 6. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (OR (EQUAL W 0) (NOT (NUMBERP W))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which simplifies, expanding NOT, OR, EQUAL, LESSP, NUMBERP, DIFFERENCE, and SUB1, to: T. Case 5. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 X))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 X))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))). But this again simplifies, opening up the functions NOT, OR, EQUAL, and NUMBERP, to: T. Case 4. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (EQUAL (SUB1 (SUB1 X)) 0) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which simplifies, expanding the functions NOT, OR, LESSP, and EQUAL, to: T. Case 3. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (LESSP (SUB1 (SUB1 (SUB1 X))) (SUB1 W)) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (LESSP (SUB1 (SUB1 (SUB1 X))) (SUB1 W)) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))). However this again simplifies, expanding NOT, OR, EQUAL, and NUMBERP, to: T. Case 2. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 X)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 X)))))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which simplifies, using linear arithmetic, to four new conjectures: Case 2.4. (IMPLIES (AND (LESSP (SUB1 W) (SUB1 X)) (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 X)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 X)))))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which again simplifies, expanding NOT, OR, LESSP, and DIFFERENCE, to: T. Case 2.3. (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 X)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 X)))))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which again simplifies, opening up the functions NOT, OR, EQUAL, and NUMBERP, to: T. Case 2.2. (IMPLIES (AND (NOT (LESSP (SUB1 (SUB1 X)) (SUB1 W))) (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 X)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 X)))))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which again simplifies, expanding NOT, OR, LESSP, and DIFFERENCE, to: T. Case 2.1. (IMPLIES (AND (LESSP (SUB1 W) (SUB1 (SUB1 X))) (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 X)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 X)))))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which again simplifies, opening up NOT, OR, LESSP, and DIFFERENCE, to: T. Case 1. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 X))) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 (SUB1 X)))))) (LESSP W X) (NUMBERP W) (NUMBERP X) (NOT (EQUAL X 0)) (NOT (EQUAL (SUB1 X) 0)) (NOT (LESSP (SUB1 (SUB1 X)) W)) (EQUAL (DIFFERENCE W X) (SUB1 (DIFFERENCE W (SUB1 X))))) (EQUAL (DIFFERENCE W (SUB1 X)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 X)))))), which simplifies, expanding NOT, OR, LESSP, and DIFFERENCE, to: T. That finishes the proof of *1.2. So let us turn our attention to: (IMPLIES (AND (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), named *1.1 above. We will try to prove it by induction. Eight inductions are suggested by terms in the conjecture. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (OR (EQUAL Z 0) (NOT (NUMBERP Z))) (p W Z)) (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (OR (EQUAL W 0) (NOT (NUMBERP W)))) (p W Z)) (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (p (SUB1 W) (SUB1 Z))) (p W Z))). Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions of OR and NOT inform us that the measure (COUNT W) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for Z. The above induction scheme generates seven new goals: Case 7. (IMPLIES (AND (OR (EQUAL Z 0) (NOT (NUMBERP Z))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, unfolding NOT and OR, to: T. Case 6. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (OR (EQUAL W 0) (NOT (NUMBERP W))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, unfolding NOT, OR, EQUAL, LESSP, NUMBERP, DIFFERENCE, and SUB1, to: T. Case 5. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 Z))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 Z))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))). But this again simplifies, opening up NOT, OR, EQUAL, and NUMBERP, to: T. Case 4. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 (SUB1 Z)))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, using linear arithmetic, to the goal: (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (LESSP (SUB1 W) (SUB1 (SUB1 Z)))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))). This again simplifies, unfolding the definitions of NOT, OR, EQUAL, and NUMBERP, to: T. Case 3. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, using linear arithmetic, to four new formulas: Case 3.4. (IMPLIES (AND (LESSP (SUB1 W) (SUB1 Z)) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, unfolding NOT, OR, LESSP, and DIFFERENCE, to: T. Case 3.3. (IMPLIES (AND (EQUAL W 0) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, unfolding NOT, OR, EQUAL, and NUMBERP, to: T. Case 3.2. (IMPLIES (AND (NOT (LESSP (SUB1 (SUB1 Z)) (SUB1 W))) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, expanding the functions NOT, OR, LESSP, and DIFFERENCE, to: T. Case 3.1. (IMPLIES (AND (LESSP (SUB1 W) (SUB1 (SUB1 Z))) (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (NOT (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which again simplifies, opening up the functions NOT, OR, LESSP, and DIFFERENCE, to: T. Case 2. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (EQUAL (SUB1 (SUB1 Z)) 0) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, expanding NOT, OR, LESSP, DIFFERENCE, and EQUAL, to: (IMPLIES (AND (NOT (EQUAL W 0)) (EQUAL (SUB1 (SUB1 Z)) 0) (LESSP (SUB1 W) (SUB1 Z)) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP (SUB1 W) (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))) (SUB1 W))). This again simplifies, using linear arithmetic, to: T. Case 1. (IMPLIES (AND (NOT (OR (EQUAL Z 0) (NOT (NUMBERP Z)))) (NOT (OR (EQUAL W 0) (NOT (NUMBERP W)))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 (SUB1 Z)))))) (LESSP W Z) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP W (SUB1 Z)) (EQUAL (DIFFERENCE W Z) (SUB1 (DIFFERENCE W (SUB1 Z)))) (NOT (EQUAL (SUB1 Z) 0))) (EQUAL (DIFFERENCE W (SUB1 Z)) (SUB1 (DIFFERENCE W (SUB1 (SUB1 Z)))))), which simplifies, opening up the functions NOT, OR, LESSP, and DIFFERENCE, to two new conjectures: Case 1.2. (IMPLIES (AND (NOT (EQUAL W 0)) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 (SUB1 Z)))))) (LESSP (SUB1 W) (SUB1 Z)) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP (SUB1 W) (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))))) (NOT (EQUAL (SUB1 Z) 0)) (NOT (EQUAL (SUB1 (SUB1 Z)) 0))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 (SUB1 Z))))))), which again simplifies, trivially, to: T. Case 1.1. (IMPLIES (AND (NOT (EQUAL W 0)) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 (SUB1 Z)))))) (LESSP (SUB1 W) (SUB1 Z)) (NUMBERP W) (NUMBERP Z) (NOT (EQUAL Z 0)) (LESSP (SUB1 W) (SUB1 (SUB1 Z))) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 Z)) (SUB1 (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))))) (NOT (EQUAL (SUB1 Z) 0)) (EQUAL (SUB1 (SUB1 Z)) 0)) (EQUAL (DIFFERENCE (SUB1 W) (SUB1 (SUB1 Z))) (SUB1 W))). This again simplifies, using linear arithmetic, to: T. That finishes the proof of *1.1, which finishes the proof of *1. Q.E.D. [ 0.0 0.4 0.1 ] DIFFERENCE-ADD1-NEW (PROVE-LEMMA LENGTH-BIG-ADD-ARRAY-LOOP (REWRITE) (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))) ((INDUCT (BIG-ADD-ARRAY-LOOP I A B N C BASE)))) This conjecture can be simplified, using the abbreviations ZEROP, IMPLIES, NOT, OR, AND, PLUS-ADD1-1, GET-IS-CAR-NTH-CDR, UNTAG, and TAG, to two new goals: Case 2. (IMPLIES (AND (ZEROP (SUB1 N)) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))), which simplifies, rewriting with COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, GET-IS-CAR-NTH-CDR, and LENGTH-PUT, and opening up the definitions of ZEROP, TAG, UNTAG, EQUAL, and BIG-ADD-ARRAY-LOOP, to: T. Case 1. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NUMBERP (SUB1 N)) (IMPLIES (AND (LESSP (ADD1 I) (LENGTH (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A))) (NOT (LESSP (LENGTH (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A)) (ADD1 (PLUS I (SUB1 N)))))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A) B (SUB1 N) (NOT (LESSP (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) BASE)) (LENGTH (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A)))) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))). This simplifies, applying COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, LENGTH-PUT, SUB1-ADD1, EQUAL-LENGTH-0, PLUS-0, GET-IS-CAR-NTH-CDR, SUB1-NNUMBERP, and CDR-CONS, and unfolding the definitions of LESSP, NOT, AND, IMPLIES, LENGTH, EQUAL, ZEROP, PUT, TAG, UNTAG, NTH-CDR, and BIG-ADD-ARRAY-LOOP, to six new goals: Case 1.6. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (NUMBERP I)) (NOT (LESSP 0 (SUB1 (LENGTH A)))) (LISTP A) (NOT (NUMBERP N)) (NOT (LESSP (LENGTH A) 0))) (EQUAL (ADD1 (LENGTH (CDR A))) (LENGTH A))), which again simplifies, applying SUB1-NNUMBERP, and unfolding EQUAL, to: T. Case 1.5. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (NUMBERP I)) (NOT (LESSP 0 (SUB1 (LENGTH A)))) (LISTP A) (NUMBERP N) (NOT (LESSP (LENGTH A) N))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))). This again simplifies, applying EQUAL-LENGTH-0, COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, GET-IS-CAR-NTH-CDR, and CDR-CONS, and unfolding the functions EQUAL, LESSP, PUT, TAG, UNTAG, NTH-CDR, SUB1, BIG-ADD-ARRAY-LOOP, and LENGTH, to: (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (NUMBERP I)) (EQUAL (SUB1 (LENGTH A)) 0) (LISTP A) (NUMBERP N) (EQUAL N 0)) (EQUAL (ADD1 (LENGTH (CDR A))) (LENGTH A))), which again simplifies, opening up the definitions of SUB1 and EQUAL, to: T. Case 1.4. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I (SUB1 (LENGTH A)))) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))), which again simplifies, using linear arithmetic, to the goal: (IMPLIES (AND (EQUAL (LENGTH A) (PLUS 1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I (SUB1 (PLUS 1 I)))) (LESSP I (PLUS 1 I)) (NOT (LESSP (PLUS 1 I) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (PLUS 1 I))). This again simplifies, rewriting with PLUS-0, PLUS-ADD1-1, SUB1-ADD1, COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, GET-IS-CAR-NTH-CDR, SUB1-NNUMBERP, EQUAL-LENGTH-1, and EQUAL-PLUS-0, and expanding ZEROP, LESSP, PLUS, PUT, TAG, UNTAG, NTH-CDR, EQUAL, BIG-ADD-ARRAY-LOOP, and SUB1, to the following eight new goals: Case 1.4.8. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (EQUAL I 0) (NOT (NUMBERP N)) (NOT (LESSP 1 0)) (NOT (LISTP A))) (NOT (LISTP (CDR (LIST (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE))))))). But this again simplifies, expanding LENGTH and EQUAL, to: T. Case 1.4.7. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (EQUAL I 0) (NOT (NUMBERP N)) (NOT (LESSP 1 0)) (LISTP A)) (NOT (LISTP (CDR (CONS (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE)) (CDR A)))))), which again simplifies, applying EQUAL-LENGTH-1 and SUB1-NNUMBERP, and expanding EQUAL, to: T. Case 1.4.6. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (EQUAL I 0) (NUMBERP N) (NOT (LESSP 1 N))) (NOT (LISTP (CDR (BIG-ADD-ARRAY-LOOP 0 A B N C BASE))))). But this again simplifies, rewriting with EQUAL-LENGTH-1, COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, GET-IS-CAR-NTH-CDR, and CDR-CONS, and expanding the definitions of NUMBERP, LESSP, SUB1, EQUAL, PUT, TAG, UNTAG, NTH-CDR, and BIG-ADD-ARRAY-LOOP, to: T. Case 1.4.5. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (EQUAL I 0) (NOT (NUMBERP N)) (NOT (LISTP A))) (NOT (LISTP (CDR (LIST (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE))))))). However this again simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 1.4.4. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (EQUAL I 0) (NOT (NUMBERP N)) (LISTP A)) (NOT (LISTP (CDR (CONS (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE)) (CDR A)))))), which again simplifies, rewriting with the lemmas EQUAL-LENGTH-1 and SUB1-NNUMBERP, and expanding the definition of EQUAL, to: T. Case 1.4.3. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (EQUAL I 0) (EQUAL N 0) (NOT (LISTP A))) (NOT (LISTP (CDR (LIST (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE))))))), which again simplifies, unfolding the definitions of LENGTH and EQUAL, to: T. Case 1.4.2. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (EQUAL I 0) (EQUAL N 0) (LISTP A)) (NOT (LISTP (CDR (CONS (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR A) (CADAR B)) BASE)) (CDR A)))))), which again simplifies, applying EQUAL-LENGTH-1, and opening up the functions SUB1 and EQUAL, to: T. Case 1.4.1. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (NOT (LESSP I (SUB1 (PLUS I N))))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (ADD1 I))). Appealing to the lemma SUB1-ELIM, we now replace N by (ADD1 X) to eliminate (SUB1 N). We employ the type restriction lemma noted when SUB1 was introduced to constrain the new variable. This generates three new conjectures: Case 1.4.1.3. (IMPLIES (AND (EQUAL N 0) (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (NOT (LESSP I (SUB1 (PLUS I N))))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (ADD1 I))), which further simplifies, expanding the definitions of SUB1 and EQUAL, to: T. Case 1.4.1.2. (IMPLIES (AND (NOT (NUMBERP N)) (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL (SUB1 N) 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (NOT (LESSP I (SUB1 (PLUS I N))))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (ADD1 I))), which further simplifies, applying SUB1-NNUMBERP, and expanding the function EQUAL, to: T. Case 1.4.1.1. (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (EQUAL (LENGTH A) (ADD1 I)) (NOT (EQUAL X 0)) (NUMBERP I) (NOT (LESSP I I)) (LESSP (SUB1 I) I) (NOT (LESSP I (SUB1 (PLUS I (ADD1 X)))))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B (ADD1 X) C BASE)) (ADD1 I))). This further simplifies, using linear arithmetic, to: T. Case 1.3. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (LESSP (SUB1 (LENGTH A)) (PLUS I (SUB1 N))) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP N 1) (NOT (EQUAL (SUB1 N) 0)) (LESSP (SUB1 (LENGTH A)) (PLUS I (SUB1 N))) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))). But this again simplifies, rewriting with the lemmas EQUAL-LESSP-N-1 and SUB1-NNUMBERP, and unfolding SUB1 and EQUAL, to: T. Case 1.2. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 N) T BASE)) (LENGTH A)) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))), which again simplifies, applying COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and GET-IS-CAR-NTH-CDR, and unfolding the definitions of TAG, UNTAG, and BIG-ADD-ARRAY-LOOP, to: T. Case 1.1. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 N) F BASE)) (LENGTH A)) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))). However this again simplifies, unfolding the definition of REMAINDER, to: (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 N) F BASE)) (LENGTH A)) (LESSP I (LENGTH A)) (NOT (LESSP (LENGTH A) (PLUS I N)))) (EQUAL (LENGTH (BIG-ADD-ARRAY-LOOP I A B N C BASE)) (LENGTH A))). However this again simplifies, applying COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and GET-IS-CAR-NTH-CDR, and expanding the functions TAG, REMAINDER, UNTAG, and BIG-ADD-ARRAY-LOOP, to: T. Q.E.D. [ 0.0 2.0 0.0 ] LENGTH-BIG-ADD-ARRAY-LOOP (PROVE-LEMMA CAR-NTH-CDR-PUT (REWRITE) (IMPLIES (AND (NUMBERP I) (NUMBERP J)) (EQUAL (CAR (NTH-CDR I (PUT VAL J A))) (IF (EQUAL I J) VAL (CAR (NTH-CDR I A)))))) This formula simplifies, obviously, to the following two new goals: Case 2. (IMPLIES (AND (NUMBERP I) (NUMBERP J) (NOT (EQUAL I J))) (EQUAL (CAR (NTH-CDR I (PUT VAL J A))) (CAR (NTH-CDR I A)))). Give the above formula the name *1. Case 1. (IMPLIES (AND (NUMBERP I) (NUMBERP J) (EQUAL I J)) (EQUAL (CAR (NTH-CDR I (PUT VAL J A))) VAL)). This again simplifies, obviously, to: (IMPLIES (NUMBERP J) (EQUAL (CAR (NTH-CDR J (PUT VAL J A))) VAL)), which we would normally push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it. So now let us return to: (IMPLIES (AND (NUMBERP I) (NUMBERP J)) (EQUAL (CAR (NTH-CDR I (PUT VAL J A))) (IF (EQUAL I J) VAL (CAR (NTH-CDR I A))))), named *1. Let us appeal to the induction principle. Three inductions are suggested by terms in the conjecture. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP I) (p I VAL J A)) (IMPLIES (AND (NOT (ZEROP I)) (p (SUB1 I) VAL (SUB1 J) (CDR A))) (p I VAL J A))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instances chosen for J and A. The above induction scheme produces two new goals: Case 2. (IMPLIES (AND (ZEROP I) (NUMBERP I) (NUMBERP J)) (EQUAL (CAR (NTH-CDR I (PUT VAL J A))) (IF (EQUAL I J) VAL (CAR (NTH-CDR I A))))), which simplifies, unfolding the definitions of ZEROP, NUMBERP, PUT, EQUAL, and NTH-CDR, to six new conjectures: Case 2.6. (IMPLIES (AND (EQUAL I 0) (NUMBERP J) (NOT (EQUAL 0 J)) (NOT (EQUAL J 0))) (EQUAL (CAR (CONS (CAR A) (PUT VAL (SUB1 J) (CDR A)))) (CAR A))), which again simplifies, appealing to the lemma CAR-CONS, to: T. Case 2.5. (IMPLIES (AND (EQUAL I 0) (NUMBERP J) (NOT (EQUAL 0 J)) (EQUAL J 0) (LISTP A)) (EQUAL (CAR (CONS VAL (CDR A))) (CAR A))), which again simplifies, obviously, to: T. Case 2.4. (IMPLIES (AND (EQUAL I 0) (NUMBERP J) (NOT (EQUAL 0 J)) (EQUAL J 0) (NOT (LISTP A))) (EQUAL (CAR (LIST VAL)) (CAR A))). This again simplifies, trivially, to: T. Case 2.3. (IMPLIES (AND (EQUAL I 0) (NUMBERP J) (EQUAL 0 J) (NOT (EQUAL J 0))) (EQUAL (CAR (CONS (CAR A) (PUT VAL (SUB1 J) (CDR A)))) VAL)). This again simplifies, trivially, to: T. Case 2.2. (IMPLIES (AND (EQUAL I 0) (NUMBERP J) (EQUAL 0 J) (EQUAL J 0) (LISTP A)) (EQUAL (CAR (CONS VAL (CDR A))) VAL)). This again simplifies, applying CAR-CONS, and expanding the definitions of NUMBERP and EQUAL, to: T. Case 2.1. (IMPLIES (AND (EQUAL I 0) (NUMBERP J) (EQUAL 0 J) (EQUAL J 0) (NOT (LISTP A))) (EQUAL (CAR (LIST VAL)) VAL)). This again simplifies, appealing to the lemma CAR-CONS, and unfolding NUMBERP and EQUAL, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP I)) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) (IF (EQUAL (SUB1 I) (SUB1 J)) VAL (CAR (NTH-CDR (SUB1 I) (CDR A))))) (NUMBERP I) (NUMBERP J)) (EQUAL (CAR (NTH-CDR I (PUT VAL J A))) (IF (EQUAL I J) VAL (CAR (NTH-CDR I A))))), which simplifies, opening up the definitions of ZEROP, PUT, and NTH-CDR, to 12 new formulas: Case 1.12. (IMPLIES (AND (NOT (EQUAL I 0)) (NOT (EQUAL (SUB1 I) (SUB1 J))) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A)))) (NUMBERP I) (NUMBERP J) (NOT (EQUAL I J)) (NOT (EQUAL J 0))) (EQUAL (CAR (NTH-CDR I (CONS (CAR A) (PUT VAL (SUB1 J) (CDR A))))) (CAR (NTH-CDR (SUB1 I) (CDR A))))), which again simplifies, rewriting with the lemma CDR-CONS, and unfolding NTH-CDR, to: T. Case 1.11. (IMPLIES (AND (NOT (EQUAL I 0)) (NOT (EQUAL (SUB1 I) (SUB1 J))) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A)))) (NUMBERP I) (NUMBERP J) (NOT (EQUAL I J)) (EQUAL J 0) (LISTP A)) (EQUAL (CAR (NTH-CDR I (CONS VAL (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A))))), which again simplifies, using linear arithmetic, applying CDR-CONS, LISTP-NTH-CDR, and CAR-NLISTP, and unfolding SUB1, EQUAL, PUT, NUMBERP, NTH-CDR, and LENGTH, to: T. Case 1.10. (IMPLIES (AND (NOT (EQUAL I 0)) (NOT (EQUAL (SUB1 I) (SUB1 J))) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A)))) (NUMBERP I) (NUMBERP J) (NOT (EQUAL I J)) (EQUAL J 0) (NOT (LISTP A))) (EQUAL (CAR (NTH-CDR I (LIST VAL))) (CAR (NTH-CDR (SUB1 I) (CDR A))))). This again simplifies, using linear arithmetic, applying the lemmas CDR-NLISTP, LISTP-NTH-CDR, EQUAL-LESSP-N-1, CDR-CONS, and CAR-NLISTP, and unfolding the definitions of SUB1, LISTP, EQUAL, PUT, LENGTH, ADD1, and NUMBERP, to: T. Case 1.9. (IMPLIES (AND (NOT (EQUAL I 0)) (NOT (EQUAL (SUB1 I) (SUB1 J))) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A)))) (NUMBERP I) (NUMBERP J) (EQUAL I J) (NOT (EQUAL J 0))) (EQUAL (CAR (NTH-CDR I (CONS (CAR A) (PUT VAL (SUB1 J) (CDR A))))) VAL)), which again simplifies, trivially, to: T. Case 1.8. (IMPLIES (AND (NOT (EQUAL I 0)) (NOT (EQUAL (SUB1 I) (SUB1 J))) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A)))) (NUMBERP I) (NUMBERP J) (EQUAL I J) (EQUAL J 0) (LISTP A)) (EQUAL (CAR (NTH-CDR I (CONS VAL (CDR A)))) VAL)). This again simplifies, clearly, to: T. Case 1.7. (IMPLIES (AND (NOT (EQUAL I 0)) (NOT (EQUAL (SUB1 I) (SUB1 J))) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A)))) (NUMBERP I) (NUMBERP J) (EQUAL I J) (EQUAL J 0) (NOT (LISTP A))) (EQUAL (CAR (NTH-CDR I (LIST VAL))) VAL)). This again simplifies, obviously, to: T. Case 1.6. (IMPLIES (AND (NOT (EQUAL I 0)) (EQUAL (SUB1 I) (SUB1 J)) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) VAL) (NUMBERP I) (NUMBERP J) (NOT (EQUAL I J)) (NOT (EQUAL J 0))) (EQUAL (CAR (NTH-CDR I (CONS (CAR A) (PUT VAL (SUB1 J) (CDR A))))) (CAR (NTH-CDR (SUB1 I) (CDR A))))). But this again simplifies, using linear arithmetic, to: T. Case 1.5. (IMPLIES (AND (NOT (EQUAL I 0)) (EQUAL (SUB1 I) (SUB1 J)) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) VAL) (NUMBERP I) (NUMBERP J) (NOT (EQUAL I J)) (EQUAL J 0) (LISTP A)) (EQUAL (CAR (NTH-CDR I (CONS VAL (CDR A)))) (CAR (NTH-CDR (SUB1 I) (CDR A))))), which again simplifies, applying CDR-CONS, CAR-NLISTP, and LISTP-NTH-CDR, and expanding SUB1, EQUAL, PUT, NTH-CDR, NUMBERP, LESSP, and LENGTH, to the new conjecture: (IMPLIES (AND (EQUAL (SUB1 I) 0) (LISTP (CDR A)) (EQUAL (CAR (CONS VAL (CDDR A))) VAL) (NUMBERP I) (NOT (EQUAL I 0)) (LISTP A)) (EQUAL (CADR A) (CAR (NTH-CDR (SUB1 I) (CDR A))))), which again simplifies, rewriting with the lemma CAR-CONS, and unfolding the definitions of EQUAL and NTH-CDR, to: T. Case 1.4. (IMPLIES (AND (NOT (EQUAL I 0)) (EQUAL (SUB1 I) (SUB1 J)) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) VAL) (NUMBERP I) (NUMBERP J) (NOT (EQUAL I J)) (EQUAL J 0) (NOT (LISTP A))) (EQUAL (CAR (NTH-CDR I (LIST VAL))) (CAR (NTH-CDR (SUB1 I) (CDR A))))), which again simplifies, applying CDR-NLISTP, CAR-CONS, and CDR-CONS, and unfolding SUB1, LISTP, EQUAL, PUT, NTH-CDR, NUMBERP, and CAR, to: (IMPLIES (AND (EQUAL (SUB1 I) 0) (NUMBERP I) (NOT (EQUAL I 0)) (NOT (LISTP A))) (EQUAL 0 (CAR (NTH-CDR (SUB1 I) (CDR A))))), which again simplifies, rewriting with CDR-NLISTP, and unfolding the functions NTH-CDR, CAR, and EQUAL, to: T. Case 1.3. (IMPLIES (AND (NOT (EQUAL I 0)) (EQUAL (SUB1 I) (SUB1 J)) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) VAL) (NUMBERP I) (NUMBERP J) (EQUAL I J) (NOT (EQUAL J 0))) (EQUAL (CAR (NTH-CDR I (CONS (CAR A) (PUT VAL (SUB1 J) (CDR A))))) VAL)). However this again simplifies, rewriting with CDR-CONS, and unfolding the definition of NTH-CDR, to: T. Case 1.2. (IMPLIES (AND (NOT (EQUAL I 0)) (EQUAL (SUB1 I) (SUB1 J)) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) VAL) (NUMBERP I) (NUMBERP J) (EQUAL I J) (EQUAL J 0) (LISTP A)) (EQUAL (CAR (NTH-CDR I (CONS VAL (CDR A)))) VAL)). This again simplifies, clearly, to: T. Case 1.1. (IMPLIES (AND (NOT (EQUAL I 0)) (EQUAL (SUB1 I) (SUB1 J)) (EQUAL (CAR (NTH-CDR (SUB1 I) (PUT VAL (SUB1 J) (CDR A)))) VAL) (NUMBERP I) (NUMBERP J) (EQUAL I J) (EQUAL J 0) (NOT (LISTP A))) (EQUAL (CAR (NTH-CDR I (LIST VAL))) VAL)). This again simplifies, clearly, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.1 0.0 ] CAR-NTH-CDR-PUT (PROVE-LEMMA CAR-NTH-CDR-BIG-ADD-ARRAY-LOOP (REWRITE) (IMPLIES (AND (NUMBERP K) (NUMBERP I) (LESSP K I)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR K A)))) ((INDUCT (BIG-ADD-ARRAY-LOOP I A B N C BASE)))) This formula can be simplified, using the abbreviations ZEROP, IMPLIES, NOT, OR, AND, GET-IS-CAR-NTH-CDR, UNTAG, and TAG, to the following two new conjectures: Case 2. (IMPLIES (AND (ZEROP (SUB1 N)) (NUMBERP K) (NUMBERP I) (LESSP K I)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR K A)))). This simplifies, appealing to the lemmas COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, GET-IS-CAR-NTH-CDR, and CAR-NTH-CDR-PUT, and opening up the definitions of ZEROP, TAG, UNTAG, EQUAL, and BIG-ADD-ARRAY-LOOP, to the new conjecture: (IMPLIES (AND (EQUAL (SUB1 N) 0) (NUMBERP K) (NUMBERP I) (LESSP K I) (EQUAL K I)) (EQUAL (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (CAR (NTH-CDR K A)))), which again simplifies, using linear arithmetic, to: T. Case 1. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NUMBERP (SUB1 N)) (IMPLIES (AND (NUMBERP K) (NUMBERP (ADD1 I)) (LESSP K (ADD1 I))) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A) B (SUB1 N) (NOT (LESSP (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) BASE))) (CAR (NTH-CDR K (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A))))) (NUMBERP K) (NUMBERP I) (LESSP K I)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR K A)))), which simplifies, applying SUB1-ADD1, COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-NTH-CDR-PUT, and unfolding LESSP, AND, NOT, and IMPLIES, to the following five new formulas: Case 1.5. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (EQUAL K 0)) (NOT (LESSP (SUB1 K) I)) (NUMBERP K) (NUMBERP I) (LESSP K I)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR K A)))). However this again simplifies, using linear arithmetic, to: T. Case 1.4. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (EQUAL K I)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 N) T BASE))) (CAR (NTH-CDR K A))) (NUMBERP K) (NUMBERP I) (LESSP K I)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR K A)))), which again simplifies, rewriting with COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and GET-IS-CAR-NTH-CDR, and opening up the functions TAG, UNTAG, and BIG-ADD-ARRAY-LOOP, to: T. Case 1.3. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (EQUAL K I)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 N) F BASE))) (CAR (NTH-CDR K A))) (NUMBERP K) (NUMBERP I) (LESSP K I)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR K A)))). But this again simplifies, unfolding REMAINDER, to the goal: (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (NOT (EQUAL K I)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 N) F BASE))) (CAR (NTH-CDR K A))) (NUMBERP K) (NUMBERP I) (LESSP K I)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR K A)))). However this again simplifies, applying COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and GET-IS-CAR-NTH-CDR, and opening up the functions TAG, REMAINDER, UNTAG, and BIG-ADD-ARRAY-LOOP, to: T. Case 1.2. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (EQUAL K I) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 N) T BASE))) (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE))) (NUMBERP I) (LESSP I I)) (EQUAL (CAR (NTH-CDR I (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR I A)))). However this again simplifies, using linear arithmetic, to: T. Case 1.1. (IMPLIES (AND (NOT (EQUAL (SUB1 N) 0)) (EQUAL K I) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (CAR (NTH-CDR K (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 N) F BASE))) (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE))) (NUMBERP I) (LESSP I I)) (EQUAL (CAR (NTH-CDR I (BIG-ADD-ARRAY-LOOP I A B N C BASE))) (CAR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: T. Q.E.D. [ 0.0 3.3 0.0 ] CAR-NTH-CDR-BIG-ADD-ARRAY-LOOP (PROVE-LEMMA EQUAL-NTH-CDR-NIL NIL (IMPLIES (BIGNP A BASE) (EQUAL (EQUAL NIL (NTH-CDR I A)) (EQUAL (FIX I) (LENGTH A))))) This simplifies, opening up the function FIX, to four new goals: Case 4. (IMPLIES (AND (BIGNP A BASE) (NUMBERP I) (NOT (EQUAL I (LENGTH A)))) (NOT (EQUAL NIL (NTH-CDR I A)))), which we will name *1. Case 3. (IMPLIES (AND (BIGNP A BASE) (NOT (NUMBERP I)) (NOT (EQUAL 0 (LENGTH A)))) (NOT (EQUAL NIL (NTH-CDR I A)))). However this again simplifies, applying the lemma EQUAL-LENGTH-0, and opening up NTH-CDR, to: T. Case 2. (IMPLIES (AND (BIGNP A BASE) (NUMBERP I) (EQUAL I (LENGTH A))) (EQUAL (EQUAL NIL (NTH-CDR I A)) T)), which again simplifies, clearly, to: (IMPLIES (BIGNP A BASE) (EQUAL NIL (NTH-CDR (LENGTH A) A))), which we would normally push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it. So now let us return to: (IMPLIES (BIGNP A BASE) (EQUAL (EQUAL NIL (NTH-CDR I A)) (EQUAL (FIX I) (LENGTH A)))), named *1. Let us appeal to the induction principle. Three inductions are suggested by terms in the conjecture. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (NLISTP A) (p I A BASE)) (IMPLIES (AND (NOT (NLISTP A)) (p (SUB1 I) (CDR A) BASE)) (p I A BASE))). Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP establish that the measure (COUNT A) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for I. The above induction scheme leads to three new formulas: Case 3. (IMPLIES (AND (NLISTP A) (BIGNP A BASE)) (EQUAL (EQUAL NIL (NTH-CDR I A)) (EQUAL (FIX I) (LENGTH A)))), which simplifies, opening up NLISTP, BIGNP, FIX, and LENGTH, to three new conjectures: Case 3.3. (IMPLIES (AND (NOT (LISTP A)) (EQUAL A NIL) (NUMBERP I) (NOT (EQUAL I 0))) (NOT (EQUAL NIL (NTH-CDR I NIL)))), which again simplifies, opening up LISTP, to: (IMPLIES (AND (NUMBERP I) (NOT (EQUAL I 0))) (NOT (EQUAL NIL (NTH-CDR I NIL)))). Give the above formula the name *1.1. Case 3.2. (IMPLIES (AND (NOT (LISTP A)) (EQUAL A NIL) (NOT (NUMBERP I))) (EQUAL (EQUAL NIL (NTH-CDR I NIL)) T)). This again simplifies, expanding the definitions of LISTP, NTH-CDR, and EQUAL, to: T. Case 3.1. (IMPLIES (AND (NOT (LISTP A)) (EQUAL A NIL) (EQUAL I 0)) (EQUAL (EQUAL NIL (NTH-CDR I NIL)) T)), which again simplifies, opening up the functions LISTP, NTH-CDR, and EQUAL, to: T. Case 2. (IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR A) BASE)) (BIGNP A BASE)) (EQUAL (EQUAL NIL (NTH-CDR I A)) (EQUAL (FIX I) (LENGTH A)))), which simplifies, expanding NLISTP, BIGNP, TYPE, and UNTAG, to: T. Case 1. (IMPLIES (AND (NOT (NLISTP A)) (EQUAL (EQUAL NIL (NTH-CDR (SUB1 I) (CDR A))) (EQUAL (FIX (SUB1 I)) (LENGTH (CDR A)))) (BIGNP A BASE)) (EQUAL (EQUAL NIL (NTH-CDR I A)) (EQUAL (FIX I) (LENGTH A)))), which simplifies, appealing to the lemma ADD1-SUB1, and unfolding the definitions of NLISTP, FIX, BIGNP, TYPE, UNTAG, NTH-CDR, and LENGTH, to three new goals: Case 1.3. (IMPLIES (AND (LISTP A) (NOT (EQUAL (SUB1 I) (LENGTH (CDR A)))) (NOT (EQUAL NIL (NTH-CDR (SUB1 I) (CDR A)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (NUMBERP I)) (NOT (EQUAL I (ADD1 (LENGTH (CDR A)))))), which again simplifies, using linear arithmetic, to: T. Case 1.2. (IMPLIES (AND (LISTP A) (NOT (EQUAL (SUB1 I) (LENGTH (CDR A)))) (NOT (EQUAL NIL (NTH-CDR (SUB1 I) (CDR A)))) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (NOT (NUMBERP I))) (NOT (EQUAL 0 (ADD1 (LENGTH (CDR A)))))), which again simplifies, using linear arithmetic, to: T. Case 1.1. (IMPLIES (AND (LISTP A) (EQUAL (SUB1 I) (LENGTH (CDR A))) (EQUAL (EQUAL NIL (NTH-CDR (SUB1 I) (CDR A))) T) (LISTP (CAR A)) (EQUAL (CAAR A) 'NAT) (NUMBERP (CADAR A)) (LESSP (CADAR A) BASE) (EQUAL (CDDAR A) NIL) (BIGNP (CDR A) BASE) (NUMBERP I) (EQUAL I 0)) (NOT (EQUAL I 1))), which again simplifies, using linear arithmetic, to: T. So next consider: (IMPLIES (AND (NUMBERP I) (NOT (EQUAL I 0))) (NOT (EQUAL NIL (NTH-CDR I NIL)))), named *1.1 above. Let us appeal to the induction principle. There is only one suggested induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP I) (p I)) (IMPLIES (AND (NOT (ZEROP I)) (p (SUB1 I))) (p I))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. The above induction scheme leads to three new conjectures: Case 3. (IMPLIES (AND (ZEROP I) (NUMBERP I) (NOT (EQUAL I 0))) (NOT (EQUAL NIL (NTH-CDR I NIL)))), which simplifies, unfolding ZEROP, to: T. Case 2. (IMPLIES (AND (NOT (ZEROP I)) (EQUAL (SUB1 I) 0) (NUMBERP I) (NOT (EQUAL I 0))) (NOT (EQUAL NIL (NTH-CDR I NIL)))), which simplifies, opening up the definitions of ZEROP, NTH-CDR, CDR, and EQUAL, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP I)) (NOT (EQUAL NIL (NTH-CDR (SUB1 I) NIL))) (NUMBERP I) (NOT (EQUAL I 0))) (NOT (EQUAL NIL (NTH-CDR I NIL)))), which simplifies, opening up the definitions of ZEROP, NTH-CDR, and CDR, to: (IMPLIES (AND (NOT (EQUAL NIL (NTH-CDR (SUB1 I) NIL))) (NUMBERP I) (NOT (EQUAL I 0))) (NOT (EQUAL NIL (NTH-CDR (SUB1 I) 0)))). Appealing to the lemma SUB1-ELIM, we now replace I by (ADD1 X) to eliminate (SUB1 I). We employ the type restriction lemma noted when SUB1 was introduced to constrain the new variable. This generates: (IMPLIES (AND (NUMBERP X) (NOT (EQUAL NIL (NTH-CDR X NIL))) (NOT (EQUAL (ADD1 X) 0))) (NOT (EQUAL NIL (NTH-CDR X 0)))). This further simplifies, obviously, to: (IMPLIES (AND (NUMBERP X) (NOT (EQUAL NIL (NTH-CDR X NIL)))) (NOT (EQUAL NIL (NTH-CDR X 0)))), which we will name *1.1.1. We will appeal to induction. There are two plausible inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP X) (p X)) (IMPLIES (AND (NOT (ZEROP X)) (p (SUB1 X))) (p X))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT X) decreases according to the well-founded relation LESSP in each induction step of the scheme. The above induction scheme generates the following three new conjectures: Case 3. (IMPLIES (AND (ZEROP X) (NUMBERP X) (NOT (EQUAL NIL (NTH-CDR X NIL)))) (NOT (EQUAL NIL (NTH-CDR X 0)))). This simplifies, expanding the definitions of ZEROP, NUMBERP, NTH-CDR, and EQUAL, to: T. Case 2. (IMPLIES (AND (NOT (ZEROP X)) (EQUAL NIL (NTH-CDR (SUB1 X) NIL)) (NUMBERP X) (NOT (EQUAL NIL (NTH-CDR X NIL)))) (NOT (EQUAL NIL (NTH-CDR X 0)))). This simplifies, unfolding ZEROP, NTH-CDR, and CDR, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP X)) (NOT (EQUAL NIL (NTH-CDR (SUB1 X) 0))) (NUMBERP X) (NOT (EQUAL NIL (NTH-CDR X NIL)))) (NOT (EQUAL NIL (NTH-CDR X 0)))). This simplifies, expanding the functions ZEROP, NTH-CDR, and CDR, to: T. That finishes the proof of *1.1.1, which, consequently, also finishes the proof of *1.1, which, in turn, also finishes the proof of *1. Q.E.D. [ 0.0 0.1 0.0 ] EQUAL-NTH-CDR-NIL (PROVE-LEMMA EQUAL-CDDR-NTH-CDR-NIL (REWRITE) (IMPLIES (BIGNP A BASE) (EQUAL (EQUAL NIL (CDDR (NTH-CDR I A))) (EQUAL (ADD1 (ADD1 I)) (LENGTH A)))) ((USE (EQUAL-NTH-CDR-NIL (I (ADD1 (ADD1 I))))))) WARNING: Note that EQUAL-CDDR-NTH-CDR-NIL contains the free variable BASE which will be chosen by instantiating the hypothesis (BIGNP A BASE). This conjecture can be simplified, using the abbreviations IMPLIES and NTH-CDR-ADD1, to: (IMPLIES (AND (IMPLIES (BIGNP A BASE) (EQUAL (EQUAL NIL (CDDR (NTH-CDR I A))) (EQUAL (FIX (ADD1 (ADD1 I))) (LENGTH A)))) (BIGNP A BASE)) (EQUAL (EQUAL NIL (CDDR (NTH-CDR I A))) (EQUAL (ADD1 (ADD1 I)) (LENGTH A)))). This simplifies, opening up the functions FIX, IMPLIES, and EQUAL, to: T. Q.E.D. [ 0.0 0.0 0.0 ] EQUAL-CDDR-NTH-CDR-NIL (PROVE-LEMMA BIGNP-PUT (REWRITE) (IMPLIES (AND (NUMBERP I) (LESSP I (LENGTH A)) (BIGNP A BASE) (NUMBERP VAL) (LESSP VAL BASE)) (BIGNP (PUT (LIST 'NAT VAL) I A) BASE))) Name the conjecture *1. Perhaps we can prove it by induction. There are six plausible inductions. They merge into two likely candidate inductions. However, only one is unflawed. We will induct according to the following scheme: (AND (IMPLIES (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A)))) (p VAL I A BASE)) (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (OR (EQUAL I 0) (NOT (NUMBERP I)))) (p VAL I A BASE)) (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (p VAL (SUB1 I) (CDR A) BASE)) (p VAL I A BASE))). Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions of OR and NOT can be used to prove that the measure (COUNT I) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for A. The above induction scheme leads to five new goals: Case 5. (IMPLIES (AND (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A)))) (NUMBERP I) (LESSP I (LENGTH A)) (BIGNP A BASE) (NUMBERP VAL) (LESSP VAL BASE)) (BIGNP (PUT (LIST 'NAT VAL) I A) BASE)), which simplifies, opening up the definitions of LENGTH, NOT, OR, EQUAL, and LESSP, to: T. Case 4. (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (OR (EQUAL I 0) (NOT (NUMBERP I))) (NUMBERP I) (LESSP I (LENGTH A)) (BIGNP A BASE) (NUMBERP VAL) (LESSP VAL BASE)) (BIGNP (PUT (LIST 'NAT VAL) I A) BASE)), which simplifies, rewriting with CDR-CONS and CAR-CONS, and unfolding LENGTH, NOT, OR, NUMBERP, EQUAL, LESSP, BIGNP, TYPE, UNTAG, and PUT, to: T. Case 3. (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (NUMBERP I) (LESSP I (LENGTH A)) (BIGNP A BASE) (NUMBERP VAL) (LESSP VAL BASE)) (BIGNP (PUT (LIST 'NAT VAL) I A) BASE)). This simplifies, rewriting with SUB1-ADD1, and unfolding LENGTH, NOT, OR, and LESSP, to: T. Case 2. (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (NOT (BIGNP (CDR A) BASE)) (NUMBERP I) (LESSP I (LENGTH A)) (BIGNP A BASE) (NUMBERP VAL) (LESSP VAL BASE)) (BIGNP (PUT (LIST 'NAT VAL) I A) BASE)), which simplifies, applying SUB1-ADD1, and opening up the definitions of LENGTH, NOT, OR, LESSP, BIGNP, TYPE, and UNTAG, to: T. Case 1. (IMPLIES (AND (NOT (OR (EQUAL (LENGTH A) 0) (NOT (NUMBERP (LENGTH A))))) (NOT (OR (EQUAL I 0) (NOT (NUMBERP I)))) (BIGNP (PUT (LIST 'NAT VAL) (SUB1 I) (CDR A)) BASE) (NUMBERP I) (LESSP I (LENGTH A)) (BIGNP A BASE) (NUMBERP VAL) (LESSP VAL BASE)) (BIGNP (PUT (LIST 'NAT VAL) I A) BASE)). This simplifies, rewriting with the lemmas SUB1-ADD1, CDR-CONS, and CAR-CONS, and opening up the definitions of LENGTH, NOT, OR, LESSP, BIGNP, TYPE, UNTAG, PUT, and EQUAL, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.1 0.0 ] BIGNP-PUT (PROVE-LEMMA CONS-CAR-CDR-HACK (REWRITE) (EQUAL (EQUAL (CONS A (CDR X)) X) (AND (LISTP X) (EQUAL A (CAR X))))) This simplifies, unfolding the function AND, to the following three new formulas: Case 3. (IMPLIES (EQUAL (CONS A (CDR X)) X) (EQUAL (EQUAL A (CAR X)) T)). This again simplifies, trivially, to the new conjecture: (IMPLIES (EQUAL (CONS A (CDR X)) X) (EQUAL A (CAR X))). Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate (CDR X) and (CAR X). We thus obtain the following two new formulas: Case 3.2. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (CONS A (CDR X)) X)) (EQUAL A (CAR X))). This further simplifies, clearly, to: T. Case 3.1. (IMPLIES (EQUAL (CONS A Z) (CONS V Z)) (EQUAL A V)). However this further simplifies, applying CAR-CONS, to: T. Case 2. (IMPLIES (AND (NOT (EQUAL (CONS A (CDR X)) X)) (LISTP X)) (NOT (EQUAL A (CAR X)))). But this again simplifies, appealing to the lemma CONS-CAR-CDR, to: T. Case 1. (IMPLIES (EQUAL (CONS A (CDR X)) X) (LISTP X)), which again simplifies, trivially, to: T. Q.E.D. [ 0.0 0.0 0.0 ] CONS-CAR-CDR-HACK (PROVE-LEMMA BIG-ADD-ARRAY-IS-BIG-ADD-ARRAY-LOOP-GENERALIZED NIL (IMPLIES (AND (NUMBERP I) (LESSP I (LENGTH A)) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIG-ADD-ARRAY (NTH-CDR I A) (NTH-CDR I B) C BASE) (NTH-CDR I (BIG-ADD-ARRAY-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE)))) ((DISABLE DIFFERENCE) (INDUCT (HINT1 I A B C BASE)))) This formula can be simplified, using the abbreviations IMPLIES, NOT, OR, AND, DIFFERENCE-ADD1-NEW, NTH-CDR-ADD1, GET-IS-CAR-NTH-CDR, UNTAG, and TAG, to the following two new goals: Case 2. (IMPLIES (AND (LESSP I (LENGTH A)) (IMPLIES (AND (NUMBERP (ADD1 I)) (LESSP (ADD1 I) (LENGTH (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A))) (BIGNP (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A))) (CDR (NTH-CDR I B)) (NOT (LESSP (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A)) I)) (NOT (LESSP (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) BASE))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIG-ADD-ARRAY (NTH-CDR I A) (NTH-CDR I B) C BASE) (NTH-CDR I (BIG-ADD-ARRAY-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE)))). This simplifies, using linear arithmetic, applying the lemmas COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, LENGTH-PUT, SUB1-ADD1, EQUAL-LENGTH-0, LESSP-REMAINDER-LINEAR, BIGNP-PUT, NTH-CDR-PUT-AT, CDR-CONS, LISTP-NTH-CDR, NLISTP-CDR-NTH-CDR, BIG-ADD-ARRAY-ON-LIST-OF-LENGTH-1, DIFFERENCE-EQUAL-1, GET-IS-CAR-NTH-CDR, BIG-ADD-ARRAY-LOOP-ON-LIST-OF-LENGTH-1, CAR-CONS, and CONS-EQUAL, and unfolding the definitions of LESSP, AND, NOT, IMPLIES, BIGNP, EQUAL, LENGTH, BIG-ADD-ARRAY, UNTAG, and TAG, to the following four new formulas: Case 2.4. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LISTP A)) (NUMBERP I) (EQUAL A NIL) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (NTH-CDR I (BIG-ADD-ARRAY-LOOP I NIL B (DIFFERENCE 0 I) C BASE)))). This again simplifies, unfolding LENGTH, EQUAL, and LESSP, to: T. Case 2.3. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP I (SUB1 (LENGTH A)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL (LENGTH A) (PLUS 1 I)) (LESSP I (PLUS 1 I)) (NOT (LESSP I (SUB1 (PLUS 1 I)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). But this again simplifies, applying PLUS-0, PLUS-ADD1-1, and SUB1-ADD1, and opening up the definitions of ZEROP, LESSP, PLUS, SUB1, NUMBERP, EQUAL, and NTH-CDR, to the following two new conjectures: Case 2.3.2. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (EQUAL I 0) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR A))). This again simplifies, rewriting with EQUAL-LENGTH-1, to: (IMPLIES (AND (LISTP A) (NOT (LISTP (CDR A))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate (CDR A) and (CAR A). We thus obtain: (IMPLIES (AND (NOT (LISTP X)) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X)), which finally simplifies, applying CDR-CONS and CAR-CONS, and unfolding the functions UNTAG, TYPE, and BIGNP, to: T. Case 2.3.1. (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (NOT (LESSP I I)) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). Appealing to the lemma SUB1-ELIM, we now replace I by (ADD1 X) to eliminate (SUB1 I). We use the type restriction lemma noted when SUB1 was introduced to constrain the new variable. The result is two new formulas: Case 2.3.1.2. (IMPLIES (AND (EQUAL I 0) (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (NOT (LESSP I I)) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))), which further simplifies, applying the lemma EQUAL-LENGTH-1, and opening up the functions SUB1 and LESSP, to: T. Case 2.3.1.1. (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (LESSP X (ADD1 X)) (NOT (LESSP (ADD1 X) (ADD1 X))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) A)))), which further simplifies, applying SUB1-ADD1, NTH-CDR-ADD1, and EQUAL-CDDR-NTH-CDR-NIL, and opening up the functions LESSP, ADD1, EQUAL, and NTH-CDR, to: (IMPLIES (AND (NUMBERP X) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (EQUAL X 0) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, unfolding the definition of NUMBERP, to the conjecture: (IMPLIES (AND (EQUAL (LENGTH A) 2) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A) and X by (CONS W V) to eliminate (CDR X) and (CAR X). This generates three new formulas: Case 2.3.1.1.3. (IMPLIES (AND (NOT (LISTP A)) (EQUAL (LENGTH A) 2) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, expanding LENGTH and EQUAL, to: T. Case 2.3.1.1.2. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS Z X)) 2) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with CDR-CONS, and opening up the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.3.1.1.1. (IMPLIES (AND (EQUAL (LENGTH (CONS Z (CONS W V))) 2) (BIGNP (CONS Z (CONS W V)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL V)). However this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and opening up LENGTH, NUMBERP, UNTAG, TYPE, and BIGNP, to: T. Case 2.2. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIG-ADD-ARRAY (NTH-CDR I A) (NTH-CDR I B) C BASE) (NTH-CDR I (BIG-ADD-ARRAY-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE)))). This again simplifies, applying the lemmas COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, LISTP-NTH-CDR, and GET-IS-CAR-NTH-CDR, and unfolding TAG, UNTAG, BIG-ADD-ARRAY, and BIG-ADD-ARRAY-LOOP, to two new goals: Case 2.2.2. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0))) (EQUAL (CONS (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE)) (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))). We use the above equality hypothesis by substituting: (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE))) for (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) and throwing away the equality. This generates: (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0))) (EQUAL (CONS (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))) (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))). But this further simplifies, using linear arithmetic and rewriting with PLUS-ADD1-1, LENGTH-PUT, LENGTH-BIG-ADD-ARRAY-LOOP, LISTP-NTH-CDR, NTH-CDR-PUT-AT, CAR-CONS, CAR-NTH-CDR-BIG-ADD-ARRAY-LOOP, and CONS-CAR-CDR-HACK, to: (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (LESSP (LENGTH A) I)) (EQUAL (CONS (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))) (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))), which again simplifies, using linear arithmetic, to: T. Case 2.2.1. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL (CONS (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE)) (NTH-CDR I (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)))), which again simplifies, using linear arithmetic, rewriting with the lemmas CDR-NLISTP, SUB1-ADD1, PLUS-ADD1-2, PLUS-0, CAR-NLISTP, NLISTP-CDR-NTH-CDR, GET-IS-CAR-NTH-CDR, NTH-CDR-PUT-BEFORE, NTH-CDR-ADD1, LISTP-NTH-CDR, NTH-CDR-PUT-AT, CAR-CONS, CDR-CONS, DIFFERENCE-EQUAL-1, CONS-EQUAL, and BIG-ADD-ARRAY-ON-LIST-OF-LENGTH-1, and opening up the definitions of TAG, LESSP, ZEROP, TV->NAT, UNTAG, BIG-ADD-ARRAY, LISTP, PUT, EQUAL, SUB1, BIG-ADD-ARRAY-LOOP, CDR, CAR, NUMBERP, ADD1, PLUS, REMAINDER, and CONS, to five new formulas: Case 2.2.1.5. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (LENGTH A) 0) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B 0 T BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (NOT (EQUAL (SUB1 (DIFFERENCE 0 I)) 0))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP 0 I) (LESSP I 0) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (LENGTH A) 0) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B 0 T BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (NOT (EQUAL (SUB1 (DIFFERENCE 0 I)) 0))). This again simplifies, using linear arithmetic, to: T. Case 2.2.1.4. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I (SUB1 (LENGTH A)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER 1 BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL (LENGTH A) (PLUS 1 I)) (LESSP I (PLUS 1 I)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (PLUS 1 I) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I (SUB1 (PLUS 1 I)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER 1 BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). However this again simplifies, rewriting with PLUS-0, PLUS-ADD1-1, SUB1-ADD1, and CDR-CONS, and unfolding ZEROP, LESSP, EQUAL, NTH-CDR, PLUS, SUB1, PUT, NUMBERP, REMAINDER, and CONS, to: (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT '(NAT 1) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). Applying the lemma SUB1-ELIM, replace I by (ADD1 X) to eliminate (SUB1 I). We rely upon the type restriction lemma noted when SUB1 was introduced to restrict the new variable. We thus obtain the following two new conjectures: Case 2.2.1.4.2. (IMPLIES (AND (EQUAL I 0) (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT '(NAT 1) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). But this finally simplifies, rewriting with EQUAL-LENGTH-1, and expanding the definitions of SUB1 and LESSP, to: T. Case 2.2.1.4.1. (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (LESSP X (ADD1 X)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE)) (NOT (NUMBERP (CADADR (NTH-CDR (ADD1 X) B)))) (NOT (LESSP (ADD1 X) (ADD1 X))) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE)) (ADD1 X) A)) (PUT '(NAT 1) (ADD1 X) (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE)) (ADD1 X) A))))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) A)))). However this further simplifies, rewriting with SUB1-ADD1, NTH-CDR-ADD1, CDR-CONS, CAR-CONS, and EQUAL-CDDR-NTH-CDR-NIL, and opening up the definitions of LESSP, ADD1, EQUAL, NTH-CDR, and PUT, to the new conjecture: (IMPLIES (AND (NUMBERP X) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (EQUAL X 0) (NOT (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 1) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, expanding NUMBERP, to: (IMPLIES (AND (EQUAL (LENGTH A) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 1) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS V W) to eliminate (CAR X) and (CDR X), V by (CONS D X) to eliminate (CDR V) and (CAR V), and X by (CONS V X1) to eliminate (CAR X) and (CDR X). We must thus prove five new formulas: Case 2.2.1.4.1.5. (IMPLIES (AND (NOT (LISTP A)) (EQUAL (LENGTH A) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 1) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, unfolding the definitions of LENGTH and EQUAL, to: T. Case 2.2.1.4.1.4. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS Z X)) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADAR X) (CADADR B)) BASE)) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 1) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR X) (CADADR B)) BASE)) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with CDR-CONS, and unfolding the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.2.1.4.1.3. (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS V W))) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADR V) (CADADR B)) BASE)) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 1) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADR V) (CADADR B)) BASE)) 1 (CONS Z (CONS V W))))))) (BIGNP (CONS Z (CONS V W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). This finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up the definitions of LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.2.1.4.1.2. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS Z (CONS (CONS D X) W))) 2) (NOT (LESSP (PLUS (TV->NAT C) (CAR X) (CADADR B)) BASE)) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 1) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CAR X) (CADADR B)) BASE)) 1 (CONS Z (CONS (CONS D X) W))))))) (BIGNP (CONS Z (CONS (CONS D X) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). This finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and opening up LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.2.1.4.1.1. (IMPLIES (AND (EQUAL (LENGTH (CONS Z (CONS (CONS D (CONS V X1)) W))) 2) (NOT (LESSP (PLUS (TV->NAT C) V (CADADR B)) BASE)) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 1) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) V (CADADR B)) BASE)) 1 (CONS Z (CONS (CONS D (CONS V X1)) W))))))) (BIGNP (CONS Z (CONS (CONS D (CONS V X1)) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). This finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.2.1.3. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (LESSP I (SUB1 (LENGTH A))) (EQUAL (LIST (LIST 'NAT (REMAINDER 1 BASE))) (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER 1 BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL '((NAT 1)) (CDR (NTH-CDR I A)))). This again simplifies, using linear arithmetic, to: T. Case 2.2.1.2. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I (SUB1 (LENGTH A)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR I B))) BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL (LENGTH A) (PLUS 1 I)) (LESSP I (PLUS 1 I)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (PLUS 1 I) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I (SUB1 (PLUS 1 I)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR I B))) BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). But this again simplifies, applying PLUS-0, PLUS-ADD1-1, SUB1-ADD1, and CDR-CONS, and unfolding the definitions of ZEROP, LESSP, EQUAL, NTH-CDR, PLUS, SUB1, and PUT, to: (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR I B))) BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). Applying the lemma SUB1-ELIM, replace I by (ADD1 X) to eliminate (SUB1 I). We employ the type restriction lemma noted when SUB1 was introduced to restrict the new variable. We would thus like to prove the following two new goals: Case 2.2.1.2.2. (IMPLIES (AND (EQUAL I 0) (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR I B))) BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). However this finally simplifies, appealing to the lemma EQUAL-LENGTH-1, and expanding the definitions of SUB1 and LESSP, to: T. Case 2.2.1.2.1. (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (LESSP X (ADD1 X)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE)) (NUMBERP (CADADR (NTH-CDR (ADD1 X) B))) (NOT (LESSP (ADD1 X) (ADD1 X))) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE)) (ADD1 X) A)) (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR (ADD1 X) B))) BASE)) (ADD1 X) (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE)) (ADD1 X) A))))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) A)))), which further simplifies, appealing to the lemmas SUB1-ADD1, NTH-CDR-ADD1, CDR-CONS, CAR-CONS, and EQUAL-CDDR-NTH-CDR-NIL, and opening up the definitions of LESSP, ADD1, EQUAL, NTH-CDR, and PUT, to: (IMPLIES (AND (NUMBERP X) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (EQUAL X 0) (NOT (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADDR B)) BASE)) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This again simplifies, expanding the function NUMBERP, to: (IMPLIES (AND (EQUAL (LENGTH A) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADDR B)) BASE)) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS V W) to eliminate (CAR X) and (CDR X), V by (CONS D X) to eliminate (CDR V) and (CAR V), and X by (CONS V X1) to eliminate (CAR X) and (CDR X). We must thus prove five new goals: Case 2.2.1.2.1.5. (IMPLIES (AND (NOT (LISTP A)) (EQUAL (LENGTH A) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADDR B)) BASE)) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, expanding the definitions of LENGTH and EQUAL, to: T. Case 2.2.1.2.1.4. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS Z X)) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADAR X) (CADADR B)) BASE)) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADDR B)) BASE)) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR X) (CADADR B)) BASE)) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with CDR-CONS, and opening up the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.2.1.2.1.3. (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS V W))) 2) (NOT (LESSP (PLUS (TV->NAT C) (CADR V) (CADADR B)) BASE)) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADDR B)) BASE)) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADR V) (CADADR B)) BASE)) 1 (CONS Z (CONS V W))))))) (BIGNP (CONS Z (CONS V W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). But this finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and expanding the definitions of LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.2.1.2.1.2. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS Z (CONS (CONS D X) W))) 2) (NOT (LESSP (PLUS (TV->NAT C) (CAR X) (CADADR B)) BASE)) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADDR B)) BASE)) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CAR X) (CADADR B)) BASE)) 1 (CONS Z (CONS (CONS D X) W))))))) (BIGNP (CONS Z (CONS (CONS D X) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)), which finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.2.1.2.1.1. (IMPLIES (AND (EQUAL (LENGTH (CONS Z (CONS (CONS D (CONS V X1)) W))) 2) (NOT (LESSP (PLUS (TV->NAT C) V (CADADR B)) BASE)) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADDR B)) BASE)) 1 (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) V (CADADR B)) BASE)) 1 (CONS Z (CONS (CONS D (CONS V X1)) W))))))) (BIGNP (CONS Z (CONS (CONS D (CONS V X1)) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)), which finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and expanding LENGTH, NUMBERP, SUB1, EQUAL, and PUT, to: T. Case 2.2.1.1. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (LESSP I (SUB1 (LENGTH A))) (EQUAL (LIST (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR I B))) BASE))) (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A)) (PUT (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR I B))) BASE)) I (CDR (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL (LIST (LIST 'NAT (REMAINDER (ADD1 (CADADR (NTH-CDR I B))) BASE))) (CDR (NTH-CDR I A)))). However this again simplifies, using linear arithmetic, to: T. Case 2.1. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIG-ADD-ARRAY (NTH-CDR I A) (NTH-CDR I B) C BASE) (NTH-CDR I (BIG-ADD-ARRAY-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE)))), which again simplifies, applying the lemmas COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and LISTP-NTH-CDR, and opening up the functions REMAINDER, TAG, UNTAG, and BIG-ADD-ARRAY, to the conjecture: (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (CONS (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE)) (NTH-CDR I (BIG-ADD-ARRAY-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE)))). However this again simplifies, rewriting with COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and GET-IS-CAR-NTH-CDR, and unfolding TAG, REMAINDER, UNTAG, and BIG-ADD-ARRAY-LOOP, to the following two new conjectures: Case 2.1.2. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0))) (EQUAL (CONS (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE)) (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))). We use the above equality hypothesis by substituting: (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE))) for (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) and throwing away the equality. This produces: (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0))) (EQUAL (CONS (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))) (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))), which further simplifies, using linear arithmetic and rewriting with the lemmas PLUS-ADD1-1, LENGTH-PUT, LENGTH-BIG-ADD-ARRAY-LOOP, LISTP-NTH-CDR, NTH-CDR-PUT-AT, CAR-CONS, CAR-NTH-CDR-BIG-ADD-ARRAY-LOOP, and CONS-CAR-CDR-HACK, to: (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (LESSP (LENGTH A) I)) (EQUAL (CONS (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))) (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))). This finally simplifies, using linear arithmetic, to: T. Case 2.1.1. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL (CONS (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE)) (NTH-CDR I (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)))), which again simplifies, using linear arithmetic, rewriting with CDR-NLISTP, PLUS-0, CAR-NLISTP, NLISTP-CDR-NTH-CDR, SUB1-ADD1, GET-IS-CAR-NTH-CDR, NTH-CDR-PUT-BEFORE, NTH-CDR-ADD1, LISTP-NTH-CDR, NTH-CDR-PUT-AT, CAR-CONS, CDR-CONS, DIFFERENCE-EQUAL-1, CONS-EQUAL, and BIG-ADD-ARRAY-ON-LIST-OF-LENGTH-1, and opening up TAG, REMAINDER, ZEROP, TV->NAT, UNTAG, BIG-ADD-ARRAY, LISTP, PUT, EQUAL, SUB1, BIG-ADD-ARRAY-LOOP, CDR, CAR, NUMBERP, PLUS, LESSP, and CONS, to the following seven new conjectures: Case 2.1.1.7. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (LENGTH A) 0) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B 0 F BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (NOT (EQUAL (SUB1 (DIFFERENCE 0 I)) 0))). However this again simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP 0 I) (LESSP I 0) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (LENGTH A) 0) (EQUAL (BIG-ADD-ARRAY (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (CDR (NTH-CDR I (BIG-ADD-ARRAY-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B 0 F BASE)))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (NOT (EQUAL (SUB1 (DIFFERENCE 0 I)) 0))). This again simplifies, using linear arithmetic, to: T. Case 2.1.1.6. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I (SUB1 (LENGTH A)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER 0 BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL (LENGTH A) (PLUS 1 I)) (LESSP I (PLUS 1 I)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (PLUS 1 I) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I (SUB1 (PLUS 1 I)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER 0 BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). This again simplifies, applying PLUS-0, PLUS-ADD1-1, SUB1-ADD1, and CDR-CONS, and expanding the definitions of ZEROP, LESSP, EQUAL, NTH-CDR, PLUS, SUB1, PUT, NUMBERP, REMAINDER, and CONS, to: (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT '(NAT 0) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). Applying the lemma SUB1-ELIM, replace I by (ADD1 X) to eliminate (SUB1 I). We use the type restriction lemma noted when SUB1 was introduced to restrict the new variable. We thus obtain the following two new conjectures: Case 2.1.1.6.2. (IMPLIES (AND (EQUAL I 0) (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT '(NAT 0) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). This finally simplifies, appealing to the lemma EQUAL-LENGTH-1, and opening up the functions SUB1 and LESSP, to: T. Case 2.1.1.6.1. (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (LESSP X (ADD1 X)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE) (NOT (NUMBERP (CADADR (NTH-CDR (ADD1 X) B)))) (NOT (LESSP (ADD1 X) (ADD1 X))) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B)))) (ADD1 X) A)) (PUT '(NAT 0) (ADD1 X) (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B)))) (ADD1 X) A))))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) A)))), which further simplifies, applying SUB1-ADD1, NTH-CDR-ADD1, CDR-CONS, CAR-CONS, and EQUAL-CDDR-NTH-CDR-NIL, and expanding the functions LESSP, ADD1, EQUAL, NTH-CDR, and PUT, to the new goal: (IMPLIES (AND (NUMBERP X) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (EQUAL X 0) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADADR B))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, unfolding NUMBERP, to the conjecture: (IMPLIES (AND (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADADR B))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS V W) to eliminate (CAR X) and (CDR X), V by (CONS D X) to eliminate (CDR V) and (CAR V), and X by (CONS V X1) to eliminate (CAR X) and (CDR X). The result is five new conjectures: Case 2.1.1.6.1.5. (IMPLIES (AND (NOT (LISTP A)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADADR B))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, opening up the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.6.1.4. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS Z X)) 2) (LESSP (PLUS (TV->NAT C) (CADAR X) (CADADR B)) BASE) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR X) (CADADR B))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with CDR-CONS, and opening up the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.6.1.3. (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS V W))) 2) (LESSP (PLUS (TV->NAT C) (CADR V) (CADADR B)) BASE) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR V) (CADADR B))) 1 (CONS Z (CONS V W))))))) (BIGNP (CONS Z (CONS V W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). However this finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.6.1.2. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS Z (CONS (CONS D X) W))) 2) (LESSP (PLUS (TV->NAT C) (CAR X) (CADADR B)) BASE) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR X) (CADADR B))) 1 (CONS Z (CONS (CONS D X) W))))))) (BIGNP (CONS Z (CONS (CONS D X) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding the definitions of LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.6.1.1. (IMPLIES (AND (EQUAL (LENGTH (CONS Z (CONS (CONS D (CONS V X1)) W))) 2) (LESSP (PLUS (TV->NAT C) V (CADADR B)) BASE) (NOT (NUMBERP (CADADDR B))) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) V (CADADR B))) 1 (CONS Z (CONS (CONS D (CONS V X1)) W))))))) (BIGNP (CONS Z (CONS (CONS D (CONS V X1)) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). This finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and unfolding the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.5. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (LESSP I (SUB1 (LENGTH A))) (LESSP 0 BASE) (EQUAL '((NAT 0)) (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER 0 BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL '((NAT 0)) (CDR (NTH-CDR I A)))). But this again simplifies, using linear arithmetic, to: T. Case 2.1.1.4. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (LESSP I (SUB1 (LENGTH A))) (NOT (LESSP 0 BASE)) (EQUAL (LIST (LIST 'NAT (REMAINDER 0 BASE))) (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER 0 BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL '((NAT 0)) (CDR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: T. Case 2.1.1.3. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I (SUB1 (LENGTH A)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (EQUAL (LENGTH A) (PLUS 1 I)) (LESSP I (PLUS 1 I)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (PLUS 1 I) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I (SUB1 (PLUS 1 I)))) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). However this again simplifies, applying PLUS-0, PLUS-ADD1-1, SUB1-ADD1, and CDR-CONS, and expanding the definitions of ZEROP, LESSP, EQUAL, NTH-CDR, PLUS, SUB1, and PUT, to the new conjecture: (IMPLIES (AND (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). Applying the lemma SUB1-ELIM, replace I by (ADD1 X) to eliminate (SUB1 I). We rely upon the type restriction lemma noted when SUB1 was introduced to restrict the new variable. This produces the following two new conjectures: Case 2.1.1.3.2. (IMPLIES (AND (EQUAL I 0) (EQUAL (LENGTH A) (ADD1 I)) (LESSP (SUB1 I) I) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP I I)) (EQUAL NIL (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR I A)))). But this finally simplifies, applying EQUAL-LENGTH-1, and unfolding the definitions of SUB1 and LESSP, to: T. Case 2.1.1.3.1. (IMPLIES (AND (NUMBERP X) (NOT (EQUAL (ADD1 X) 0)) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (LESSP X (ADD1 X)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B))) BASE) (NUMBERP (CADADR (NTH-CDR (ADD1 X) B))) (NOT (LESSP (ADD1 X) (ADD1 X))) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B)))) (ADD1 X) A)) (PUT (LIST 'NAT (REMAINDER (CADADR (NTH-CDR (ADD1 X) B)) BASE)) (ADD1 X) (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR (ADD1 X) A)) (CADAR (NTH-CDR (ADD1 X) B)))) (ADD1 X) A))))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR (NTH-CDR (ADD1 X) A)))). This further simplifies, rewriting with SUB1-ADD1, NTH-CDR-ADD1, CDR-CONS, CAR-CONS, and EQUAL-CDDR-NTH-CDR-NIL, and unfolding LESSP, ADD1, EQUAL, NTH-CDR, and PUT, to: (IMPLIES (AND (NUMBERP X) (EQUAL (LENGTH A) (ADD1 (ADD1 X))) (EQUAL X 0) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADADDR B) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADADR B))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, unfolding the function NUMBERP, to: (IMPLIES (AND (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADADDR B) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADADR B))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemmas REMAINDER-QUOTIENT-ELIM and CAR-CDR-ELIM, we now replace B by (CONS Z X) to eliminate (CDR B) and (CAR B), X by (CONS W V) to eliminate (CDR X) and (CAR X), V by (CONS X D) to eliminate (CAR V) and (CDR V), X by (CONS X1 V) to eliminate (CDR X) and (CAR X), V by (CONS X Z1) to eliminate (CAR V) and (CDR V), X by (PLUS V (TIMES BASE V1)) to eliminate (REMAINDER X BASE) and (QUOTIENT X BASE), W by (CONS W1 X) to eliminate (CDR W) and (CAR W), X by (CONS W D1) to eliminate (CAR X) and (CDR X), W by (CONS V1 V) to eliminate (CDR W) and (CAR W), V by (CONS W W1) to eliminate (CAR V) and (CDR V), W by (CONS Z1 X) to eliminate (CDR W) and (CAR W), X by (CONS W V1) to eliminate (CAR X) and (CDR X), W by (CONS X1 V) to eliminate (CDR W) and (CAR W), V by (CONS W Z1) to eliminate (CAR V) and (CDR V), W by (CONS D X) to eliminate (CDR W) and (CAR W), and X by (CONS W X1) to eliminate (CAR X) and (CDR X). We use LESSP-REMAINDER, the type restriction lemma noted when REMAINDER was introduced, and the type restriction lemma noted when QUOTIENT was introduced to constrain the new variables. This generates 17 new conjectures: Case 2.1.1.3.1.17. (IMPLIES (AND (NOT (LISTP B)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADADR B)) BASE) (NUMBERP (CADADDR B)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADADDR B) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADADR B))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which further simplifies, rewriting with the lemmas CDR-NLISTP and PLUS-0, and opening up the functions CAR, CDR, ZEROP, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to two new goals: Case 2.1.1.3.1.17.2. (IMPLIES (AND (NOT (LISTP B)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, rewriting with the lemma PLUS-0, and opening up ZEROP, to: (IMPLIES (AND (NOT (LISTP B)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS V W) to eliminate (CAR X) and (CDR X), V by (CONS D X) to eliminate (CDR V) and (CAR V), and X by (CONS V X1) to eliminate (CAR X) and (CDR X). This generates five new formulas: Case 2.1.1.3.1.17.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP B)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.17.2.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z X)) 2) (NOT (NUMBERP (CADAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, applying the lemma CDR-CONS, and unfolding the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.17.2.3. (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z (CONS V W))) 2) (NOT (NUMBERP (CADR V))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS V W))))))) (BIGNP (CONS Z (CONS V W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and expanding LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.17.2.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z (CONS (CONS D X) W))) 2) (NOT (NUMBERP (CAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS D X) W))))))) (BIGNP (CONS Z (CONS (CONS D X) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). However this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and expanding the functions LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.17.2.1. (IMPLIES (AND (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z (CONS (CONS D (CONS V X1)) W))) 2) (NOT (NUMBERP V)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS D (CONS V X1)) W))))))) (BIGNP (CONS Z (CONS (CONS D (CONS V X1)) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). But this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and expanding the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.17.1. (IMPLIES (AND (NOT (LISTP B)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS V W) to eliminate (CAR X) and (CDR X), V by (CONS D X) to eliminate (CDR V) and (CAR V), and X by (CONS V X1) to eliminate (CAR X) and (CDR X). This generates five new goals: Case 2.1.1.3.1.17.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP B)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, opening up LENGTH and EQUAL, to: T. Case 2.1.1.3.1.17.1.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z X)) 2) (NUMBERP (CADAR X)) (LESSP (PLUS (TV->NAT C) (CADAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR X))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, applying CDR-CONS, and unfolding LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.17.1.3. (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z (CONS V W))) 2) (NUMBERP (CADR V)) (LESSP (PLUS (TV->NAT C) (CADR V)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR V))) 1 (CONS Z (CONS V W))))))) (BIGNP (CONS Z (CONS V W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). However this finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.17.1.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z (CONS (CONS D X) W))) 2) (NUMBERP (CAR X)) (LESSP (PLUS (TV->NAT C) (CAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR X))) 1 (CONS Z (CONS (CONS D X) W))))))) (BIGNP (CONS Z (CONS (CONS D X) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and unfolding LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.17.1.1. (IMPLIES (AND (NOT (LISTP B)) (EQUAL (LENGTH (CONS Z (CONS (CONS D (CONS V X1)) W))) 2) (NUMBERP V) (LESSP (PLUS (TV->NAT C) V) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) V)) 1 (CONS Z (CONS (CONS D (CONS V X1)) W))))))) (BIGNP (CONS Z (CONS (CONS D (CONS V X1)) W)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL W)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.16. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADAR X)) BASE) (NUMBERP (CADADR X)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADADR X) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADAR X))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this further simplifies, applying the lemmas CAR-NLISTP, PLUS-0, and CDR-NLISTP, and unfolding the functions CDR, CAR, ZEROP, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to two new formulas: Case 2.1.1.3.1.16.2. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, rewriting with PLUS-0, and expanding the function ZEROP, to the new formula: (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS V Z) to eliminate (CDR A) and (CAR A), Z by (CONS W D) to eliminate (CAR Z) and (CDR Z), W by (CONS X1 Z) to eliminate (CDR W) and (CAR W), and Z by (CONS W Z1) to eliminate (CAR Z) and (CDR Z). This produces the following five new conjectures: Case 2.1.1.3.1.16.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This finally simplifies, opening up the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.16.2.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V Z)) 2) (NOT (NUMBERP (CADAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V Z)))))) (BIGNP (CONS V Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying the lemma CDR-CONS, and opening up the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.16.2.3. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS W D))) 2) (NOT (NUMBERP (CADR W))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V (CONS W D))))))) (BIGNP (CONS V (CONS W D)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL D)), which finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and expanding LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.16.2.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS X1 Z) D))) 2) (NOT (NUMBERP (CAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V (CONS (CONS X1 Z) D))))))) (BIGNP (CONS V (CONS (CONS X1 Z) D)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL D)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and unfolding the functions LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.16.2.1. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS X1 (CONS W Z1)) D))) 2) (NOT (NUMBERP W)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V (CONS (CONS X1 (CONS W Z1)) D))))))) (BIGNP (CONS V (CONS (CONS X1 (CONS W Z1)) D)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL D)). But this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and unfolding LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.16.1. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS V Z) to eliminate (CDR A) and (CAR A), Z by (CONS W D) to eliminate (CAR Z) and (CDR Z), W by (CONS X1 Z) to eliminate (CDR W) and (CAR W), and Z by (CONS W Z1) to eliminate (CAR Z) and (CDR Z). The result is five new goals: Case 2.1.1.3.1.16.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, unfolding the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.16.1.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V Z)) 2) (NUMBERP (CADAR Z)) (LESSP (PLUS (TV->NAT C) (CADAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR Z))) 1 (CONS V Z)))))) (BIGNP (CONS V Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, rewriting with CDR-CONS, and unfolding the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.16.1.3. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS W D))) 2) (NUMBERP (CADR W)) (LESSP (PLUS (TV->NAT C) (CADR W)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR W))) 1 (CONS V (CONS W D))))))) (BIGNP (CONS V (CONS W D)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL D)). However this finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and expanding the definitions of LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.16.1.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS X1 Z) D))) 2) (NUMBERP (CAR Z)) (LESSP (PLUS (TV->NAT C) (CAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR Z))) 1 (CONS V (CONS (CONS X1 Z) D))))))) (BIGNP (CONS V (CONS (CONS X1 Z) D)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL D)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding the definitions of LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.16.1.1. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS X1 (CONS W Z1)) D))) 2) (NUMBERP W) (LESSP (PLUS (TV->NAT C) W) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) W)) 1 (CONS V (CONS (CONS X1 (CONS W Z1)) D))))))) (BIGNP (CONS V (CONS (CONS X1 (CONS W Z1)) D)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL D)). This finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and opening up LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.15. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADR W)) BASE) (NUMBERP (CADAR V)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADAR V) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADR W))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which further simplifies, applying CDR-NLISTP, PLUS-0, and CAR-NLISTP, and expanding CAR, ZEROP, CDR, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to the following two new conjectures: Case 2.1.1.3.1.15.2. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This again simplifies, applying PLUS-0, and expanding the function ZEROP, to: (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D V1) to eliminate (CAR X) and (CDR X). We would thus like to prove the following five new conjectures: Case 2.1.1.3.1.15.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this finally simplifies, opening up LENGTH and EQUAL, to: T. Case 2.1.1.3.1.15.2.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z X)) 2) (NOT (NUMBERP (CADAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, applying CDR-CONS, and opening up the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.15.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). This finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and unfolding LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.15.2.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (NOT (NUMBERP (CAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). This finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and opening up the definitions of LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.15.2.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and expanding LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.15.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D V1) to eliminate (CAR X) and (CDR X). We would thus like to prove the following five new conjectures: Case 2.1.1.3.1.15.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this finally simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.15.1.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z X)) 2) (NUMBERP (CADAR X)) (LESSP (PLUS (TV->NAT C) (CADAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR X))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with the lemma CDR-CONS, and unfolding the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.15.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.15.1.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (NUMBERP (CAR X)) (LESSP (PLUS (TV->NAT C) (CAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR X))) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and unfolding the definitions of LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.15.1.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.14. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CAR X)) BASE) (NUMBERP (CADAR V)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADAR V) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CAR X))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which further simplifies, applying CAR-NLISTP and PLUS-0, and unfolding the functions ZEROP, CDR, CAR, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to the following two new conjectures: Case 2.1.1.3.1.14.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this again simplifies, applying PLUS-0, and opening up ZEROP, to: (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). We would thus like to prove the following five new goals: Case 2.1.1.3.1.14.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this finally simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.14.2.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W Z)) 2) (NOT (NUMBERP (CADAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying the lemma CDR-CONS, and opening up the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.14.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and unfolding the definitions of LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.14.2.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NOT (NUMBERP (CAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and opening up the functions LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.14.2.1. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and expanding LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.14.1. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). This produces the following five new conjectures: Case 2.1.1.3.1.14.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this finally simplifies, opening up the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.14.1.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W Z)) 2) (NUMBERP (CADAR Z)) (LESSP (PLUS (TV->NAT C) (CADAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR Z))) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, rewriting with CDR-CONS, and opening up LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.14.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.14.1.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NUMBERP (CAR Z)) (LESSP (PLUS (TV->NAT C) (CAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR Z))) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.14.1.1. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS W (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and expanding the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.13. (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) W) BASE) (NUMBERP (CADAR V)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADAR V) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) W)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which further simplifies, rewriting with the lemmas COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-NLISTP, and unfolding the functions CDR, CAR, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to: (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D V1) to eliminate (CAR X) and (CDR X). The result is five new conjectures: Case 2.1.1.3.1.13.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.13.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z X)) 2) (LESSP (PLUS W (TV->NAT C) (CADAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADAR X))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, applying the lemma CDR-CONS, and expanding LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.13.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (LESSP (PLUS W (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADR D))) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.13.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (LESSP (PLUS W (TV->NAT C) (CAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CAR X))) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.13.1. (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))) 2) (LESSP (PLUS W (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) D)) 1 (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). This finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and opening up the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.12. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADR W)) BASE) (NUMBERP (CADR X)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADR X) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADR W))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this further simplifies, applying CDR-NLISTP and PLUS-0, and expanding CAR, ZEROP, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to the following two new formulas: Case 2.1.1.3.1.12.2. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This again simplifies, appealing to the lemma PLUS-0, and unfolding the definition of ZEROP, to: (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS V Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). This generates five new conjectures: Case 2.1.1.3.1.12.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.12.2.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V Z)) 2) (NOT (NUMBERP (CADAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V Z)))))) (BIGNP (CONS V Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying the lemma CDR-CONS, and expanding the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.12.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V (CONS D X1))))))) (BIGNP (CONS V (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and opening up the definitions of LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.12.2.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS Z1 Z) X1))) 2) (NOT (NUMBERP (CAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS V (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and unfolding LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.12.2.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS V (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS V (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.12.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS V Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). We would thus like to prove the following five new goals: Case 2.1.1.3.1.12.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this finally simplifies, unfolding the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.12.1.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V Z)) 2) (NUMBERP (CADAR Z)) (LESSP (PLUS (TV->NAT C) (CADAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR Z))) 1 (CONS V Z)))))) (BIGNP (CONS V Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, rewriting with the lemma CDR-CONS, and unfolding the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.12.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS V (CONS D X1))))))) (BIGNP (CONS V (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.12.1.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS Z1 Z) X1))) 2) (NUMBERP (CAR Z)) (LESSP (PLUS (TV->NAT C) (CAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR Z))) 1 (CONS V (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS V (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.12.1.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS V (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS V (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). This finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and opening up the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.11. (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CAR V)) BASE) (NUMBERP (CADR X)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADR X) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CAR V))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this further simplifies, applying CAR-NLISTP, PLUS-0, and CDR-NLISTP, and expanding the functions ZEROP, CAR, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to the following two new conjectures: Case 2.1.1.3.1.11.2. (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this again simplifies, rewriting with the lemma PLUS-0, and expanding the function ZEROP, to the formula: (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). We must thus prove five new goals: Case 2.1.1.3.1.11.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, expanding the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.11.2.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W Z)) 2) (NOT (NUMBERP (CADAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, appealing to the lemma CDR-CONS, and unfolding the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.11.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and expanding LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.11.2.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NOT (NUMBERP (CAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and opening up the functions LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.11.2.1. (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.11.1. (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). We would thus like to prove the following five new conjectures: Case 2.1.1.3.1.11.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This finally simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.11.1.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W Z)) 2) (NUMBERP (CADAR Z)) (LESSP (PLUS (TV->NAT C) (CADAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR Z))) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying CDR-CONS, and expanding the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.11.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.11.1.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NUMBERP (CAR Z)) (LESSP (PLUS (TV->NAT C) (CAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR Z))) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and unfolding LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.11.1.1. (IMPLIES (AND (NOT (LISTP V)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS W (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.10. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) W) BASE) (NUMBERP (CADR X)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CADR X) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) W)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which further simplifies, applying COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CDR-NLISTP, and opening up the definitions of CAR, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to: (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS V Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). We would thus like to prove the following five new formulas: Case 2.1.1.3.1.10.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This finally simplifies, expanding the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.10.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V Z)) 2) (LESSP (PLUS W (TV->NAT C) (CADAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADAR Z))) 1 (CONS V Z)))))) (BIGNP (CONS V Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying CDR-CONS, and expanding LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.10.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS D X1))) 2) (LESSP (PLUS W (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADR D))) 1 (CONS V (CONS D X1))))))) (BIGNP (CONS V (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and expanding LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.10.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS Z1 Z) X1))) 2) (LESSP (PLUS W (TV->NAT C) (CAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CAR Z))) 1 (CONS V (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS V (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and opening up the definitions of LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.10.1. (IMPLIES (AND (NOT (LISTP X)) (EQUAL (LENGTH (CONS V (CONS (CONS Z1 (CONS D V1)) X1))) 2) (LESSP (PLUS W (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) D)) 1 (CONS V (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS V (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.9. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADR W)) BASE) (NUMBERP (CAR V)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CAR V) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADR W))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This further simplifies, rewriting with the lemmas CDR-NLISTP, PLUS-0, and CAR-NLISTP, and unfolding the functions CAR, ZEROP, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to two new goals: Case 2.1.1.3.1.9.2. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, applying PLUS-0, and unfolding the definition of ZEROP, to: (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D V1) to eliminate (CAR X) and (CDR X). We thus obtain the following five new formulas: Case 2.1.1.3.1.9.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this finally simplifies, unfolding the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.9.2.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z X)) 2) (NOT (NUMBERP (CADAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with the lemma CDR-CONS, and expanding LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.9.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and opening up LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.9.2.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (NOT (NUMBERP (CAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and unfolding the functions LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.9.2.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and unfolding the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.9.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D V1) to eliminate (CAR X) and (CDR X). The result is five new formulas: Case 2.1.1.3.1.9.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, unfolding the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.9.1.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z X)) 2) (NUMBERP (CADAR X)) (LESSP (PLUS (TV->NAT C) (CADAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR X))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, applying the lemma CDR-CONS, and expanding the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.9.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.9.1.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (NUMBERP (CAR X)) (LESSP (PLUS (TV->NAT C) (CAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR X))) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). This finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.9.1.1. (IMPLIES (AND (NOT (LISTP W)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.8. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CAR X)) BASE) (NUMBERP (CAR V)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CAR V) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CAR X))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this further simplifies, rewriting with CAR-NLISTP and PLUS-0, and opening up the definitions of ZEROP, NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to the following two new formulas: Case 2.1.1.3.1.8.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this again simplifies, applying PLUS-0, and expanding the definition of ZEROP, to: (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). We thus obtain the following five new formulas: Case 2.1.1.3.1.8.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this finally simplifies, unfolding the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.8.2.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W Z)) 2) (NOT (NUMBERP (CADAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying CDR-CONS, and unfolding LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.8.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and expanding LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.8.2.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NOT (NUMBERP (CAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and opening up the functions LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.8.2.1. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and unfolding the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.8.1. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D V1) to eliminate (CAR Z) and (CDR Z). This generates five new goals: Case 2.1.1.3.1.8.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, expanding the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.8.1.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W Z)) 2) (NUMBERP (CADAR Z)) (LESSP (PLUS (TV->NAT C) (CADAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR Z))) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, appealing to the lemma CDR-CONS, and expanding the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.8.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.8.1.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NUMBERP (CAR Z)) (LESSP (PLUS (TV->NAT C) (CAR Z)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR Z))) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and unfolding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.8.1.1. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D V1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS W (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and opening up LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.7. (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) W) BASE) (NUMBERP (CAR V)) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER (CAR V) BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) W)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This further simplifies, rewriting with COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-NLISTP, and opening up the functions NUMBERP, LESSP, EQUAL, REMAINDER, and CONS, to: (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D V1) to eliminate (CAR X) and (CDR X). This produces the following five new formulas: Case 2.1.1.3.1.7.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP V)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this finally simplifies, unfolding the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.7.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z X)) 2) (LESSP (PLUS W (TV->NAT C) (CADAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADAR X))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with CDR-CONS, and opening up LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.7.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (LESSP (PLUS W (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADR D))) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.7.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (LESSP (PLUS W (TV->NAT C) (CAR X)) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CAR X))) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, rewriting with the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.7.1. (IMPLIES (AND (NOT (LISTP V)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))) 2) (LESSP (PLUS W (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT '(NAT 0) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) D)) 1 (CONS Z (CONS (CONS Z1 (CONS D V1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D V1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and opening up the definitions of LENGTH, NUMBERP, SUB1, EQUAL, PUT, and CONS, to: T. Case 2.1.1.3.1.6. (IMPLIES (AND (NOT (LISTP W)) (EQUAL BASE 0) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADR W)) BASE) (NUMBERP X) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER X BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADR W))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this finally simplifies, using linear arithmetic, to: T. Case 2.1.1.3.1.5. (IMPLIES (AND (NOT (LISTP V)) (EQUAL BASE 0) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CAR V)) BASE) (NUMBERP X) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER X BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CAR V))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, using linear arithmetic, to: T. Case 2.1.1.3.1.4. (IMPLIES (AND (EQUAL BASE 0) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) W) BASE) (NUMBERP X) (EQUAL NIL (CDR (PUT (LIST 'NAT (REMAINDER X BASE)) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) W)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, using linear arithmetic, to: T. Case 2.1.1.3.1.3. (IMPLIES (AND (NOT (LISTP W)) (NUMBERP V) (EQUAL (LESSP V BASE) (NOT (ZEROP BASE))) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CADR W)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CADR W))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which further simplifies, rewriting with CDR-NLISTP and PLUS-0, and opening up ZEROP, NOT, CAR, and NUMBERP, to the following two new conjectures: Case 2.1.1.3.1.3.2. (IMPLIES (AND (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this again simplifies, rewriting with PLUS-0, and unfolding the definition of ZEROP, to: (IMPLIES (AND (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D W1) to eliminate (CAR X) and (CDR X). We would thus like to prove the following five new formulas: Case 2.1.1.3.1.3.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). This finally simplifies, unfolding the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.3.2.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z X)) 2) (NOT (NUMBERP (CADAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, applying CDR-CONS, and expanding the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.3.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and opening up the definitions of LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.3.2.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (NOT (NUMBERP (CAR X))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and expanding the definitions of LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.3.2.1. (IMPLIES (AND (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D W1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS Z (CONS (CONS Z1 (CONS D W1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D W1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and expanding LENGTH, NUMBERP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.3.1. (IMPLIES (AND (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D W1) to eliminate (CAR X) and (CDR X). The result is five new goals: Case 2.1.1.3.1.3.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, opening up the functions LENGTH and EQUAL, to: T. Case 2.1.1.3.1.3.1.4. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z X)) 2) (NUMBERP (CADAR X)) (LESSP (PLUS (TV->NAT C) (CADAR X)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR X))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, rewriting with the lemma CDR-CONS, and opening up the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.3.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and opening up the functions LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.3.1.2. (IMPLIES (AND (NOT (LISTP X)) (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (NUMBERP (CAR X)) (LESSP (PLUS (TV->NAT C) (CAR X)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR X))) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding the functions LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.3.1.1. (IMPLIES (AND (NOT (LISTP W)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D W1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS Z (CONS (CONS Z1 (CONS D W1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D W1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and expanding LENGTH, NUMBERP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.2. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (EQUAL (LESSP V BASE) (NOT (ZEROP BASE))) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) (CAR X)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) (CAR X))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). But this further simplifies, appealing to the lemmas CAR-NLISTP and PLUS-0, and expanding the definitions of ZEROP, NOT, and NUMBERP, to two new formulas: Case 2.1.1.3.1.2.2. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (PLUS (TV->NAT C) 0) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which again simplifies, applying PLUS-0, and opening up ZEROP, to: (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Applying the lemma CAR-CDR-ELIM, replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D W1) to eliminate (CAR Z) and (CDR Z). We thus obtain the following five new formulas: Case 2.1.1.3.1.2.2.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NOT (NUMBERP (CADADR A))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this finally simplifies, opening up the definitions of LENGTH and EQUAL, to: T. Case 2.1.1.3.1.2.2.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W Z)) 2) (NOT (NUMBERP (CADAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying CDR-CONS, and opening up the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.2.2.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NOT (NUMBERP (CADR D))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CDR-NLISTP, and expanding the functions LENGTH, NUMBERP, and CAR, to: T. Case 2.1.1.3.1.2.2.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NOT (NUMBERP (CAR Z))) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). But this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-NLISTP, and expanding the functions LENGTH and NUMBERP, to: T. Case 2.1.1.3.1.2.2.1. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D W1)) X1))) 2) (NOT (NUMBERP D)) (LESSP (TV->NAT C) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (TV->NAT C)) 1 (CONS W (CONS (CONS Z1 (CONS D W1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D W1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, and CAR-CONS, and opening up LENGTH, NUMBERP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.2.1. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS W Z) to eliminate (CDR A) and (CAR A), Z by (CONS D X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z1 Z) to eliminate (CDR D) and (CAR D), and Z by (CONS D W1) to eliminate (CAR Z) and (CDR Z). This generates five new goals: Case 2.1.1.3.1.2.1.5. (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (NUMBERP (CADADR A)) (LESSP (PLUS (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, unfolding LENGTH and EQUAL, to: T. Case 2.1.1.3.1.2.1.4. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W Z)) 2) (NUMBERP (CADAR Z)) (LESSP (PLUS (TV->NAT C) (CADAR Z)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR Z))) 1 (CONS W Z)))))) (BIGNP (CONS W Z) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR Z))), which finally simplifies, applying CDR-CONS, and unfolding the definitions of LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.2.1.3. (IMPLIES (AND (NOT (LISTP D)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W (CONS D X1))) 2) (NUMBERP (CADR D)) (LESSP (PLUS (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADR D))) 1 (CONS W (CONS D X1))))))) (BIGNP (CONS W (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and unfolding the definitions of LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.2.1.2. (IMPLIES (AND (NOT (LISTP Z)) (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 Z) X1))) 2) (NUMBERP (CAR Z)) (LESSP (PLUS (TV->NAT C) (CAR Z)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CAR Z))) 1 (CONS W (CONS (CONS Z1 Z) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 Z) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). This finally simplifies, appealing to the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.2.1.1. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS W (CONS (CONS Z1 (CONS D W1)) X1))) 2) (NUMBERP D) (LESSP (PLUS (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) D)) 1 (CONS W (CONS (CONS Z1 (CONS D W1)) X1))))))) (BIGNP (CONS W (CONS (CONS Z1 (CONS D W1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, and CAR-CONS, and opening up the functions LENGTH, NUMBERP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.1. (IMPLIES (AND (NUMBERP V) (EQUAL (LESSP V BASE) (NOT (ZEROP BASE))) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (LESSP (PLUS (TV->NAT C) (CADADR A) W) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADADR A) W)) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). However this further simplifies, applying the lemmas COMMUTATIVITY-OF-PLUS and COMMUTATIVITY2-OF-PLUS, and unfolding the definitions of ZEROP and NOT, to: (IMPLIES (AND (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))). Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to eliminate (CDR A) and (CAR A), X by (CONS D X1) to eliminate (CAR X) and (CDR X), D by (CONS Z1 X) to eliminate (CDR D) and (CAR D), and X by (CONS D W1) to eliminate (CAR X) and (CDR X). The result is five new conjectures: Case 2.1.1.3.1.1.5. (IMPLIES (AND (NOT (LISTP A)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH A) 2) (LESSP (PLUS W (TV->NAT C) (CADADR A)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADADR A))) 1 A))))) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDDR A))), which finally simplifies, unfolding LENGTH and EQUAL, to: T. Case 2.1.1.3.1.1.4. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z X)) 2) (LESSP (PLUS W (TV->NAT C) (CADAR X)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADAR X))) 1 (CONS Z X)))))) (BIGNP (CONS Z X) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL (CDR X))), which finally simplifies, applying CDR-CONS, and opening up the functions LENGTH, ADD1, and EQUAL, to: T. Case 2.1.1.3.1.1.3. (IMPLIES (AND (NOT (LISTP D)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS D X1))) 2) (LESSP (PLUS W (TV->NAT C) (CADR D)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CADR D))) 1 (CONS Z (CONS D X1))))))) (BIGNP (CONS Z (CONS D X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). This finally simplifies, applying the lemmas CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CDR-NLISTP, PLUS-0, and CAR-CONS, and unfolding LENGTH, NUMBERP, CAR, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.1.2. (IMPLIES (AND (NOT (LISTP X)) (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 X) X1))) 2) (LESSP (PLUS W (TV->NAT C) (CAR X)) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) (CAR X))) 1 (CONS Z (CONS (CONS Z1 X) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 X) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)), which finally simplifies, rewriting with CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, CAR-NLISTP, PLUS-0, and CAR-CONS, and expanding LENGTH, NUMBERP, ZEROP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.3.1.1.1. (IMPLIES (AND (NUMBERP V) (LESSP V BASE) (NUMBERP V1) (NOT (EQUAL BASE 0)) (EQUAL (LENGTH (CONS Z (CONS (CONS Z1 (CONS D W1)) X1))) 2) (LESSP (PLUS W (TV->NAT C) D) BASE) (EQUAL NIL (CDR (PUT (LIST 'NAT V) 1 (CDR (PUT (LIST 'NAT (PLUS W (TV->NAT C) D)) 1 (CONS Z (CONS (CONS Z1 (CONS D W1)) X1))))))) (BIGNP (CONS Z (CONS (CONS Z1 (CONS D W1)) X1)) BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL NIL X1)). However this finally simplifies, applying CDR-CONS, EQUAL-LENGTH-0, ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and CAR-CONS, and opening up the definitions of LENGTH, NUMBERP, SUB1, EQUAL, and PUT, to: T. Case 2.1.1.2. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (LESSP I (SUB1 (LENGTH A))) (LESSP (CADADR (NTH-CDR I B)) BASE) (EQUAL (LIST (LIST 'NAT (CADADR (NTH-CDR I B)))) (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL (LIST (LIST 'NAT (CADADR (NTH-CDR I B)))) (CDR (NTH-CDR I A)))). However this again simplifies, using linear arithmetic, to: T. Case 2.1.1.1. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (LESSP I (SUB1 (LENGTH A))) (NOT (LESSP (CADADR (NTH-CDR I B)) BASE)) (EQUAL (LIST (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE))) (CDR (NTH-CDR I (CONS (CAR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A)) (PUT (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE)) I (CDR (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A))))))) (NUMBERP I) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL (LIST (LIST 'NAT (REMAINDER (CADADR (NTH-CDR I B)) BASE))) (CDR (NTH-CDR I A)))), which again simplifies, using linear arithmetic, to: T. Case 1. T, which simplifies, obviously, to: T. Q.E.D. [ 0.0 12.7 1.8 ] BIG-ADD-ARRAY-IS-BIG-ADD-ARRAY-LOOP-GENERALIZED (PROVE-LEMMA BIG-ADD-ARRAY-IS-BIG-ADD-ARRAY-LOOP (REWRITE) (IMPLIES (AND (LISTP A) (BIGNP A BASE) (NUMBERP BASE) (LESSP 1 BASE)) (EQUAL (BIG-ADD-ARRAY A B C BASE) (BIG-ADD-ARRAY-LOOP 0 A B (LENGTH A) C BASE))) ((USE (BIG-ADD-ARRAY-IS-BIG-ADD-ARRAY-LOOP-GENERALIZED (I 0))))) This simplifies, rewriting with EQUAL-LENGTH-0, and opening up NUMBERP, EQUAL, LESSP, AND, NTH-CDR, DIFFERENCE, and IMPLIES, to: T. Q.E.D. [ 0.0 0.1 0.0 ] BIG-ADD-ARRAY-IS-BIG-ADD-ARRAY-LOOP (PROVE-LEMMA BIG-ADD-CARRY-OUT-ON-LIST-OF-LENGTH-1 (REWRITE) (IMPLIES (AND (LISTP A) (NLISTP (CDR A))) (EQUAL (BIG-ADD-CARRY-OUT A B C BASE) (BOOL (NOT (LESSP (PLUS (UNTAG (CAR A)) (UNTAG (CAR B)) (TV->NAT C)) BASE))))) ((EXPAND (BIG-ADD-CARRY-OUT A B C BASE)))) This formula can be simplified, using the abbreviations NLISTP, AND, IMPLIES, and UNTAG, to the new conjecture: (IMPLIES (AND (LISTP A) (NOT (LISTP (CDR A)))) (EQUAL (BIG-ADD-CARRY-OUT A B C BASE) (BOOL (NOT (LESSP (PLUS (CADAR A) (CADAR B) (TV->NAT C)) BASE))))), which simplifies, applying COMMUTATIVITY-OF-PLUS and COMMUTATIVITY2-OF-PLUS, and unfolding the definitions of BIG-ADD-CARRY-OUT, UNTAG, BOOL, NOT, and TAG, to: T. Q.E.D. [ 0.0 0.0 0.0 ] BIG-ADD-CARRY-OUT-ON-LIST-OF-LENGTH-1 (PROVE-LEMMA BIG-ADD-CARRY-OUT-IS-BIG-ADD-CARRY-OUT-LOOP-GENERALIZED NIL (IMPLIES (AND (NUMBERP I) (LESSP I (LENGTH A))) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) (BIG-ADD-CARRY-OUT-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE))) ((DISABLE DIFFERENCE) (INDUCT (HINT1 I A B C BASE)))) This formula can be simplified, using the abbreviations IMPLIES, NOT, OR, AND, DIFFERENCE-ADD1-NEW, NTH-CDR-ADD1, GET-IS-CAR-NTH-CDR, UNTAG, and TAG, to the following two new formulas: Case 2. (IMPLIES (AND (LESSP I (LENGTH A)) (IMPLIES (AND (NUMBERP (ADD1 I)) (LESSP (ADD1 I) (LENGTH (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A)))) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A))) (CDR (NTH-CDR I B)) (NOT (LESSP (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) BASE) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH (PUT (LIST 'NAT (REMAINDER (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) I A)) I)) (NOT (LESSP (PLUS (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)) (TV->NAT C)) BASE)) BASE))) (NUMBERP I)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) (BIG-ADD-CARRY-OUT-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE))). This simplifies, using linear arithmetic, appealing to the lemmas COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, LENGTH-PUT, SUB1-ADD1, EQUAL-LENGTH-0, NTH-CDR-PUT-AT, CDR-CONS, LISTP-NTH-CDR, NLISTP-CDR-NTH-CDR, BIG-ADD-CARRY-OUT-ON-LIST-OF-LENGTH-1, DIFFERENCE-EQUAL-1, and GET-IS-CAR-NTH-CDR, and opening up the definitions of LESSP, AND, NOT, IMPLIES, BOOL, TAG, EQUAL, LENGTH, BIG-ADD-CARRY-OUT, UNTAG, SUB1, and BIG-ADD-CARRY-OUT-LOOP, to the following five new formulas: Case 2.5. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LISTP A)) (NUMBERP I) (NOT C)) (EQUAL '(BOOL F) (BIG-ADD-CARRY-OUT-LOOP I A B (DIFFERENCE 0 I) C BASE))). This again simplifies, unfolding the functions LENGTH, EQUAL, and LESSP, to: T. Case 2.4. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LISTP A)) (NUMBERP I) C) (EQUAL '(BOOL T) (BIG-ADD-CARRY-OUT-LOOP I A B (DIFFERENCE 0 I) C BASE))), which again simplifies, opening up the functions LENGTH, EQUAL, and LESSP, to: T. Case 2.3. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)) (NUMBERP I) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0))) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE))), which again simplifies, applying COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and LISTP-NTH-CDR, and expanding UNTAG and BIG-ADD-CARRY-OUT, to: T. Case 2.2. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) T BASE)) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) '(BOOL T))). But this again simplifies, using linear arithmetic, applying CDR-NLISTP, SUB1-ADD1, PLUS-ADD1-2, PLUS-0, CAR-NLISTP, NLISTP-CDR-NTH-CDR, GET-IS-CAR-NTH-CDR, NTH-CDR-PUT-BEFORE, NTH-CDR-ADD1, LISTP-NTH-CDR, COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, and BIG-ADD-CARRY-OUT-ON-LIST-OF-LENGTH-1, and unfolding the functions BOOL, LESSP, ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, LISTP, EQUAL, SUB1, BIG-ADD-CARRY-OUT-LOOP, TAG, and CAR, to the following six new conjectures: Case 2.2.6. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (LENGTH A) 0) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B 0 T BASE)) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE 0 I)) 0)) C). However this again simplifies, using linear arithmetic, to the goal: (IMPLIES (AND (LESSP 0 I) (LESSP I 0) (NOT (LESSP (PLUS (TV->NAT F) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (EQUAL (LENGTH A) 0) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) T BASE) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT F) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B 0 T BASE)) (NUMBERP I)) (NOT (EQUAL (SUB1 (DIFFERENCE 0 I)) 0))). But this again simplifies, using linear arithmetic, to: T. Case 2.2.5. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (EQUAL BASE 0) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (LESSP (LENGTH A) I)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) '(BOOL T))), which again simplifies, using linear arithmetic, to: T. Case 2.2.4. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP BASE)) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (LESSP (LENGTH A) I)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) '(BOOL T))), which again simplifies, using linear arithmetic, to: T. Case 2.2.3. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (NUMBERP (CADADR (NTH-CDR I B))) (NOT (LESSP (CADADR (NTH-CDR I B)) (SUB1 BASE))) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (LESSP (LENGTH A) I)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) '(BOOL T))), which again simplifies, using linear arithmetic, to: T. Case 2.2.2. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (NOT (LESSP 0 (SUB1 BASE))) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (LESSP (LENGTH A) I)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) '(BOOL T))), which again simplifies, using linear arithmetic, to: T. Case 2.2.1. (IMPLIES (AND (LESSP I (LENGTH A)) (NOT (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) (NOT (EQUAL (LENGTH A) 0)) (LESSP I (SUB1 (LENGTH A))) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (LESSP (LENGTH A) I)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) '(BOOL T))), which again simplifies, using linear arithmetic, to: T. Case 2.1. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE)) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)) (NUMBERP I)) (EQUAL (BIG-ADD-CARRY-OUT (NTH-CDR I A) (NTH-CDR I B) C BASE) (BIG-ADD-CARRY-OUT-LOOP I A B (DIFFERENCE (LENGTH A) I) C BASE))), which again simplifies, rewriting with COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, LISTP-NTH-CDR, and GET-IS-CAR-NTH-CDR, and unfolding REMAINDER, UNTAG, BIG-ADD-CARRY-OUT, TAG, BOOL, and BIG-ADD-CARRY-OUT-LOOP, to: (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (PUT (LIST 'NAT (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B)))) I A) B (SUB1 (DIFFERENCE (LENGTH A) I)) F BASE)) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0)) (EQUAL (BIG-ADD-CARRY-OUT (CDR (NTH-CDR I A)) (CDR (NTH-CDR I B)) F BASE) '(BOOL F))), which again simplifies, using linear arithmetic, applying CDR-NLISTP, PLUS-0, CAR-NLISTP, NLISTP-CDR-NTH-CDR, GET-IS-CAR-NTH-CDR, NTH-CDR-PUT-BEFORE, NTH-CDR-ADD1, LISTP-NTH-CDR, and BIG-ADD-CARRY-OUT-ON-LIST-OF-LENGTH-1, and expanding BOOL, ZEROP, TV->NAT, UNTAG, BIG-ADD-CARRY-OUT, LISTP, EQUAL, SUB1, BIG-ADD-CARRY-OUT-LOOP, CAR, LESSP, PLUS, and NUMBERP, to the following four new formulas: Case 2.1.4. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (LESSP I (SUB1 (LENGTH A))) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (NUMBERP (CADADR (NTH-CDR I B)))) (LESSP (CADADR (NTH-CDR I B)) BASE)). This again simplifies, using linear arithmetic, to: T. Case 2.1.3. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (LESSP I (SUB1 (LENGTH A))) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (NOT (NUMBERP (CADADR (NTH-CDR I B))))) (LESSP 0 BASE)), which again simplifies, using linear arithmetic, to: T. Case 2.1.2. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (LESSP 0 BASE) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (LESSP I (SUB1 (LENGTH A)))) (NUMBERP BASE)), which again simplifies, using linear arithmetic, to: T. Case 2.1.1. (IMPLIES (AND (LESSP I (LENGTH A)) (LESSP (PLUS (TV->NAT C) (CADAR (NTH-CDR I A)) (CADAR (NTH-CDR I B))) BASE) (NOT (EQUAL (LENGTH A) 0)) (NOT (NUMBERP (CADADR (NTH-CDR I B)))) (LESSP 0 BASE) (NUMBERP I) (EQUAL (SUB1 (DIFFERENCE (LENGTH A) I)) 0) (LESSP I (SUB1 (LENGTH A)))) (NOT (EQUAL BASE 0))), which again simplifies, using linear arithmetic, to: T. Case 1. T, which simplifies, trivially, to: T. Q.E.D. [ 0.0 1.6 0.0 ] BIG-ADD-CARRY-OUT-IS-BIG-ADD-CARRY-OUT-LOOP-GENERALIZED (PROVE-LEMMA BIG-ADD-CARRY-OUT-IS-BIG-ADD-CARRY-OUT-LOOP (REWRITE) (IMPLIES (LISTP A) (EQUAL (BIG-ADD-CARRY-OUT A B C BASE) (BIG-ADD-CARRY-OUT-LOOP 0 A B (LENGTH A) C BASE))) ((USE (BIG-ADD-CARRY-OUT-IS-BIG-ADD-CARRY-OUT-LOOP-GENERALIZED (I 0))))) WARNING: the newly proposed lemma, BIG-ADD-CARRY-OUT-IS-BIG-ADD-CARRY-OUT-LOOP, could be applied whenever the previously added lemma: BIG-ADD-CARRY-OUT-ON-LIST-OF-LENGTH-1 could. This formula simplifies, appealing to the lemma EQUAL-LENGTH-0, and opening up the functions NUMBERP, EQUAL, LESSP, AND, NTH-CDR, DIFFERENCE, and IMPLIES, to: T. Q.E.D. [ 0.0 0.0 0.0 ] BIG-ADD-CARRY-OUT-IS-BIG-ADD-CARRY-OUT-LOOP (DEFN BIG-ADD-PROGRAM NIL '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) Observe that (LISTP (BIG-ADD-PROGRAM)) is a theorem. [ 0.0 0.0 0.0 ] BIG-ADD-PROGRAM (DEFN BIG-ADD-LOOP-CLOCK (N) (IF (ZEROP N) 0 (IF (EQUAL N 1) 11 (PLUS 19 (BIG-ADD-LOOP-CLOCK (SUB1 N)))))) Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT N) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIG-ADD-LOOP-CLOCK is accepted under the principle of definition. Note that (NUMBERP (BIG-ADD-LOOP-CLOCK N)) is a theorem. [ 0.0 0.0 0.0 ] BIG-ADD-LOOP-CLOCK (DEFN BIG-ADD-CLOCK (N) (PLUS 3 (BIG-ADD-LOOP-CLOCK N))) Observe that (NUMBERP (BIG-ADD-CLOCK N)) is a theorem. [ 0.0 0.0 0.0 ] BIG-ADD-CLOCK (DEFN ARRAY (NAME SEGMENT) (CDR (ASSOC NAME SEGMENT))) [ 0.0 0.0 0.0 ] ARRAY (DEFN PUT-ARRAY (A NAME SEGMENT) (PUT-ASSOC A NAME SEGMENT)) Note that: (OR (LISTP (PUT-ARRAY A NAME SEGMENT)) (EQUAL (PUT-ARRAY A NAME SEGMENT) SEGMENT)) is a theorem. [ 0.0 0.0 0.0 ] PUT-ARRAY (DISABLE BOOLEANP) [ 0.0 0.0 0.0 ] BOOLEANP-OFF3 (DEFN TV (B) (EQUAL B 'T)) Observe that (OR (FALSEP (TV B)) (TRUEP (TV B))) is a theorem. [ 0.0 0.0 0.0 ] TV (ENABLE ASSOC-PUT-ASSOC-2) [ 0.0 0.0 0.0 ] ASSOC-PUT-ASSOC-2-ON (DISABLE GET-IS-CAR-NTH-CDR) [ 0.0 0.0 0.0 ] GET-IS-CAR-NTH-CDR-OFF (PROVE-LEMMA P-STEP1-OPENER (REWRITE) (EQUAL (P-STEP1 (CONS OPCODE OPERANDS) P) (IF (P-INS-OKP (CONS OPCODE OPERANDS) P) (P-INS-STEP (CONS OPCODE OPERANDS) P) (P-HALT P (X-Y-ERROR-MSG 'P OPCODE)))) ((DISABLE P-INS-OKP P-INS-STEP))) WARNING: Note that the rewrite rule P-STEP1-OPENER will be stored so as to apply only to terms with the nonrecursive function symbol P-STEP1. This formula can be simplified, using the abbreviations CDR-CONS, UNPACK-PACK, and X-Y-ERROR-MSG, to: (EQUAL (P-STEP1 (CONS OPCODE OPERANDS) P) (IF (P-INS-OKP (CONS OPCODE OPERANDS) P) (P-INS-STEP (CONS OPCODE OPERANDS) P) (P-HALT P (PACK (APPEND '(73 76 76 69 71 65 76 45 . 0) (APPEND (UNPACK OPCODE) '(45 73 78 83 84 82 85 67 84 73 79 78 . 0))))))), which simplifies, applying CAR-CONS, and opening up the definitions of P-HALT, X-Y-ERROR-MSG, UNPACK, CDR, CAR, LISTP, APPEND, and P-STEP1, to: T. Q.E.D. [ 0.0 0.0 0.0 ] P-STEP1-OPENER (DISABLE P-STEP1) [ 0.0 0.0 0.0 ] P-STEP1-OFF (PROVE-LEMMA P-OPENER (REWRITE) (AND (EQUAL (P S 0) S) (EQUAL (P (P-STATE PC CTRL TEMP PROG DATA MAX-CTRL MAX-TEMP WORD-SIZE PSW) (ADD1 N)) (P (P-STEP (P-STATE PC CTRL TEMP PROG DATA MAX-CTRL MAX-TEMP WORD-SIZE PSW)) N))) ((DISABLE P-STEP))) WARNING: Note that the proposed lemma P-OPENER is to be stored as zero type prescription rules, zero compound recognizer rules, zero linear rules, and two replacement rules. This conjecture can be simplified, using the abbreviation AND, to two new goals: Case 2. (EQUAL (P S 0) S), which simplifies, opening up EQUAL and P, to: T. Case 1. (EQUAL (P (P-STATE PC CTRL TEMP PROG DATA MAX-CTRL MAX-TEMP WORD-SIZE PSW) (ADD1 N)) (P (P-STEP (P-STATE PC CTRL TEMP PROG DATA MAX-CTRL MAX-TEMP WORD-SIZE PSW)) N)), which simplifies, applying SUB1-ADD1, and opening up P, to the new conjecture: (IMPLIES (NOT (NUMBERP N)) (EQUAL (P (P-STEP (P-STATE PC CTRL TEMP PROG DATA MAX-CTRL MAX-TEMP WORD-SIZE PSW)) 0) (P (P-STEP (P-STATE PC CTRL TEMP PROG DATA MAX-CTRL MAX-TEMP WORD-SIZE PSW)) N))), which again simplifies, expanding the definitions of EQUAL and P, to: T. Q.E.D. [ 0.0 0.0 0.0 ] P-OPENER (DISABLE P) [ 0.0 0.0 0.0 ] P-OFF (PROVE-LEMMA BIGNP-IMPLIES-P-OBJECTP-GET (REWRITE) (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (AND (LISTP (GET I A)) (EQUAL (CDDR (GET I A)) NIL) (EQUAL (CAR (GET I A)) 'NAT) (NUMBERP (CADR (GET I A))) (LESSP (CADR (GET I A)) (EXP 2 WORD-SIZE))))) WARNING: Note that BIGNP-IMPLIES-P-OBJECTP-GET contains the free variable WORD-SIZE which will be chosen by instantiating the hypothesis: (BIGNP A (EXP 2 WORD-SIZE)). WARNING: Note that BIGNP-IMPLIES-P-OBJECTP-GET contains the free variable WORD-SIZE which will be chosen by instantiating the hypothesis: (BIGNP A (EXP 2 WORD-SIZE)). WARNING: Note that BIGNP-IMPLIES-P-OBJECTP-GET contains the free variable WORD-SIZE which will be chosen by instantiating the hypothesis: (BIGNP A (EXP 2 WORD-SIZE)). WARNING: Note that BIGNP-IMPLIES-P-OBJECTP-GET contains the free variable WORD-SIZE which will be chosen by instantiating the hypothesis: (BIGNP A (EXP 2 WORD-SIZE)). WARNING: When the linear lemma BIGNP-IMPLIES-P-OBJECTP-GET is stored under (CADR (GET I A)) it contains the free variable WORD-SIZE which will be chosen by instantiating the hypothesis (BIGNP A (EXP 2 WORD-SIZE)). WARNING: When the linear lemma BIGNP-IMPLIES-P-OBJECTP-GET is stored under (EXP 2 WORD-SIZE) it contains the free variables I and A which will be chosen by instantiating the hypotheses (BIGNP A (EXP 2 WORD-SIZE)) and (LESSP I (LENGTH A)). WARNING: Note that the proposed lemma BIGNP-IMPLIES-P-OBJECTP-GET is to be stored as zero type prescription rules, zero compound recognizer rules, two linear rules, and four replacement rules. This simplifies, opening up the definition of AND, to five new formulas: Case 5. (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LISTP (GET I A))), which we will name *1. Case 4. (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CDDR (GET I A)) NIL)), which we would usually push and work on later by induction. But if we must use induction to prove the input conjecture, we prefer to induct on the original formulation of the problem. Thus we will disregard all that we have previously done, give the name *1 to the original input, and work on it. So now let us consider: (AND (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LISTP (GET I A))) (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CDDR (GET I A)) NIL)) (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CAR (GET I A)) 'NAT)) (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (NUMBERP (CADR (GET I A)))) (IMPLIES (AND (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LESSP (CADR (GET I A)) (EXP 2 WORD-SIZE)))), which we named *1 above. We will appeal to induction. There are 26 plausible inductions. They merge into two likely candidate inductions, both of which are unflawed. However, one of these is more likely than the other. We will induct according to the following scheme: (AND (IMPLIES (NLISTP A) (p I A WORD-SIZE)) (IMPLIES (AND (NOT (NLISTP A)) (p (SUB1 I) (CDR A) WORD-SIZE)) (p I A WORD-SIZE))). Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP establish that the measure (COUNT A) decreases according to the well-founded relation LESSP in each induction step of the scheme. Note, however, the inductive instance chosen for I. The above induction scheme produces the following 20 new conjectures: Case 20.(IMPLIES (AND (NLISTP A) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LISTP (GET I A))). This simplifies, opening up NLISTP, BIGNP, LENGTH, EQUAL, and LESSP, to: T. Case 19.(IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR A) (EXP 2 WORD-SIZE))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LISTP (GET I A))). This simplifies, unfolding the functions NLISTP, BIGNP, TYPE, and UNTAG, to: T. Case 18.(IMPLIES (AND (NOT (NLISTP A)) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LISTP (GET I A))). This simplifies, applying SUB1-ADD1, and unfolding NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 17.(IMPLIES (AND (NOT (NLISTP A)) (LISTP (GET (SUB1 I) (CDR A))) (EQUAL (CDDR (GET (SUB1 I) (CDR A))) NIL) (EQUAL (CAR (GET (SUB1 I) (CDR A))) 'NAT) (NUMBERP (CADR (GET (SUB1 I) (CDR A)))) (LESSP (CADR (GET (SUB1 I) (CDR A))) (EXP 2 WORD-SIZE)) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LISTP (GET I A))), which simplifies, applying SUB1-ADD1, and opening up NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 16.(IMPLIES (AND (NLISTP A) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CDDR (GET I A)) NIL)). This simplifies, unfolding the definitions of NLISTP, BIGNP, LENGTH, EQUAL, and LESSP, to: T. Case 15.(IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR A) (EXP 2 WORD-SIZE))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CDDR (GET I A)) NIL)). This simplifies, unfolding the definitions of NLISTP, BIGNP, TYPE, and UNTAG, to: T. Case 14.(IMPLIES (AND (NOT (NLISTP A)) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CDDR (GET I A)) NIL)). This simplifies, rewriting with SUB1-ADD1, and opening up the definitions of NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 13.(IMPLIES (AND (NOT (NLISTP A)) (LISTP (GET (SUB1 I) (CDR A))) (EQUAL (CDDR (GET (SUB1 I) (CDR A))) NIL) (EQUAL (CAR (GET (SUB1 I) (CDR A))) 'NAT) (NUMBERP (CADR (GET (SUB1 I) (CDR A)))) (LESSP (CADR (GET (SUB1 I) (CDR A))) (EXP 2 WORD-SIZE)) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CDDR (GET I A)) NIL)), which simplifies, applying SUB1-ADD1, and unfolding the functions NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 12.(IMPLIES (AND (NLISTP A) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CAR (GET I A)) 'NAT)). This simplifies, unfolding the definitions of NLISTP, BIGNP, LENGTH, EQUAL, and LESSP, to: T. Case 11.(IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR A) (EXP 2 WORD-SIZE))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CAR (GET I A)) 'NAT)). This simplifies, opening up the definitions of NLISTP, BIGNP, TYPE, and UNTAG, to: T. Case 10.(IMPLIES (AND (NOT (NLISTP A)) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CAR (GET I A)) 'NAT)). This simplifies, rewriting with SUB1-ADD1, and opening up the definitions of NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 9. (IMPLIES (AND (NOT (NLISTP A)) (LISTP (GET (SUB1 I) (CDR A))) (EQUAL (CDDR (GET (SUB1 I) (CDR A))) NIL) (EQUAL (CAR (GET (SUB1 I) (CDR A))) 'NAT) (NUMBERP (CADR (GET (SUB1 I) (CDR A)))) (LESSP (CADR (GET (SUB1 I) (CDR A))) (EXP 2 WORD-SIZE)) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (EQUAL (CAR (GET I A)) 'NAT)), which simplifies, applying SUB1-ADD1, and expanding the functions NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 8. (IMPLIES (AND (NLISTP A) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (NUMBERP (CADR (GET I A)))). This simplifies, expanding the functions NLISTP, BIGNP, LENGTH, EQUAL, and LESSP, to: T. Case 7. (IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR A) (EXP 2 WORD-SIZE))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (NUMBERP (CADR (GET I A)))). This simplifies, unfolding NLISTP, BIGNP, TYPE, and UNTAG, to: T. Case 6. (IMPLIES (AND (NOT (NLISTP A)) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (NUMBERP (CADR (GET I A)))). This simplifies, applying SUB1-ADD1, and expanding the functions NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 5. (IMPLIES (AND (NOT (NLISTP A)) (LISTP (GET (SUB1 I) (CDR A))) (EQUAL (CDDR (GET (SUB1 I) (CDR A))) NIL) (EQUAL (CAR (GET (SUB1 I) (CDR A))) 'NAT) (NUMBERP (CADR (GET (SUB1 I) (CDR A)))) (LESSP (CADR (GET (SUB1 I) (CDR A))) (EXP 2 WORD-SIZE)) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (NUMBERP (CADR (GET I A)))), which simplifies, rewriting with SUB1-ADD1, and unfolding the functions NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 4. (IMPLIES (AND (NLISTP A) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LESSP (CADR (GET I A)) (EXP 2 WORD-SIZE))). This simplifies, unfolding the functions NLISTP, BIGNP, LENGTH, EQUAL, and LESSP, to: T. Case 3. (IMPLIES (AND (NOT (NLISTP A)) (NOT (BIGNP (CDR A) (EXP 2 WORD-SIZE))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LESSP (CADR (GET I A)) (EXP 2 WORD-SIZE))). This simplifies, opening up NLISTP, BIGNP, TYPE, and UNTAG, to: T. Case 2. (IMPLIES (AND (NOT (NLISTP A)) (NOT (LESSP (SUB1 I) (LENGTH (CDR A)))) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LESSP (CADR (GET I A)) (EXP 2 WORD-SIZE))). This simplifies, applying the lemma SUB1-ADD1, and expanding NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. Case 1. (IMPLIES (AND (NOT (NLISTP A)) (LISTP (GET (SUB1 I) (CDR A))) (EQUAL (CDDR (GET (SUB1 I) (CDR A))) NIL) (EQUAL (CAR (GET (SUB1 I) (CDR A))) 'NAT) (NUMBERP (CADR (GET (SUB1 I) (CDR A)))) (LESSP (CADR (GET (SUB1 I) (CDR A))) (EXP 2 WORD-SIZE)) (BIGNP A (EXP 2 WORD-SIZE)) (LESSP I (LENGTH A))) (LESSP (CADR (GET I A)) (EXP 2 WORD-SIZE))). This simplifies, rewriting with SUB1-ADD1, and opening up the definitions of NLISTP, BIGNP, TYPE, UNTAG, LENGTH, LESSP, EQUAL, and GET, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.7 0.0 ] BIGNP-IMPLIES-P-OBJECTP-GET (PROVE-LEMMA BOOLEANP-NOT-F (REWRITE) (IMPLIES (AND (BOOLEANP C) (NOT (EQUAL C 'F))) (EQUAL (EQUAL C 'T) T)) ((ENABLE BOOLEANP))) This formula simplifies, opening up the definition of BOOLEANP, to: T. Q.E.D. [ 0.0 0.0 0.0 ] BOOLEANP-NOT-F (PROVE-LEMMA LESSP-1-BASE (REWRITE) (IMPLIES (NOT (ZEROP WORD-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE)))) WARNING: Note that the proposed lemma LESSP-1-BASE is to be stored as zero type prescription rules, zero compound recognizer rules, one linear rule, and zero replacement rules. This formula can be simplified, using the abbreviations ZEROP, NOT, and IMPLIES, to the new conjecture: (IMPLIES (AND (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))), which we will name *1. We will appeal to induction. There is only one plausible induction. We will induct according to the following scheme: (AND (IMPLIES (ZEROP WORD-SIZE) (p WORD-SIZE)) (IMPLIES (AND (NOT (ZEROP WORD-SIZE)) (p (SUB1 WORD-SIZE))) (p WORD-SIZE))). Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP inform us that the measure (COUNT WORD-SIZE) decreases according to the well-founded relation LESSP in each induction step of the scheme. The above induction scheme leads to the following three new formulas: Case 3. (IMPLIES (AND (ZEROP WORD-SIZE) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))). This simplifies, opening up the definition of ZEROP, to: T. Case 2. (IMPLIES (AND (NOT (ZEROP WORD-SIZE)) (EQUAL (SUB1 WORD-SIZE) 0) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))). This simplifies, opening up the definitions of ZEROP and EXP, to the new goal: (IMPLIES (AND (EQUAL (SUB1 WORD-SIZE) 0) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE)) (LESSP 1 (TIMES 2 (EXP 2 (SUB1 WORD-SIZE))))), which again simplifies, opening up the functions EXP, TIMES, and LESSP, to: T. Case 1. (IMPLIES (AND (NOT (ZEROP WORD-SIZE)) (LESSP 1 (EXP 2 (SUB1 WORD-SIZE))) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))), which simplifies, rewriting with PLUS-0 and EQUAL-TIMES-0, and opening up the functions ZEROP, EXP, SUB1, NUMBERP, EQUAL, and TIMES, to the new formula: (IMPLIES (AND (LESSP 1 (EXP 2 (SUB1 WORD-SIZE))) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE)) (LESSP 1 (PLUS (EXP 2 (SUB1 WORD-SIZE)) (EXP 2 (SUB1 WORD-SIZE))))), which again simplifies, using linear arithmetic, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.0 ] LESSP-1-BASE (PROVE-LEMMA ASSOC-PUT-ASSOC-2-NEW (REWRITE) (IMPLIES (NOT (EQUAL A B)) (EQUAL (ASSOC A (PUT-ASSOC VAL B SEGMENT)) (ASSOC A SEGMENT)))) Call the conjecture *1. We will appeal to induction. There are two plausible inductions. However, they merge into one likely candidate induction. We will induct according to the following scheme: (AND (IMPLIES (NLISTP SEGMENT) (p A VAL B SEGMENT)) (IMPLIES (AND (NOT (NLISTP SEGMENT)) (EQUAL B (CAAR SEGMENT))) (p A VAL B SEGMENT)) (IMPLIES (AND (NOT (NLISTP SEGMENT)) (NOT (EQUAL B (CAAR SEGMENT))) (p A VAL B (CDR SEGMENT))) (p A VAL B SEGMENT))). Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of NLISTP can be used to establish that the measure (COUNT SEGMENT) decreases according to the well-founded relation LESSP in each induction step of the scheme. The above induction scheme generates three new formulas: Case 3. (IMPLIES (AND (NLISTP SEGMENT) (NOT (EQUAL A B))) (EQUAL (ASSOC A (PUT-ASSOC VAL B SEGMENT)) (ASSOC A SEGMENT))), which simplifies, expanding the definitions of NLISTP, PUT-ASSOC, ASSOC, and EQUAL, to: T. Case 2. (IMPLIES (AND (NOT (NLISTP SEGMENT)) (EQUAL B (CAAR SEGMENT)) (NOT (EQUAL A B))) (EQUAL (ASSOC A (PUT-ASSOC VAL B SEGMENT)) (ASSOC A SEGMENT))), which simplifies, applying the lemmas CDR-CONS and CAR-CONS, and unfolding the definitions of NLISTP, PUT-ASSOC, and ASSOC, to: T. Case 1. (IMPLIES (AND (NOT (NLISTP SEGMENT)) (NOT (EQUAL B (CAAR SEGMENT))) (EQUAL (ASSOC A (PUT-ASSOC VAL B (CDR SEGMENT))) (ASSOC A (CDR SEGMENT))) (NOT (EQUAL A B))) (EQUAL (ASSOC A (PUT-ASSOC VAL B SEGMENT)) (ASSOC A SEGMENT))), which simplifies, applying CDR-CONS and CAR-CONS, and expanding NLISTP, PUT-ASSOC, and ASSOC, to: T. That finishes the proof of *1. Q.E.D. [ 0.0 0.0 0.0 ] ASSOC-PUT-ASSOC-2-NEW (ENABLE DEFINEDP-PUT-ASSOC) [ 0.0 0.0 0.0 ] DEFINEDP-PUT-ASSOC-ON1 (PROVE-LEMMA BOOLEANP-NOT-F-TV->NAT (REWRITE) (IMPLIES (AND (BOOLEANP C) (NOT (EQUAL C 'F))) (EQUAL (TV->NAT C) 1)) ((ENABLE TV->NAT))) This conjecture simplifies, unfolding the definition of TV->NAT, to: (IMPLIES (AND (BOOLEANP C) (NOT (EQUAL C 'F))) C). But this again simplifies, unfolding the function BOOLEANP, to: T. Q.E.D. [ 0.0 0.0 0.0 ] BOOLEANP-NOT-F-TV->NAT (DEFN BIG-ADD-LOOP-CORRECT-HINT (A B I DATA-SEGMENT C WORD-SIZE) (IF (AND (DEFINEDP A DATA-SEGMENT) (LESSP I (LENGTH (ARRAY A DATA-SEGMENT)))) (IF (ZEROP (SUB1 (DIFFERENCE (LENGTH (ARRAY A DATA-SEGMENT)) I))) T (BIG-ADD-LOOP-CORRECT-HINT A B (ADD1 I) (PUT-ASSOC (PUT (TAG 'NAT (REMAINDER (PLUS (UNTAG (GET I (ARRAY A DATA-SEGMENT))) (UNTAG (GET I (ARRAY B DATA-SEGMENT))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (ARRAY A DATA-SEGMENT)) A DATA-SEGMENT) (IF (LESSP (PLUS (UNTAG (GET I (ARRAY A DATA-SEGMENT))) (UNTAG (GET I (ARRAY B DATA-SEGMENT))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T) WORD-SIZE)) T) ((LESSP (DIFFERENCE (LENGTH (ARRAY A DATA-SEGMENT)) I)))) Linear arithmetic, the lemmas DIFFERENCE-ADD1-NEW, LENGTH-PUT, ASSOC-PUT-ASSOC-2, CDR-CONS, COMMUTATIVITY2-OF-PLUS, and COMMUTATIVITY-OF-PLUS, and the definitions of TAG, BOOL-TO-NAT, UNTAG, ZEROP, AND, and ARRAY can be used to establish that the measure: (DIFFERENCE (LENGTH (ARRAY A DATA-SEGMENT)) I) decreases according to the well-founded relation LESSP in each recursive call. Hence, BIG-ADD-LOOP-CORRECT-HINT is accepted under the principle of definition. Note that (TRUEP (BIG-ADD-LOOP-CORRECT-HINT A B I DATA-SEGMENT C WORD-SIZE)) is a theorem. [ 0.0 0.1 0.0 ] BIG-ADD-LOOP-CORRECT-HINT (ENABLE PUT-ASSOC-PUT-ASSOC) [ 0.0 0.0 0.0 ] PUT-ASSOC-PUT-ASSOC-ON1 (PROVE-LEMMA BIG-ADD-LOOP-CORRECT-GENERALIZED NIL (IMPLIES (AND (LESSP (LENGTH (ARRAY A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (ZEROP WORD-SIZE)) (LISTP CTRL-STK) (BIGNP (ARRAY A DATA-SEGMENT) (EXP 2 WORD-SIZE)) (BIGNP (ARRAY B DATA-SEGMENT) (EXP 2 WORD-SIZE)) (NOT (LESSP MAX-TEMP-STK-SIZE (ADD1 (ADD1 (ADD1 (LENGTH TEMP-STK)))))) (EQUAL (DEFINITION 'BIG-ADD PROG-SEGMENT) (BIG-ADD-PROGRAM)) (DEFINEDP A DATA-SEGMENT) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I N) (EQUAL N (LENGTH (ARRAY A DATA-SEGMENT))) (EQUAL N (LENGTH (ARRAY B DATA-SEGMENT))) (BOOLEANP C)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (CONS 'A (LIST 'ADDR (CONS A I))) (CONS 'B (LIST 'ADDR (CONS B I))) (CONS 'N (LIST 'NAT (DIFFERENCE N I)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (BIG-ADD-LOOP-CLOCK (DIFFERENCE N I))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP I (ARRAY A DATA-SEGMENT) (ARRAY B DATA-SEGMENT) (DIFFERENCE N I) (TV C) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP I (ARRAY A DATA-SEGMENT) (ARRAY B DATA-SEGMENT) (DIFFERENCE N I) (TV C) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))) ((INDUCT (BIG-ADD-LOOP-CORRECT-HINT A B I DATA-SEGMENT C WORD-SIZE)))) This conjecture can be simplified, using the abbreviations ZEROP, IMPLIES, NOT, OR, AND, PUT-ASSOC-PUT-ASSOC, DEFINEDP-PUT-ASSOC, UNTAG, TAG, TV, BIG-ADD-PROGRAM, DEFINITION, and ARRAY, to three new goals: Case 3. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (ZEROP (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (LESSP MAX-TEMP-STK-SIZE (ADD1 (ADD1 (ADD1 (LENGTH TEMP-STK)))))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I N) (EQUAL N (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL N (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE N I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (BIG-ADD-LOOP-CLOCK (DIFFERENCE N I))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE N I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE N I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which simplifies, applying the lemmas SUB1-ADD1, COMMUTATIVITY2-OF-PLUS, COMMUTATIVITY-OF-PLUS, and P-PC-P-STATE, and unfolding ZEROP, LESSP, PLUS, BIG-ADD-LOOP-CLOCK, BOOL, UNTAG, EQUAL, BIG-ADD-CARRY-OUT-LOOP, TAG, and BIG-ADD-ARRAY-LOOP, to six new formulas: Case 3.6. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 11) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, rewriting with the lemmas P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-CTRL-STK-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, SUB1-ADD1, and P-OPENER, and opening up the definitions of SUB1, EQUAL, P-INS-STEP, PUSH, POP, FETCH, FETCH-ADP, ADD1-P-PC, ADD1-ADDR, P-FETCH-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, DEFINIENS, UNTAG, P-OBJECTP, TOP, P-FETCH-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, P-STEP, P-HALT, X-Y-ERROR-MSG, LOCAL-VAR-VALUE, BINDINGS, ASSOC, CDR, P-PUSH-LOCAL-STEP, LESSP, LENGTH, and P-PUSH-LOCAL-OKP, to two new formulas: Case 3.6.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (NOT (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 3)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-PUSH-LOCAL-INSTRUCTION) 9) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.6.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 4)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS B I)) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 9) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, applying P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-CTRL-STK-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, BIGNP-IMPLIES-P-OBJECTP-GET, and P-OPENER, and unfolding the definitions of P-INS-STEP, PUSH, POP, FETCH, FETCH-ADP, ADD1-P-PC, ADD1-ADDR, P-FETCH-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, DEFINIENS, UNTAG, P-OBJECTP, TOP, P-FETCH-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, P-STEP, P-HALT, X-Y-ERROR-MSG, BOOL, TAG, FIX-SMALL-NATURAL, REMAINDER, BOOL-TO-NAT, P-ADD-NAT-WITH-CARRY-STEP, TOP2, TOP1, SMALL-NATURALP, and P-ADD-NAT-WITH-CARRY-OKP, to the following seven new formulas: Case 3.6.1.7. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 4)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS B I)) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 9) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this again simplifies, using linear arithmetic, to: T. Case 3.6.1.6. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (NOT (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 5)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (GET I (CDR (ASSOC B DATA-SEGMENT))) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-ADD-NAT-WITH-CARRY-INSTRUCTION) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic and rewriting with BIGNP-IMPLIES-P-OBJECTP-GET, to: T. Case 3.6.1.5. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (NOT (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 5)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (GET I (CDR (ASSOC B DATA-SEGMENT))) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-ADD-NAT-WITH-CARRY-INSTRUCTION) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, using linear arithmetic and applying BIGNP-IMPLIES-P-OBJECTP-GET, to: T. Case 3.6.1.4. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (LESSP (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). But this again simplifies, applying BOOLEANP-NOT-F, PLUS-0, PLUS-ADD1-1, and SUB1-ADD1, and unfolding the functions TV->NAT, ZEROP, LESSP, and EQUAL, to: T. Case 3.6.1.3. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (NOT (LESSP (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (REMAINDER (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this again simplifies, applying BOOLEANP-NOT-F, PLUS-0, PLUS-ADD1-1, SUB1-ADD1, REMAINDER-CARRYOUT1, P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CAR-CONS, P-CTRL-STK-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, CDR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and unfolding TV->NAT, ZEROP, LESSP, EQUAL, DIFFERENCE, P-INS-STEP, PUSH, LOCAL-VAR-VALUE, TOP, BINDINGS, ASSOC, DEFINIENS, CDR, ADD1-P-PC, ADD1-ADDR, P-PUSH-LOCAL-STEP, P-INS-OKP, CAR, LENGTH, P-PUSH-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, P-STEP, DEPOSIT, PUT-VALUE, DEPOSIT-ADP, TOP1, P-DEPOSIT-STEP, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, UNTAG, P-OBJECTP, POP, P-DEPOSIT-OKP, P-HALT, and X-Y-ERROR-MSG, to the following four new formulas: Case 3.6.1.3.4. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (NOT (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 8)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-PUSH-LOCAL-INSTRUCTION) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, using linear arithmetic, to: T. Case 3.6.1.3.3. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying P-STEP1-OPENER, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, P-WORD-SIZE-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and unfolding the definitions of P-HALT, X-Y-ERROR-MSG, P-INS-STEP, PUSH, POP, TAG, SUB1, ADD1-P-PC, ADD1-ADDR, P-SUB1-NAT-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, SMALL-NATURALP, NUMBERP, UNTAG, CDR, LISTP, P-OBJECTP, TOP, P-SUB1-NAT-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, and P-STEP, to the following two new formulas: Case 3.6.1.3.3.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (NOT (LESSP 1 (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-SUB1-NAT-INSTRUCTION) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, using linear arithmetic, to: T. Case 3.6.1.3.3.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 10)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 0) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and expanding P-INS-STEP, SET-LOCAL-VAR-VALUE, BINDINGS, PUT-ASSOC, PUT-VALUE, RET-PC, P-FRAME, POP, PUSH, CDR, TOP, ADD1-P-PC, ADD1-ADDR, P-SET-LOCAL-STEP, P-INS-OKP, CAR, P-SET-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, P-STEP, P-TEST-AND-JUMP-STEP, PC, P-TEST-NAT-AND-JUMP-STEP, P-TEST-AND-JUMP-OKP, P-OBJECTP, LISTP, LESSP, NUMBERP, SMALL-NATURALP, TYPE, P-OBJECTP-TYPE, P-TEST-NATP, UNTAG, P-TEST-NAT-AND-JUMP-OKP, P-RET-STEP, and P-RET-OKP, to: T. Case 3.6.1.3.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (EQUAL (EXP 2 WORD-SIZE) 0) (NOT (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 8)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-PUSH-LOCAL-INSTRUCTION) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). But this again simplifies, using linear arithmetic, to: T. Case 3.6.1.3.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE)))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (EQUAL (EXP 2 WORD-SIZE) 0) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.6.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (EQUAL C 'F) (LESSP (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying PLUS-0, and opening up BOOLEANP, EQUAL, TV->NAT, and ZEROP, to: T. Case 3.6.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (EQUAL C 'F) (NOT (LESSP (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (REMAINDER (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, applying PLUS-0, REMAINDER-CARRYOUT0, P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CAR-CONS, P-CTRL-STK-P-STATE, SUB1-ADD1, P-MAX-TEMP-STK-SIZE-P-STATE, CDR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and unfolding the definitions of BOOLEANP, EQUAL, TV->NAT, ZEROP, P-INS-STEP, PUSH, LOCAL-VAR-VALUE, TOP, BINDINGS, ASSOC, DEFINIENS, CDR, ADD1-P-PC, ADD1-ADDR, P-PUSH-LOCAL-STEP, P-INS-OKP, CAR, LESSP, LENGTH, P-PUSH-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, P-STEP, DEPOSIT, PUT-VALUE, DEPOSIT-ADP, TOP1, P-DEPOSIT-STEP, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, UNTAG, P-OBJECTP, POP, P-DEPOSIT-OKP, P-HALT, and X-Y-ERROR-MSG, to the following two new formulas: Case 3.6.1.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 8)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-PUSH-LOCAL-INSTRUCTION) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, using linear arithmetic, to: T. Case 3.6.1.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying the lemmas P-STEP1-OPENER, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, P-WORD-SIZE-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and expanding the definitions of P-HALT, X-Y-ERROR-MSG, P-INS-STEP, PUSH, POP, TAG, SUB1, ADD1-P-PC, ADD1-ADDR, P-SUB1-NAT-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, SMALL-NATURALP, NUMBERP, UNTAG, CDR, LISTP, P-OBJECTP, TOP, P-SUB1-NAT-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, and P-STEP, to two new conjectures: Case 3.6.1.1.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (NOT (LESSP 1 (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-SUB1-NAT-INSTRUCTION) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.6.1.1.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 10)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 0) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and unfolding the definitions of P-INS-STEP, SET-LOCAL-VAR-VALUE, BINDINGS, PUT-ASSOC, PUT-VALUE, RET-PC, P-FRAME, POP, PUSH, CDR, TOP, ADD1-P-PC, ADD1-ADDR, P-SET-LOCAL-STEP, P-INS-OKP, CAR, P-SET-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, P-STEP, P-TEST-AND-JUMP-STEP, PC, P-TEST-NAT-AND-JUMP-STEP, P-HALT, X-Y-ERROR-MSG, P-TEST-AND-JUMP-OKP, P-OBJECTP, LISTP, LESSP, NUMBERP, SMALL-NATURALP, TYPE, P-OBJECTP-TYPE, P-TEST-NATP, UNTAG, and P-TEST-NAT-AND-JUMP-OKP, to the following two new conjectures: Case 3.6.1.1.1.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE)) (NOT (EQUAL (EXP 2 WORD-SIZE) 0))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 21)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 0)))) RET-PC) CTRL-STK) (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 1) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this finally simplifies, applying P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, P-TEMP-STK-P-STATE, CAR-CONS, CDR-CONS, P-CTRL-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and opening up the functions P-INS-STEP, RET-PC, TOP, POP, P-RET-STEP, P-INS-OKP, CAR, P-RET-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, and P-STEP, to: T. Case 3.6.1.1.1.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (NOT (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE)) (EQUAL (EXP 2 WORD-SIZE) 0)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 11)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 0)))) RET-PC) CTRL-STK) (CONS '(NAT 0) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-TEST-NAT-AND-JUMP-INSTRUCTION) 1) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (DIFFERENCE (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this finally simplifies, using linear arithmetic, to: T. Case 3.5. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 19) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 19) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, using linear arithmetic, to: T. Case 3.4. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 0) (P-STATE RET-PC CTRL-STK (CONS '(BOOL T) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.3. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 11) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-CTRL-STK-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, SUB1-ADD1, and P-OPENER, and opening up the definitions of SUB1, EQUAL, P-INS-STEP, PUSH, POP, FETCH, FETCH-ADP, ADD1-P-PC, ADD1-ADDR, P-FETCH-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, DEFINIENS, UNTAG, P-OBJECTP, TOP, P-FETCH-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, P-STEP, P-HALT, X-Y-ERROR-MSG, LOCAL-VAR-VALUE, BINDINGS, ASSOC, CDR, P-PUSH-LOCAL-STEP, LESSP, LENGTH, P-PUSH-LOCAL-OKP, and REMAINDER, to the following two new conjectures: Case 3.3.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (NOT (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 3)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-PUSH-LOCAL-INSTRUCTION) 9) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, using linear arithmetic, to: T. Case 3.3.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 4)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS B I)) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 9) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, rewriting with P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-CTRL-STK-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, BIGNP-IMPLIES-P-OBJECTP-GET, and P-OPENER, and opening up P-INS-STEP, PUSH, POP, FETCH, FETCH-ADP, ADD1-P-PC, ADD1-ADDR, P-FETCH-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, DEFINIENS, UNTAG, P-OBJECTP, TOP, P-FETCH-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, P-STEP, P-HALT, X-Y-ERROR-MSG, BOOL, TAG, FIX-SMALL-NATURAL, REMAINDER, BOOL-TO-NAT, P-ADD-NAT-WITH-CARRY-STEP, TOP2, TOP1, SMALL-NATURALP, and P-ADD-NAT-WITH-CARRY-OKP, to the following seven new conjectures: Case 3.3.1.7. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 4)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS B I)) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 9) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this again simplifies, using linear arithmetic, to: T. Case 3.3.1.6. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (NOT (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 5)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (GET I (CDR (ASSOC B DATA-SEGMENT))) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-ADD-NAT-WITH-CARRY-INSTRUCTION) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.3.1.5. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (NOT (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 5)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (GET I (CDR (ASSOC B DATA-SEGMENT))) (CONS (GET I (CDR (ASSOC A DATA-SEGMENT))) (CONS (LIST 'BOOL C) TEMP-STK))) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-ADD-NAT-WITH-CARRY-INSTRUCTION) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.3.1.4. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (LESSP (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, rewriting with the lemmas BOOLEANP-NOT-F, PLUS-0, PLUS-ADD1-1, SUB1-ADD1, P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CAR-CONS, P-CTRL-STK-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, CDR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and expanding the definitions of TV->NAT, ZEROP, LESSP, P-INS-STEP, PUSH, LOCAL-VAR-VALUE, TOP, BINDINGS, ASSOC, DEFINIENS, CDR, ADD1-P-PC, ADD1-ADDR, P-PUSH-LOCAL-STEP, P-INS-OKP, CAR, LENGTH, P-PUSH-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, P-STEP, DEPOSIT, PUT-VALUE, DEPOSIT-ADP, TOP1, P-DEPOSIT-STEP, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, UNTAG, P-OBJECTP, POP, P-DEPOSIT-OKP, P-HALT, and X-Y-ERROR-MSG, to two new goals: Case 3.3.1.4.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (NOT (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 8)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-PUSH-LOCAL-INSTRUCTION) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.3.1.4.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying P-STEP1-OPENER, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, P-WORD-SIZE-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and opening up the definitions of P-HALT, X-Y-ERROR-MSG, P-INS-STEP, PUSH, POP, TAG, SUB1, ADD1-P-PC, ADD1-ADDR, P-SUB1-NAT-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, SMALL-NATURALP, NUMBERP, UNTAG, CDR, LISTP, P-OBJECTP, TOP, P-SUB1-NAT-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, and P-STEP, to the following two new formulas: Case 3.3.1.4.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (NOT (LESSP 1 (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-SUB1-NAT-INSTRUCTION) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this again simplifies, using linear arithmetic, to: T. Case 3.3.1.4.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (EQUAL (EXP 2 WORD-SIZE) 0)) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (SUB1 (EXP 2 WORD-SIZE))) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 10)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 0) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (ADD1 (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying the lemmas P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and opening up the functions P-INS-STEP, SET-LOCAL-VAR-VALUE, BINDINGS, PUT-ASSOC, PUT-VALUE, RET-PC, P-FRAME, POP, PUSH, CDR, TOP, ADD1-P-PC, ADD1-ADDR, P-SET-LOCAL-STEP, P-INS-OKP, CAR, P-SET-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, P-STEP, P-TEST-AND-JUMP-STEP, PC, P-TEST-NAT-AND-JUMP-STEP, P-TEST-AND-JUMP-OKP, P-OBJECTP, LISTP, LESSP, NUMBERP, SMALL-NATURALP, TYPE, P-OBJECTP-TYPE, P-TEST-NATP, UNTAG, P-TEST-NAT-AND-JUMP-OKP, P-RET-STEP, and P-RET-OKP, to: T. Case 3.3.1.3. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (EQUAL C 'F)) (NOT (LESSP (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (REMAINDER (PLUS 1 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying BOOLEANP-NOT-F, PLUS-0, PLUS-ADD1-1, and SUB1-ADD1, and expanding TV->NAT, ZEROP, and LESSP, to: T. Case 3.3.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (EQUAL C 'F) (LESSP (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this again simplifies, rewriting with PLUS-0, P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CAR-CONS, P-CTRL-STK-P-STATE, SUB1-ADD1, P-MAX-TEMP-STK-SIZE-P-STATE, CDR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and expanding the definitions of BOOLEANP, EQUAL, TV->NAT, ZEROP, P-INS-STEP, PUSH, LOCAL-VAR-VALUE, TOP, BINDINGS, ASSOC, DEFINIENS, CDR, ADD1-P-PC, ADD1-ADDR, P-PUSH-LOCAL-STEP, P-INS-OKP, CAR, LESSP, LENGTH, P-PUSH-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, P-STEP, DEPOSIT, PUT-VALUE, DEPOSIT-ADP, TOP1, P-DEPOSIT-STEP, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, UNTAG, P-OBJECTP, POP, P-DEPOSIT-OKP, P-HALT, and X-Y-ERROR-MSG, to the following two new formulas: Case 3.3.1.2.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 8)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-PUSH-LOCAL-INSTRUCTION) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This again simplifies, using linear arithmetic, to: T. Case 3.3.1.2.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 4) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, rewriting with P-STEP1-OPENER, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, P-WORD-SIZE-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and unfolding the definitions of P-HALT, X-Y-ERROR-MSG, P-INS-STEP, PUSH, POP, TAG, SUB1, ADD1-P-PC, ADD1-ADDR, P-SUB1-NAT-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, SMALL-NATURALP, NUMBERP, UNTAG, CDR, LISTP, P-OBJECTP, TOP, P-SUB1-NAT-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, and P-STEP, to the following two new goals: Case 3.3.1.2.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (NOT (LESSP 1 (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 9)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 1) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-SUB1-NAT-INSTRUCTION) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this again simplifies, using linear arithmetic, to: T. Case 3.3.1.2.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 10)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS '(NAT 0) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 3) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, applying P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, CDR-CONS, P-CTRL-STK-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and opening up P-INS-STEP, SET-LOCAL-VAR-VALUE, BINDINGS, PUT-ASSOC, PUT-VALUE, RET-PC, P-FRAME, POP, PUSH, CDR, TOP, ADD1-P-PC, ADD1-ADDR, P-SET-LOCAL-STEP, P-INS-OKP, CAR, P-SET-LOCAL-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, P-STEP, P-TEST-AND-JUMP-STEP, PC, P-TEST-NAT-AND-JUMP-STEP, P-HALT, X-Y-ERROR-MSG, P-TEST-AND-JUMP-OKP, P-OBJECTP, LISTP, LESSP, NUMBERP, SMALL-NATURALP, TYPE, P-OBJECTP-TYPE, P-TEST-NATP, UNTAG, and P-TEST-NAT-AND-JUMP-OKP, to the following two new conjectures: Case 3.3.1.2.1.1.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE)) (NOT (EQUAL (EXP 2 WORD-SIZE) 0))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 21)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 0)))) RET-PC) CTRL-STK) (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 1) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This finally simplifies, applying P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-DATA-SEGMENT-P-STATE, P-TEMP-STK-P-STATE, CAR-CONS, CDR-CONS, P-CTRL-STK-P-STATE, P-PC-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, and P-OPENER, and expanding P-INS-STEP, RET-PC, TOP, POP, P-RET-STEP, P-INS-OKP, CAR, P-RET-OKP, CONS, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, EQUAL, and P-STEP, to: T. Case 3.3.1.2.1.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (LENGTH TEMP-STK) (SUB1 MAX-TEMP-STK-SIZE)) (LESSP 1 (EXP 2 WORD-SIZE)) (EQUAL (EXP 2 WORD-SIZE) 0)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 11)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 0)))) RET-PC) CTRL-STK) (CONS '(NAT 0) (CONS '(BOOL F) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'ILLEGAL-TEST-NAT-AND-JUMP-INSTRUCTION) 1) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). This finally simplifies, using linear arithmetic, to: T. Case 3.3.1.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1) (LESSP (LENGTH TEMP-STK) (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (NOT (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) (LESSP (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (LESSP (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (EQUAL C 'F) (NOT (LESSP (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 6)) (CONS (LIST (CONS (LIST 'A 'ADDR (CONS A I)) (CONS (LIST 'B 'ADDR (CONS B I)) '((N NAT 1)))) RET-PC) CTRL-STK) (CONS (LIST 'NAT (REMAINDER (PLUS 0 (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) (CONS '(BOOL T) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 7) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 3.2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 19) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: (IMPLIES (AND (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 19) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). But this again simplifies, using linear arithmetic, to: T. Case 3.1. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (LESSP (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 0) (P-STATE RET-PC CTRL-STK (CONS '(BOOL F) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (TV->NAT (EQUAL C 'T)) (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))))) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 2. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0)) (NUMBERP (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) (IMPLIES (AND (LESSP (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (ZEROP WORD-SIZE)) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (LESSP MAX-TEMP-STK-SIZE (ADD1 (ADD1 (ADD1 (LENGTH TEMP-STK)))))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP A DATA-SEGMENT) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP (ADD1 I)) (LESSP (ADD1 I) N) (EQUAL N (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (EQUAL N (LENGTH (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (BOOLEANP (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A (ADD1 I))) (LIST 'B 'ADDR (CONS B (ADD1 I))) (LIST 'N 'NAT (DIFFERENCE N (ADD1 I)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A (ADD1 I))) (CONS (LIST 'BOOL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T)) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (BIG-ADD-LOOP-CLOCK (DIFFERENCE N (ADD1 I)))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (DIFFERENCE N (ADD1 I)) (EQUAL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T) 'T) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP (ADD1 I) (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (DIFFERENCE N (ADD1 I)) (EQUAL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T) 'T) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (LESSP MAX-TEMP-STK-SIZE (ADD1 (ADD1 (ADD1 (LENGTH TEMP-STK)))))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I N) (EQUAL N (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL N (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE N I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (BIG-ADD-LOOP-CLOCK (DIFFERENCE N I))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE N I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE N I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which simplifies, using linear arithmetic, applying COMMUTATIVITY-OF-PLUS, COMMUTATIVITY2-OF-PLUS, ASSOC-PUT-ASSOC-2, CDR-CONS, LENGTH-PUT, LESSP-REMAINDER-LINEAR, BIGNP-PUT, ASSOC-PUT-ASSOC-2-NEW, SUB1-ADD1, EQUAL-LENGTH-0, DIFFERENCE-ADD1-NEW, P-PC-P-STATE, PLUS-ADD1-1, PLUS-0, DIFFERENCE-EQUAL-1, P-STEP1-OPENER, P-WORD-SIZE-P-STATE, P-MAX-TEMP-STK-SIZE-P-STATE, P-MAX-CTRL-STK-SIZE-P-STATE, P-CTRL-STK-P-STATE, P-DATA-SEGMENT-P-STATE, CAR-CONS, P-TEMP-STK-P-STATE, P-PROG-SEGMENT-P-STATE, P-PSW-P-STATE, P-OPENER, BIG-ADD-ARRAY-LOOP-ON-LIST-OF-LENGTH-1, and BOOLEANP-NOT-F, and unfolding the functions BOOL-TO-NAT, ZEROP, NOT, LESSP, EQUAL, AND, UNPACK, IMPLIES, BIG-ADD-LOOP-CLOCK, LENGTH, BIGNP, CONS, P-INS-STEP, PUSH, POP, FETCH, FETCH-ADP, ADD1-P-PC, ADD1-ADDR, P-FETCH-STEP, P-INS-OKP, CAR, P-OBJECTP-TYPE, TYPE, ADPP, ADP-OFFSET, ADP-NAME, DEFINIENS, UNTAG, P-OBJECTP, TOP, P-FETCH-OKP, P-CURRENT-INSTRUCTION, OFFSET, DEFINITION, AREA-NAME, P-CURRENT-PROGRAM, PROGRAM-BODY, GET, UNLABEL, P-STEP, P-HALT, X-Y-ERROR-MSG, LOCAL-VAR-VALUE, BINDINGS, ASSOC, CDR, P-PUSH-LOCAL-STEP, P-PUSH-LOCAL-OKP, BOOL, SUB1, BIG-ADD-CARRY-OUT-LOOP, TAG, and BOOLEANP, to the following 31 new goals: Case 2.31. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0)) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (IMPLIES (AND (LESSP (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (ZEROP WORD-SIZE)) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (LESSP MAX-TEMP-STK-SIZE (ADD1 (ADD1 (ADD1 (LENGTH TEMP-STK)))))) (EQUAL '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET))) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP A DATA-SEGMENT) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP (ADD1 I)) (LESSP (ADD1 I) (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (BOOLEANP (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A (ADD1 I))) (LIST 'B 'ADDR (CONS B (ADD1 I))) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A (ADD1 I))) (CONS (LIST 'BOOL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T)) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (BIG-ADD-LOOP-CLOCK (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)) (EQUAL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T) 'T) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP (ADD1 I) (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)) (EQUAL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T) 'T) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1)) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) 11) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))). However this again simplifies, using linear arithmetic, to: T. Case 2.30. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0)) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (IMPLIES (AND (LESSP (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (ZEROP WORD-SIZE)) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (LESSP MAX-TEMP-STK-SIZE (ADD1 (ADD1 (ADD1 (LENGTH TEMP-STK)))))) (EQUAL '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET))) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP A DATA-SEGMENT) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP (ADD1 I)) (LESSP (ADD1 I) (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (BOOLEANP (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A (ADD1 I))) (LIST 'B 'ADDR (CONS B (ADD1 I))) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A (ADD1 I))) (CONS (LIST 'BOOL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T)) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (BIG-ADD-LOOP-CLOCK (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)) (EQUAL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T) 'T) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP (ADD1 I) (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)) (EQUAL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T) 'T) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (EQUAL WORD-SIZE 0)) (NUMBERP WORD-SIZE) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B DATA-SEGMENT)) (EXP 2 WORD-SIZE)) (NOT (EQUAL MAX-TEMP-STK-SIZE 0)) (NUMBERP MAX-TEMP-STK-SIZE) (NOT (EQUAL (SUB1 MAX-TEMP-STK-SIZE) 0)) (NOT (EQUAL (SUB1 (SUB1 MAX-TEMP-STK-SIZE)) 0)) (NOT (LESSP (SUB1 (SUB1 (SUB1 MAX-TEMP-STK-SIZE))) (LENGTH TEMP-STK))) (EQUAL (ASSOC 'BIG-ADD PROG-SEGMENT) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP I) (LESSP I (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B DATA-SEGMENT)))) (BOOLEANP C) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 0)) (NOT (EQUAL (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) 1))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A I)) (LIST 'B 'ADDR (CONS B I)) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A I)) (CONS (LIST 'BOOL C) TEMP-STK)) PROG-SEGMENT DATA-SEGMENT MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (ADD1 (BIG-ADD-LOOP-CLOCK (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I))))))))))))))))))))))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) TEMP-STK) PROG-SEGMENT (PUT-ASSOC (BIG-ADD-ARRAY-LOOP I (CDR (ASSOC A DATA-SEGMENT)) (CDR (ASSOC B DATA-SEGMENT)) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (EQUAL C 'T) (EXP 2 WORD-SIZE)) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN))), which again simplifies, using linear arithmetic, to: T. Case 2.29. (IMPLIES (AND (DEFINEDP A DATA-SEGMENT) (NOT (EQUAL (SUB1 (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I)) 0)) (LESSP (LENGTH (CDR (ASSOC A DATA-SEGMENT))) I) (IMPLIES (AND (LESSP (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT)))) (EXP 2 WORD-SIZE)) (NOT (ZEROP WORD-SIZE)) (LISTP CTRL-STK) (BIGNP (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (BIGNP (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (EXP 2 WORD-SIZE)) (NOT (LESSP MAX-TEMP-STK-SIZE (ADD1 (ADD1 (ADD1 (LENGTH TEMP-STK)))))) (EQUAL '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET))) '(BIG-ADD (A B N) NIL (PUSH-CONSTANT (BOOL F)) (PUSH-LOCAL A) (DL LOOP NIL (FETCH)) (PUSH-LOCAL B) (FETCH) (ADD-NAT-WITH-CARRY) (PUSH-LOCAL A) (DEPOSIT) (PUSH-LOCAL N) (SUB1-NAT) (SET-LOCAL N) (TEST-NAT-AND-JUMP ZERO DONE) (PUSH-LOCAL B) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (POP-LOCAL B) (PUSH-LOCAL A) (PUSH-CONSTANT (NAT 1)) (ADD-ADDR) (SET-LOCAL A) (JUMP LOOP) (DL DONE NIL (RET)))) (DEFINEDP A DATA-SEGMENT) (DEFINEDP B DATA-SEGMENT) (NOT (EQUAL A B)) (NUMBERP (ADD1 I)) (LESSP (ADD1 I) (LENGTH (CDR (ASSOC A DATA-SEGMENT)))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (EQUAL (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (LENGTH (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))))) (BOOLEANP (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T))) (EQUAL (P (P-STATE '(PC (BIG-ADD . 2)) (CONS (LIST (LIST (LIST 'A 'ADDR (CONS A (ADD1 I))) (LIST 'B 'ADDR (CONS B (ADD1 I))) (LIST 'N 'NAT (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)))) RET-PC) CTRL-STK) (CONS (LIST 'ADDR (CONS A (ADD1 I))) (CONS (LIST 'BOOL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE)) 'F 'T)) TEMP-STK)) PROG-SEGMENT (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT) MAX-CTRL-STK-SIZE MAX-TEMP-STK-SIZE WORD-SIZE 'RUN) (BIG-ADD-LOOP-CLOCK (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)))) (P-STATE RET-PC CTRL-STK (CONS (BIG-ADD-CARRY-OUT-LOOP (ADD1 I) (CDR (ASSOC A (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (CDR (ASSOC B (PUT-ASSOC (PUT (LIST 'NAT (REMAINDER (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT)))) (BOOL-TO-NAT C)) (EXP 2 WORD-SIZE))) I (CDR (ASSOC A DATA-SEGMENT))) A DATA-SEGMENT))) (DIFFERENCE (LENGTH (CDR (ASSOC A DATA-SEGMENT))) (ADD1 I)) (EQUAL (IF (LESSP (PLUS (CADR (GET I (CDR (ASSOC A DATA-SEGMENT)))) (CADR (GET I (CDR (ASSOC B DATA-SEGMENT))