(BOOT-STRAP NQTHM)

[ 0.0 0.1 0.0 ]

GROUND-ZERO


(COMPILE-UNCOMPILED-DEFNS "tmp")
Loading tmp.o
Finished loading tmp.o

/v/hank/v28/boyer/nqthm-2nd/nqthm-1992/examples/basic/tmp.lisp


(DEFN FROM-TO
      (I J)
      (IF (LESSP J I)
          NIL
          (IF (EQUAL (FIX I) (FIX J))
              (LIST (FIX J))
              (APPEND (FROM-TO I (SUB1 J))
                      (LIST J)))))

     Linear arithmetic, the lemmas COUNT-NUMBERP, SUB1-NNUMBERP, and
COUNT-NOT-LESSP, and the definitions of LESSP, EQUAL, COUNT, and FIX establish
that the measure (COUNT J) decreases according to the well-founded relation
LESSP in each recursive call.  Hence, FROM-TO is accepted under the
definitional principle.  Note that:
      (OR (LITATOM (FROM-TO I J))
          (LISTP (FROM-TO I J)))
is a theorem.




[ 0.0 0.0 0.0 ]

FROM-TO


(PROVE-LEMMA PLUS-RIGHT-ID2
             (REWRITE)
             (IMPLIES (NOT (NUMBERP Y))
                      (EQUAL (PLUS X Y) (FIX X))))

This simplifies, unfolding the definition of FIX, to the following two new
goals:

Case 2. (IMPLIES (AND (NOT (NUMBERP Y))
                      (NOT (NUMBERP X)))
                 (EQUAL (PLUS X Y) 0)).

  This again simplifies, opening up the definitions of PLUS and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (NUMBERP Y)) (NUMBERP X))
                 (EQUAL (PLUS X Y) X)),

  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 X) (p X Y))
           (IMPLIES (AND (NOT (ZEROP X)) (p (SUB1 X) Y))
                    (p X Y))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definition
of ZEROP establish 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 two new formulas:

Case 2. (IMPLIES (AND (ZEROP X)
                      (NOT (NUMBERP Y))
                      (NUMBERP X))
                 (EQUAL (PLUS X Y) X)).

  This simplifies, expanding the functions ZEROP, NUMBERP, EQUAL, and PLUS, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (EQUAL (PLUS (SUB1 X) Y) (SUB1 X))
                      (NOT (NUMBERP Y))
                      (NUMBERP X))
                 (EQUAL (PLUS X Y) X)).

  This simplifies, using linear arithmetic, to the new conjecture:

        (IMPLIES (AND (EQUAL X 0)
                      (NOT (ZEROP X))
                      (EQUAL (PLUS (SUB1 X) Y) (SUB1 X))
                      (NOT (NUMBERP Y))
                      (NUMBERP X))
                 (EQUAL (PLUS X Y) X)),

  which again simplifies, expanding the function ZEROP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

PLUS-RIGHT-ID2


(PROVE-LEMMA PLUS-ADD1
             (REWRITE)
             (EQUAL (PLUS X (ADD1 Y))
                    (IF (NUMBERP Y)
                        (ADD1 (PLUS X Y))
                        (ADD1 X))))

This simplifies, obviously, to two new formulas:

Case 2. (IMPLIES (NOT (NUMBERP Y))
                 (EQUAL (PLUS X (ADD1 Y)) (ADD1 X))),

  which again simplifies, rewriting with the lemma SUB1-TYPE-RESTRICTION, to
  the conjecture:

        (IMPLIES (NOT (NUMBERP Y))
                 (EQUAL (PLUS X 1) (ADD1 X))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (NUMBERP Y)
                 (EQUAL (PLUS X (ADD1 Y))
                        (ADD1 (PLUS X Y)))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PLUS-ADD1


(PROVE-LEMMA COMMUTATIVITY2-OF-PLUS
             (REWRITE)
             (EQUAL (PLUS X (PLUS Y Z))
                    (PLUS Y (PLUS X Z))))

This simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUTATIVITY2-OF-PLUS


(PROVE-LEMMA COMMUTATIVITY-OF-PLUS
             (REWRITE)
             (EQUAL (PLUS X Y) (PLUS Y X)))

WARNING:  the newly proposed lemma, COMMUTATIVITY-OF-PLUS, could be applied
whenever the previously added lemma COMMUTATIVITY2-OF-PLUS could.




WARNING:  the newly proposed lemma, COMMUTATIVITY-OF-PLUS, could be applied
whenever the previously added lemma PLUS-ADD1 could.




WARNING:  the newly proposed lemma, COMMUTATIVITY-OF-PLUS, could be applied
whenever the previously added lemma PLUS-RIGHT-ID2 could.




This formula simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUTATIVITY-OF-PLUS


(PROVE-LEMMA ASSOCIATIVITY-OF-PLUS
             (REWRITE)
             (EQUAL (PLUS (PLUS X Y) Z)
                    (PLUS X (PLUS Y Z))))

WARNING:  the previously added lemma, COMMUTATIVITY-OF-PLUS, could be applied
whenever the newly proposed ASSOCIATIVITY-OF-PLUS could!


This simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ASSOCIATIVITY-OF-PLUS


(PROVE-LEMMA PLUS-EQUAL-0
             (REWRITE)
             (EQUAL (EQUAL (PLUS A B) 0)
                    (AND (ZEROP A) (ZEROP B))))

This simplifies, opening up the functions ZEROP and AND, to six new
conjectures:

Case 6. (IMPLIES (AND (NOT (EQUAL (PLUS A B) 0))
                      (NOT (NUMBERP A)))
                 (NOT (EQUAL B 0))),

  which again simplifies, applying PLUS-RIGHT-ID2 and COMMUTATIVITY-OF-PLUS,
  and unfolding the functions NUMBERP and EQUAL, to:

        T.

Case 5. (IMPLIES (AND (NOT (EQUAL (PLUS A B) 0))
                      (NOT (NUMBERP A)))
                 (NUMBERP B)).

  However this again simplifies, applying PLUS-RIGHT-ID2, and unfolding the
  function EQUAL, to:

        T.

Case 4. (IMPLIES (AND (NOT (EQUAL (PLUS A B) 0))
                      (EQUAL A 0))
                 (NOT (EQUAL B 0))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES (AND (NOT (EQUAL (PLUS A B) 0))
                      (EQUAL A 0))
                 (NUMBERP B)),

  which again simplifies, applying the lemma PLUS-RIGHT-ID2, and opening up
  the definitions of NUMBERP and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (EQUAL (PLUS A B) 0)
                      (NOT (EQUAL A 0)))
                 (NOT (NUMBERP A))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (PLUS A B) 0)
                      (NOT (EQUAL B 0)))
                 (NOT (NUMBERP B))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PLUS-EQUAL-0


(PROVE-LEMMA DIFFERENCE-X-X
             (REWRITE)
             (EQUAL (DIFFERENCE X X) 0))

This conjecture simplifies, using linear arithmetic, to:

      (IMPLIES (LESSP X X)
               (EQUAL (DIFFERENCE X X) 0)).

But this again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-X-X


(PROVE-LEMMA DIFFERENCE-PLUS
             (REWRITE)
             (AND (EQUAL (DIFFERENCE (PLUS X Y) X)
                         (FIX Y))
                  (EQUAL (DIFFERENCE (PLUS Y X) X)
                         (FIX Y))))

WARNING:  Note that the proposed lemma DIFFERENCE-PLUS is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and two replacement rules.


This formula can be simplified, using the abbreviation AND, to the following
two new conjectures:

Case 2. (EQUAL (DIFFERENCE (PLUS X Y) X)
               (FIX Y)).

  This simplifies, unfolding the function FIX, to the following two new
  formulas:

  Case 2.2.
          (IMPLIES (NOT (NUMBERP Y))
                   (EQUAL (DIFFERENCE (PLUS X Y) X) 0)).

    However this again simplifies, applying PLUS-RIGHT-ID2, to the following
    two new goals:

    Case 2.2.2.
            (IMPLIES (AND (NOT (NUMBERP Y))
                          (NOT (NUMBERP X)))
                     (EQUAL (DIFFERENCE 0 X) 0)).

      But this again simplifies, expanding EQUAL and DIFFERENCE, to:

            T.

    Case 2.2.1.
            (IMPLIES (AND (NOT (NUMBERP Y)) (NUMBERP X))
                     (EQUAL (DIFFERENCE X X) 0)),

      which again simplifies, using linear arithmetic, to:

            (IMPLIES (AND (LESSP X X)
                          (NOT (NUMBERP Y))
                          (NUMBERP X))
                     (EQUAL (DIFFERENCE X X) 0)).

      However this again simplifies, using linear arithmetic, to:

            T.

  Case 2.1.
          (IMPLIES (NUMBERP Y)
                   (EQUAL (DIFFERENCE (PLUS X Y) X) Y)),

    which again simplifies, using linear arithmetic, to the conjecture:

          (IMPLIES (AND (LESSP (PLUS X Y) X) (NUMBERP Y))
                   (EQUAL (DIFFERENCE (PLUS X Y) X) Y)).

    This again simplifies, using linear arithmetic, to:

          T.

Case 1. (EQUAL (DIFFERENCE (PLUS Y X) X)
               (FIX Y)),

  which simplifies, applying the lemma COMMUTATIVITY-OF-PLUS, and unfolding
  FIX, to two new conjectures:

  Case 1.2.
          (IMPLIES (NOT (NUMBERP Y))
                   (EQUAL (DIFFERENCE (PLUS X Y) X) 0)),

    which again simplifies, rewriting with the lemma PLUS-RIGHT-ID2, to two
    new formulas:

    Case 1.2.2.
            (IMPLIES (AND (NOT (NUMBERP Y))
                          (NOT (NUMBERP X)))
                     (EQUAL (DIFFERENCE 0 X) 0)),

      which again simplifies, expanding the definitions of EQUAL and
      DIFFERENCE, to:

            T.

    Case 1.2.1.
            (IMPLIES (AND (NOT (NUMBERP Y)) (NUMBERP X))
                     (EQUAL (DIFFERENCE X X) 0)),

      which again simplifies, using linear arithmetic, to:

            (IMPLIES (AND (LESSP X X)
                          (NOT (NUMBERP Y))
                          (NUMBERP X))
                     (EQUAL (DIFFERENCE X X) 0)).

      However this again simplifies, using linear arithmetic, to:

            T.

  Case 1.1.
          (IMPLIES (NUMBERP Y)
                   (EQUAL (DIFFERENCE (PLUS X Y) X) Y)),

    which again simplifies, using linear arithmetic, to the formula:

          (IMPLIES (AND (LESSP (PLUS X Y) X) (NUMBERP Y))
                   (EQUAL (DIFFERENCE (PLUS X Y) X) Y)).

    This again simplifies, using linear arithmetic, to:

          T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS


(PROVE-LEMMA PLUS-CANCELLATION
             (REWRITE)
             (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                    (EQUAL (FIX B) (FIX C))))

This conjecture simplifies, expanding the definition of FIX, to the following
seven new formulas:

Case 7. (IMPLIES (AND (NUMBERP C)
                      (NUMBERP B)
                      (NOT (EQUAL B C)))
                 (NOT (EQUAL (PLUS A B) (PLUS A C)))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 6. (IMPLIES (AND (NUMBERP C)
                      (NOT (NUMBERP B))
                      (NOT (EQUAL 0 C)))
                 (NOT (EQUAL (PLUS A B) (PLUS A C)))),

  which again simplifies, rewriting with PLUS-RIGHT-ID2, to the following two
  new conjectures:

  Case 6.2.
          (IMPLIES (AND (NUMBERP C)
                        (NOT (NUMBERP B))
                        (NOT (EQUAL 0 C))
                        (NOT (NUMBERP A)))
                   (NOT (EQUAL 0 (PLUS A C)))).

    This again simplifies, using linear arithmetic, to:

          T.

  Case 6.1.
          (IMPLIES (AND (NUMBERP C)
                        (NOT (NUMBERP B))
                        (NOT (EQUAL 0 C))
                        (NUMBERP A))
                   (NOT (EQUAL A (PLUS A C)))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 5. (IMPLIES (AND (NOT (NUMBERP C))
                      (NUMBERP B)
                      (NOT (EQUAL B 0)))
                 (NOT (EQUAL (PLUS A B) (PLUS A C)))),

  which again simplifies, rewriting with PLUS-RIGHT-ID2, to the following two
  new goals:

  Case 5.2.
          (IMPLIES (AND (NOT (NUMBERP C))
                        (NUMBERP B)
                        (NOT (EQUAL B 0))
                        (NOT (NUMBERP A)))
                   (NOT (EQUAL (PLUS A B) 0))).

    This again simplifies, using linear arithmetic, to:

          T.

  Case 5.1.
          (IMPLIES (AND (NOT (NUMBERP C))
                        (NUMBERP B)
                        (NOT (EQUAL B 0))
                        (NUMBERP A))
                   (NOT (EQUAL (PLUS A B) A))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 4. (IMPLIES (AND (NOT (NUMBERP C))
                      (NOT (NUMBERP B)))
                 (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                        T)),

  which again simplifies, rewriting with the lemma PLUS-RIGHT-ID2, and opening
  up EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NUMBERP C)) (EQUAL B 0))
                 (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                        T)),

  which again simplifies, rewriting with COMMUTATIVITY-OF-PLUS and
  PLUS-RIGHT-ID2, and expanding the functions EQUAL and PLUS, to:

        T.

Case 2. (IMPLIES (AND (NOT (NUMBERP B)) (EQUAL 0 C))
                 (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                        T)).

  This again simplifies, applying PLUS-RIGHT-ID2 and COMMUTATIVITY-OF-PLUS,
  and opening up EQUAL and PLUS, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP C)
                      (NUMBERP B)
                      (EQUAL B C))
                 (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                        T)).

  But this again simplifies, expanding the function EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PLUS-CANCELLATION


(PROVE-LEMMA DIFFERENCE-0
             (REWRITE)
             (IMPLIES (NOT (LESSP Y X))
                      (EQUAL (DIFFERENCE X Y) 0)))


     Name the conjecture *1.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest four 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 X Y))
           (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                         (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                    (p X Y))
           (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                         (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                         (p (SUB1 X) (SUB1 Y)))
                    (p X Y))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT can be used to show that the measure (COUNT Y) 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 four new goals:

Case 4. (IMPLIES (AND (OR (EQUAL X 0) (NOT (NUMBERP X)))
                      (NOT (LESSP Y X)))
                 (EQUAL (DIFFERENCE X Y) 0)).

  This simplifies, expanding the definitions of NOT, OR, EQUAL, LESSP, and
  DIFFERENCE, to:

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                      (OR (EQUAL Y 0) (NOT (NUMBERP Y)))
                      (NOT (LESSP Y X)))
                 (EQUAL (DIFFERENCE X Y) 0)).

  This simplifies, unfolding NOT, OR, EQUAL, and LESSP, to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                      (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                      (LESSP (SUB1 Y) (SUB1 X))
                      (NOT (LESSP Y X)))
                 (EQUAL (DIFFERENCE X Y) 0)).

  This simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP X 1)
                      (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                      (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                      (LESSP (SUB1 Y) (SUB1 X))
                      (NOT (LESSP Y X)))
                 (EQUAL (DIFFERENCE X Y) 0)),

  which again simplifies, opening up the definitions of SUB1, NUMBERP, EQUAL,
  LESSP, NOT, and OR, to:

        T.

Case 1. (IMPLIES (AND (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                      (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                      (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                             0)
                      (NOT (LESSP Y X)))
                 (EQUAL (DIFFERENCE X Y) 0)),

  which simplifies, using linear arithmetic, to three new conjectures:

  Case 1.3.
          (IMPLIES (AND (LESSP X Y)
                        (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                        (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                        (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                               0)
                        (NOT (LESSP Y X)))
                   (EQUAL (DIFFERENCE X Y) 0)),

    which again simplifies, using linear arithmetic, to two new conjectures:

    Case 1.3.2.
            (IMPLIES (AND (LESSP (SUB1 X) (SUB1 Y))
                          (LESSP X Y)
                          (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                          (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                          (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                                 0)
                          (NOT (LESSP Y X)))
                     (EQUAL (DIFFERENCE X Y) 0)),

      which again simplifies, unfolding the functions LESSP, NOT, OR,
      DIFFERENCE, and EQUAL, to:

            T.

    Case 1.3.1.
            (IMPLIES (AND (LESSP X 1)
                          (LESSP X Y)
                          (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                          (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                          (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                                 0)
                          (NOT (LESSP Y X)))
                     (EQUAL (DIFFERENCE X Y) 0)),

      which again simplifies, unfolding SUB1, NUMBERP, EQUAL, LESSP, NOT, and
      OR, to:

            T.

  Case 1.2.
          (IMPLIES (AND (LESSP (SUB1 X) (SUB1 Y))
                        (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                        (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                        (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                               0)
                        (NOT (LESSP Y X)))
                   (EQUAL (DIFFERENCE X Y) 0)),

    which again simplifies, expanding the definitions of NOT, OR, LESSP,
    DIFFERENCE, and EQUAL, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LESSP X 1)
                        (NOT (OR (EQUAL X 0) (NOT (NUMBERP X))))
                        (NOT (OR (EQUAL Y 0) (NOT (NUMBERP Y))))
                        (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                               0)
                        (NOT (LESSP Y X)))
                   (EQUAL (DIFFERENCE X Y) 0)),

    which again simplifies, opening up the definitions of SUB1, NUMBERP, EQUAL,
    LESSP, NOT, and OR, to:

          T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-0


(PROVE-LEMMA EQUAL-DIFFERENCE-0
             (REWRITE)
             (EQUAL (EQUAL 0 (DIFFERENCE X Y))
                    (NOT (LESSP Y X))))

This conjecture simplifies, unfolding NOT, to two new conjectures:

Case 2. (IMPLIES (NOT (EQUAL 0 (DIFFERENCE X Y)))
                 (LESSP Y X)),

  which again simplifies, rewriting with the lemma DIFFERENCE-0, and opening
  up the definition of EQUAL, to:

        T.

Case 1. (IMPLIES (EQUAL 0 (DIFFERENCE X Y))
                 (NOT (LESSP Y X))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EQUAL-DIFFERENCE-0


(PROVE-LEMMA DIFFERENCE-CANCELLATION-0
             (REWRITE)
             (EQUAL (EQUAL X (DIFFERENCE X Y))
                    (AND (NUMBERP X)
                         (OR (EQUAL X 0) (ZEROP Y)))))

This simplifies, opening up the functions ZEROP, OR, and AND, to five new
goals:

Case 5. (IMPLIES (EQUAL X (DIFFERENCE X Y))
                 (NUMBERP X)),

  which again simplifies, obviously, to:

        T.

Case 4. (IMPLIES (AND (EQUAL X (DIFFERENCE X Y))
                      (NOT (EQUAL X 0))
                      (NOT (EQUAL Y 0)))
                 (NOT (NUMBERP Y))).

  But this again simplifies, using linear arithmetic, to the conjecture:

        (IMPLIES (AND (LESSP X Y)
                      (EQUAL X (DIFFERENCE X Y))
                      (NOT (EQUAL X 0))
                      (NOT (EQUAL Y 0)))
                 (NOT (NUMBERP Y))).

  This again simplifies, using linear arithmetic and applying DIFFERENCE-0, to:

        T.

Case 3. (IMPLIES (AND (NOT (EQUAL X (DIFFERENCE X Y)))
                      (NUMBERP X))
                 (NUMBERP Y)).

  But this again simplifies, expanding the definition of DIFFERENCE, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL X (DIFFERENCE X Y)))
                      (NUMBERP X))
                 (NOT (EQUAL Y 0))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP X 0)
                      (NOT (EQUAL X (DIFFERENCE X 0))))
                 (NOT (NUMBERP X))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL X (DIFFERENCE X Y)))
                      (NUMBERP X))
                 (NOT (EQUAL X 0))),

  which again simplifies, using linear arithmetic, applying the lemma
  DIFFERENCE-0, and expanding EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-CANCELLATION-0


(PROVE-LEMMA DIFFERENCE-CANCELLATION-1
             (REWRITE)
             (EQUAL (EQUAL (DIFFERENCE X Y)
                           (DIFFERENCE Z Y))
                    (IF (LESSP X Y)
                        (NOT (LESSP Y Z))
                        (IF (LESSP Z Y)
                            (NOT (LESSP Y X))
                            (EQUAL (FIX X) (FIX Z))))))

This simplifies, opening up NOT and FIX, to the following 11 new goals:

Case 11.(IMPLIES (AND (EQUAL (DIFFERENCE X Y)
                             (DIFFERENCE Z Y))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NOT (NUMBERP Z))
                      (NUMBERP X))
                 (EQUAL (EQUAL X 0) T)).

  This again simplifies, using linear arithmetic, applying DIFFERENCE-0 and
  EQUAL-DIFFERENCE-0, and expanding LESSP, to the following two new
  conjectures:

  Case 11.2.
          (IMPLIES (AND (NOT (LESSP Y X))
                        (NOT (LESSP X Y))
                        (EQUAL Y 0)
                        (NOT (NUMBERP Z))
                        (NUMBERP X))
                   (EQUAL X 0)).

    But this again simplifies, using linear arithmetic, to:

          T.

  Case 11.1.
          (IMPLIES (AND (NOT (LESSP Y X))
                        (NOT (LESSP X Y))
                        (NOT (NUMBERP Y))
                        (NOT (NUMBERP Z))
                        (NUMBERP X))
                   (EQUAL X 0)),

    which again simplifies, unfolding the definition of LESSP, to:

          T.

Case 10.(IMPLIES (AND (EQUAL (DIFFERENCE X Y)
                             (DIFFERENCE Z Y))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NUMBERP Z)
                      (NOT (NUMBERP X)))
                 (EQUAL (EQUAL 0 Z) T)),

  which again simplifies, using linear arithmetic, rewriting with DIFFERENCE-0
  and EQUAL-DIFFERENCE-0, and opening up the functions LESSP and EQUAL, to the
  following two new formulas:

  Case 10.2.
          (IMPLIES (AND (NOT (LESSP Y Z))
                        (EQUAL Y 0)
                        (NUMBERP Z)
                        (NOT (NUMBERP X)))
                   (EQUAL 0 Z)).

    But this again simplifies, using linear arithmetic, to:

          T.

  Case 10.1.
          (IMPLIES (AND (NOT (LESSP Y Z))
                        (NOT (NUMBERP Y))
                        (NUMBERP Z)
                        (NOT (NUMBERP X)))
                   (EQUAL 0 Z)),

    which again simplifies, expanding the function LESSP, to:

          T.

Case 9. (IMPLIES (AND (EQUAL (DIFFERENCE X Y)
                             (DIFFERENCE Z Y))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NUMBERP Z)
                      (NUMBERP X))
                 (EQUAL (EQUAL X Z) T)),

  which again simplifies, obviously, to the new formula:

        (IMPLIES (AND (EQUAL (DIFFERENCE X Y)
                             (DIFFERENCE Z Y))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NUMBERP Z)
                      (NUMBERP X))
                 (EQUAL X Z)),

  which again simplifies, using linear arithmetic, to:

        T.

Case 8. (IMPLIES (AND (NOT (EQUAL (DIFFERENCE X Y)
                                  (DIFFERENCE Z Y)))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NOT (NUMBERP Z)))
                 (NOT (EQUAL X 0))),

  which again simplifies, using linear arithmetic, appealing to the lemma
  DIFFERENCE-0, and unfolding the function EQUAL, to:

        T.

Case 7. (IMPLIES (AND (NOT (EQUAL (DIFFERENCE X Y)
                                  (DIFFERENCE Z Y)))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NOT (NUMBERP X)))
                 (NOT (EQUAL 0 Z))),

  which again simplifies, using linear arithmetic, applying DIFFERENCE-0, and
  unfolding the function EQUAL, to:

        T.

Case 6. (IMPLIES (AND (NOT (EQUAL (DIFFERENCE X Y)
                                  (DIFFERENCE Z Y)))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NUMBERP Z)
                      (NUMBERP X))
                 (NOT (EQUAL X Z))).

  This again simplifies, clearly, to:

        T.

Case 5. (IMPLIES (AND (NOT (EQUAL (DIFFERENCE X Y)
                                  (DIFFERENCE Z Y)))
                      (LESSP X Y))
                 (LESSP Y Z)).

  However this again simplifies, using linear arithmetic, applying
  DIFFERENCE-0, and expanding the function EQUAL, to:

        T.

Case 4. (IMPLIES (AND (NOT (EQUAL (DIFFERENCE X Y)
                                  (DIFFERENCE Z Y)))
                      (NOT (LESSP X Y))
                      (NOT (LESSP Z Y))
                      (NOT (NUMBERP Z)))
                 (NUMBERP X)).

  However this again simplifies, using linear arithmetic, applying
  DIFFERENCE-0, and unfolding the definition of EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (EQUAL (DIFFERENCE X Y)
                                  (DIFFERENCE Z Y)))
                      (NOT (LESSP X Y))
                      (LESSP Z Y))
                 (LESSP Y X)).

  But this again simplifies, using linear arithmetic, to three new goals:

  Case 3.3.
          (IMPLIES (AND (NOT (NUMBERP Y))
                        (NOT (EQUAL (DIFFERENCE X Y)
                                    (DIFFERENCE Z Y)))
                        (NOT (LESSP X Y))
                        (LESSP Z Y))
                   (LESSP Y X)),

    which again simplifies, appealing to the lemma DIFFERENCE-0, and expanding
    the definitions of DIFFERENCE and LESSP, to:

          T.

  Case 3.2.
          (IMPLIES (AND (NOT (NUMBERP X))
                        (NOT (EQUAL (DIFFERENCE X Y)
                                    (DIFFERENCE Z Y)))
                        (NOT (LESSP X Y))
                        (LESSP Z Y))
                   (LESSP Y X)),

    which again simplifies, using linear arithmetic, applying DIFFERENCE-0,
    and unfolding the function EQUAL, to:

          T.

  Case 3.1.
          (IMPLIES (AND (NUMBERP X)
                        (NUMBERP Y)
                        (NOT (EQUAL (DIFFERENCE X X)
                                    (DIFFERENCE Z X)))
                        (NOT (LESSP X X))
                        (LESSP Z X))
                   (LESSP X X)).

    However this again simplifies, using linear arithmetic, applying
    DIFFERENCE-0, and expanding the function EQUAL, to:

          T.

Case 2. (IMPLIES (AND (EQUAL (DIFFERENCE X Y)
                             (DIFFERENCE Z Y))
                      (LESSP X Y))
                 (NOT (LESSP Y Z))).

  However this again simplifies, using linear arithmetic and rewriting with
  the lemmas DIFFERENCE-0 and EQUAL-DIFFERENCE-0, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (DIFFERENCE X Y)
                             (DIFFERENCE Z Y))
                      (NOT (LESSP X Y))
                      (LESSP Z Y))
                 (NOT (LESSP Y X))),

  which again simplifies, using linear arithmetic and rewriting with
  DIFFERENCE-0 and EQUAL-DIFFERENCE-0, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-CANCELLATION-1


(DEFN DELETE
      (X Y)
      (IF (LISTP Y)
          (IF (EQUAL X (CAR Y))
              (CDR Y)
              (CONS (CAR Y) (DELETE X (CDR Y))))
          Y))

     Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT Y) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, DELETE is accepted under the principle of definition.




[ 0.0 0.0 0.0 ]

DELETE


(DEFN SUBBAGP
      (X Y)
      (IF (LISTP X)
          (IF (MEMBER (CAR X) Y)
              (SUBBAGP (CDR X) (DELETE (CAR X) Y))
              F)
          T))

     Linear arithmetic and the lemma CDR-LESSP establish that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, SUBBAGP is accepted under the principle of definition.
From the definition we can conclude that:
      (OR (FALSEP (SUBBAGP X Y))
          (TRUEP (SUBBAGP X Y)))
is a theorem.




[ 0.0 0.0 0.0 ]

SUBBAGP


(DEFN BAGDIFF
      (X Y)
      (IF (LISTP Y)
          (IF (MEMBER (CAR Y) X)
              (BAGDIFF (DELETE (CAR Y) X) (CDR Y))
              (BAGDIFF X (CDR Y)))
          X))

     Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT Y) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, BAGDIFF is accepted under the definitional principle.




[ 0.0 0.0 0.0 ]

BAGDIFF


(DEFN BAGINT
      (X Y)
      (IF (LISTP X)
          (IF (MEMBER (CAR X) Y)
              (CONS (CAR X)
                    (BAGINT (CDR X) (DELETE (CAR X) Y)))
              (BAGINT (CDR X) Y))
          NIL))

     Linear arithmetic and the lemma CDR-LESSP establish that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, BAGINT is accepted under the principle of definition.
Note that (OR (LITATOM (BAGINT X Y)) (LISTP (BAGINT X Y))) is a theorem.




[ 0.0 0.0 0.0 ]

BAGINT


(PROVE-LEMMA DELETE-NON-MEMBER
             (REWRITE)
             (IMPLIES (NOT (MEMBER X Y))
                      (EQUAL (DELETE X Y) Y)))


     Give the conjecture the name *1.


     We will try to 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 (NLISTP Y) (p X Y))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (EQUAL X (CAR Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (NOT (EQUAL X (CAR Y)))
                         (p X (CDR Y)))
                    (p X Y))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP inform us that the measure (COUNT Y) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates four new goals:

Case 4. (IMPLIES (AND (NLISTP Y) (NOT (MEMBER X Y)))
                 (EQUAL (DELETE X Y) Y)),

  which simplifies, expanding NLISTP, MEMBER, and DELETE, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Y))
                      (EQUAL X (CAR Y))
                      (NOT (MEMBER X Y)))
                 (EQUAL (DELETE X Y) Y)),

  which simplifies, opening up the functions NLISTP and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (MEMBER X (CDR Y))
                      (NOT (MEMBER X Y)))
                 (EQUAL (DELETE X Y) Y)),

  which simplifies, opening up the definitions of NLISTP and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (EQUAL (DELETE X (CDR Y)) (CDR Y))
                      (NOT (MEMBER X Y)))
                 (EQUAL (DELETE X Y) Y)),

  which simplifies, rewriting with the lemma CONS-CAR-CDR, and unfolding the
  functions NLISTP, MEMBER, and DELETE, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

DELETE-NON-MEMBER


(PROVE-LEMMA MEMBER-DELETE
             (REWRITE)
             (IMPLIES (MEMBER X (DELETE U V))
                      (MEMBER X V)))

WARNING:  Note that MEMBER-DELETE contains the free variable U which will be
chosen by instantiating the hypothesis (MEMBER X (DELETE U V)).



     Give the conjecture the name *1.


     Let us appeal to the induction principle.  Two 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 (AND (LISTP V) (EQUAL U (CAR V)))
                    (p X V U))
           (IMPLIES (AND (LISTP V)
                         (NOT (EQUAL U (CAR V)))
                         (p X (CDR V) U))
                    (p X V U))
           (IMPLIES (NOT (LISTP V)) (p X V U))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT V)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates four new conjectures:

Case 4. (IMPLIES (AND (LISTP V)
                      (EQUAL U (CAR V))
                      (MEMBER X (DELETE U V)))
                 (MEMBER X V)),

  which simplifies, expanding the functions DELETE and MEMBER, to:

        T.

Case 3. (IMPLIES (AND (LISTP V)
                      (NOT (EQUAL U (CAR V)))
                      (NOT (MEMBER X (DELETE U (CDR V))))
                      (MEMBER X (DELETE U V)))
                 (MEMBER X V)),

  which simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  expanding DELETE and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (LISTP V)
                      (NOT (EQUAL U (CAR V)))
                      (MEMBER X (CDR V))
                      (MEMBER X (DELETE U V)))
                 (MEMBER X V)),

  which simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS, and
  opening up the functions DELETE and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP V))
                      (MEMBER X (DELETE U V)))
                 (MEMBER X V)),

  which simplifies, applying DELETE-NON-MEMBER, and unfolding the definition
  of MEMBER, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

MEMBER-DELETE


(PROVE-LEMMA COMMUTATIVITY-OF-DELETE
             (REWRITE)
             (EQUAL (DELETE X (DELETE Y Z))
                    (DELETE Y (DELETE X Z))))


     Call the conjecture *1.


     Perhaps we can prove it by induction.  Two 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 (AND (LISTP Z) (EQUAL Y (CAR Z)))
                    (p X Y Z))
           (IMPLIES (AND (LISTP Z)
                         (NOT (EQUAL Y (CAR Z)))
                         (p X Y (CDR Z)))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP Z)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT Z) decreases according to the well-founded relation LESSP in
each induction step of the scheme.  The above induction scheme leads to three
new goals:

Case 3. (IMPLIES (AND (LISTP Z) (EQUAL Y (CAR Z)))
                 (EQUAL (DELETE X (DELETE Y Z))
                        (DELETE Y (DELETE X Z)))),

  which simplifies, opening up the definition of DELETE, to two new
  conjectures:

  Case 3.2.
          (IMPLIES (AND (LISTP Z)
                        (NOT (EQUAL X (CAR Z))))
                   (EQUAL (DELETE X (CDR Z))
                          (DELETE (CAR Z)
                                  (CONS (CAR Z) (DELETE X (CDR Z)))))),

    which again simplifies, rewriting with CDR-CONS and CAR-CONS, and opening
    up the function DELETE, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Z) (EQUAL X (CAR Z)))
                   (EQUAL (DELETE X (CDR Z))
                          (DELETE (CAR Z) (CDR Z)))).

    This again simplifies, obviously, to:

          T.

Case 2. (IMPLIES (AND (LISTP Z)
                      (NOT (EQUAL Y (CAR Z)))
                      (EQUAL (DELETE X (DELETE Y (CDR Z)))
                             (DELETE Y (DELETE X (CDR Z)))))
                 (EQUAL (DELETE X (DELETE Y Z))
                        (DELETE Y (DELETE X Z)))).

  This simplifies, applying CDR-CONS and CAR-CONS, and opening up DELETE, to:

        (IMPLIES (AND (LISTP Z)
                      (NOT (EQUAL Y (CAR Z)))
                      (EQUAL (DELETE X (DELETE Y (CDR Z)))
                             (DELETE Y (DELETE X (CDR Z))))
                      (NOT (EQUAL X (CAR Z))))
                 (EQUAL (CONS (CAR Z)
                              (DELETE X (DELETE Y (CDR Z))))
                        (DELETE Y
                                (CONS (CAR Z) (DELETE X (CDR Z)))))).

  But this again simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
  and expanding the definition of DELETE, to:

        T.

Case 1. (IMPLIES (NOT (LISTP Z))
                 (EQUAL (DELETE X (DELETE Y Z))
                        (DELETE Y (DELETE X Z)))),

  which simplifies, applying DELETE-NON-MEMBER, and expanding the definition
  of MEMBER, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUTATIVITY-OF-DELETE


(PROVE-LEMMA SUBBAGP-DELETE
             (REWRITE)
             (IMPLIES (SUBBAGP X (DELETE U Y))
                      (SUBBAGP X Y)))

WARNING:  Note that SUBBAGP-DELETE contains the free variable U which will be
chosen by instantiating the hypothesis (SUBBAGP X (DELETE U Y)).



     Give the conjecture the name *1.


     Let us appeal to the induction principle.  Three inductions are suggested
by terms in the conjecture.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (MEMBER (CAR X) (DELETE U Y))
                         (p (CDR X) (DELETE (CAR X) Y) U))
                    (p X Y U))
           (IMPLIES (AND (LISTP X)
                         (NOT (MEMBER (CAR X) (DELETE U Y))))
                    (p X Y U))
           (IMPLIES (NOT (LISTP X)) (p X Y U))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instance chosen for Y.  The above
induction scheme generates four new conjectures:

Case 4. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) (DELETE U Y))
                      (NOT (SUBBAGP (CDR X)
                                    (DELETE U (DELETE (CAR X) Y))))
                      (SUBBAGP X (DELETE U Y)))
                 (SUBBAGP X Y)),

  which simplifies, applying COMMUTATIVITY-OF-DELETE, and opening up SUBBAGP,
  to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) (DELETE U Y))
                      (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                      (SUBBAGP X (DELETE U Y)))
                 (SUBBAGP X Y)).

  This simplifies, applying the lemmas COMMUTATIVITY-OF-DELETE and
  MEMBER-DELETE, and unfolding the function SUBBAGP, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) (DELETE U Y)))
                      (SUBBAGP X (DELETE U Y)))
                 (SUBBAGP X Y)).

  This simplifies, unfolding the function SUBBAGP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (SUBBAGP X (DELETE U Y)))
                 (SUBBAGP X Y)).

  This simplifies, unfolding the definition of SUBBAGP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBBAGP-DELETE


(PROVE-LEMMA SUBBAGP-CDR1
             (REWRITE)
             (IMPLIES (SUBBAGP X Y)
                      (SUBBAGP (CDR X) Y)))

.

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. (IMPLIES (AND (NOT (LISTP X)) (SUBBAGP X Y))
                 (SUBBAGP (CDR X) Y)).

  But this simplifies, applying CDR-NLISTP, and expanding SUBBAGP and LISTP,
  to:

        T.

Case 1. (IMPLIES (SUBBAGP (CONS V Z) Y)
                 (SUBBAGP Z Y)).

  However this simplifies, rewriting with CDR-CONS, CAR-CONS, and
  SUBBAGP-DELETE, and expanding the definition of SUBBAGP, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

SUBBAGP-CDR1


(PROVE-LEMMA SUBBAGP-CDR2
             (REWRITE)
             (IMPLIES (SUBBAGP X (CDR Y))
                      (SUBBAGP X Y)))

.

Applying the lemma CAR-CDR-ELIM, replace Y by (CONS V Z) to eliminate (CDR Y)
and (CAR Y).  We thus obtain the following two new goals:

Case 2. (IMPLIES (AND (NOT (LISTP Y))
                      (SUBBAGP X (CDR Y)))
                 (SUBBAGP X Y)).

  But this simplifies, applying CDR-NLISTP, and expanding MEMBER, LISTP, and
  SUBBAGP, to:

        T.

Case 1. (IMPLIES (SUBBAGP X Z)
                 (SUBBAGP X (CONS V Z))),

  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 (SUBBAGP X (CDR Y))
         (SUBBAGP X Y)),

which we named *1 above.  We will appeal to induction.  Two 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 (AND (LISTP X)
                         (MEMBER (CAR X) (CDR Y))
                         (p (CDR X) (DELETE (CAR X) Y)))
                    (p X Y))
           (IMPLIES (AND (LISTP X)
                         (NOT (MEMBER (CAR X) (CDR Y))))
                    (p X Y))
           (IMPLIES (NOT (LISTP X)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instance chosen for Y.  The above
induction scheme leads to the following four new conjectures:

Case 4. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) (CDR Y))
                      (NOT (SUBBAGP (CDR X)
                                    (CDR (DELETE (CAR X) Y))))
                      (SUBBAGP X (CDR Y)))
                 (SUBBAGP X Y)).

  This simplifies, unfolding SUBBAGP and MEMBER, to the following two new
  conjectures:

  Case 4.2.
          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) (CDR Y))
                        (NOT (SUBBAGP (CDR X)
                                      (CDR (DELETE (CAR X) Y))))
                        (SUBBAGP (CDR X)
                                 (DELETE (CAR X) (CDR Y))))
                   (LISTP Y)).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up LISTP
    and MEMBER, to:

          T.

  Case 4.1.
          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) (CDR Y))
                        (NOT (SUBBAGP (CDR X)
                                      (CDR (DELETE (CAR X) Y))))
                        (SUBBAGP (CDR X)
                                 (DELETE (CAR X) (CDR Y))))
                   (SUBBAGP (CDR X) (DELETE (CAR X) Y))).

    This further simplifies, rewriting with CDR-NLISTP, DELETE-NON-MEMBER, and
    SUBBAGP-CDR1, and unfolding the definitions of DELETE, MEMBER, LISTP, and
    SUBBAGP, to the new formula:

          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) (CDR Y))
                        (LISTP Y)
                        (NOT (EQUAL (CAR X) (CAR Y)))
                        (NOT (SUBBAGP (CDR X)
                                      (CDR (CONS (CAR Y)
                                                 (DELETE (CAR X) (CDR Y))))))
                        (SUBBAGP (CDR X)
                                 (DELETE (CAR X) (CDR Y))))
                   (SUBBAGP (CDR X)
                            (CONS (CAR Y)
                                  (DELETE (CAR X) (CDR Y))))),

    which again simplifies, rewriting with CDR-CONS, to:

          T.

Case 3. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) (CDR Y))
                      (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                      (SUBBAGP X (CDR Y)))
                 (SUBBAGP X Y)).

  This simplifies, unfolding the definitions of SUBBAGP and MEMBER, to:

        (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) (CDR Y))
                      (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                      (SUBBAGP (CDR X)
                               (DELETE (CAR X) (CDR Y))))
                 (LISTP Y)),

  which again simplifies, applying CDR-NLISTP, and opening up the functions
  LISTP and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) (CDR Y)))
                      (SUBBAGP X (CDR Y)))
                 (SUBBAGP X Y)).

  This simplifies, unfolding the definition of SUBBAGP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (SUBBAGP X (CDR Y)))
                 (SUBBAGP X Y)).

  This simplifies, unfolding the function SUBBAGP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.1 0.0 ]

SUBBAGP-CDR2


(PROVE-LEMMA SUBBAGP-BAGINT1
             (REWRITE)
             (SUBBAGP (BAGINT X Y) X))


     Give the conjecture the name *1.


     We will try to prove it by induction.  There is only one suggested
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (MEMBER (CAR X) Y)
                         (p (CDR X) (DELETE (CAR X) Y)))
                    (p X Y))
           (IMPLIES (AND (LISTP X)
                         (NOT (MEMBER (CAR X) Y))
                         (p (CDR X) Y))
                    (p X Y))
           (IMPLIES (NOT (LISTP X)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for Y.  The
above induction scheme leads to three new formulas:

Case 3. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) Y)
                      (SUBBAGP (BAGINT (CDR X) (DELETE (CAR X) Y))
                               (CDR X)))
                 (SUBBAGP (BAGINT X Y) X)),

  which simplifies, applying CDR-CONS and CAR-CONS, and opening up the
  definitions of BAGINT, DELETE, MEMBER, and SUBBAGP, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) Y))
                      (SUBBAGP (BAGINT (CDR X) Y) (CDR X)))
                 (SUBBAGP (BAGINT X Y) X)).

  This simplifies, applying SUBBAGP-CDR2, and unfolding BAGINT, to:

        T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (SUBBAGP (BAGINT X Y) X)),

  which simplifies, appealing to the lemmas CDR-NLISTP and SUBBAGP-CDR2, and
  unfolding BAGINT and SUBBAGP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBBAGP-BAGINT1


(PROVE-LEMMA SUBBAGP-BAGINT2
             (REWRITE)
             (SUBBAGP (BAGINT X Y) Y))


     Give the conjecture the name *1.


     We will try to prove it by induction.  There is only one suggested
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (MEMBER (CAR X) Y)
                         (p (CDR X) (DELETE (CAR X) Y)))
                    (p X Y))
           (IMPLIES (AND (LISTP X)
                         (NOT (MEMBER (CAR X) Y))
                         (p (CDR X) Y))
                    (p X Y))
           (IMPLIES (NOT (LISTP X)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for Y.  The
above induction scheme leads to three new formulas:

Case 3. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) Y)
                      (SUBBAGP (BAGINT (CDR X) (DELETE (CAR X) Y))
                               (DELETE (CAR X) Y)))
                 (SUBBAGP (BAGINT X Y) Y)),

  which simplifies, applying CDR-CONS and CAR-CONS, and opening up the
  definitions of BAGINT and SUBBAGP, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) Y))
                      (SUBBAGP (BAGINT (CDR X) Y) Y))
                 (SUBBAGP (BAGINT X Y) Y)).

  This simplifies, expanding BAGINT, to:

        T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (SUBBAGP (BAGINT X Y) Y)).

  This simplifies, applying SUBBAGP-CDR2, and opening up the functions BAGINT,
  SUBBAGP, and LISTP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBBAGP-BAGINT2


(DEFN PLUS-FRINGE
      (X)
      (IF (AND (LISTP X) (EQUAL (CAR X) 'PLUS))
          (APPEND (PLUS-FRINGE (CADR X))
                  (PLUS-FRINGE (CADDR X)))
          (CONS X NIL)))

     Linear arithmetic, the lemmas CAR-LESSEQP, CDR-LESSEQP, and CDR-LESSP,
and the definition of AND establish that the measure (COUNT X) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
PLUS-FRINGE is accepted under the principle of definition.  Note that
(LISTP (PLUS-FRINGE X)) is a theorem.




[ 0.0 0.0 0.0 ]

PLUS-FRINGE


(DEFN PLUS-TREE
      (L)
      (IF (NLISTP L)
          ''0
          (IF (NLISTP (CDR L))
              (LIST 'FIX (CAR L))
              (IF (NLISTP (CDDR L))
                  (LIST 'PLUS (CAR L) (CADR L))
                  (LIST 'PLUS
                        (CAR L)
                        (PLUS-TREE (CDR L)))))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP inform us that the measure (COUNT L) decreases according
to the well-founded relation LESSP in each recursive call.  Hence, PLUS-TREE
is accepted under the principle of definition.  Note that
(LISTP (PLUS-TREE L)) is a theorem.




[ 0.0 0.0 0.0 ]

PLUS-TREE


(DEFN CANCEL
      (X)
      (IF (AND (LISTP X)
               (EQUAL (CAR X) 'EQUAL))
          (IF (AND (LISTP (CADR X))
                   (EQUAL (CAADR X) 'PLUS)
                   (LISTP (CADDR X))
                   (EQUAL (CAADDR X) 'PLUS))
              (LIST 'EQUAL
                    (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADR X))
                                        (BAGINT (PLUS-FRINGE (CADR X))
                                                (PLUS-FRINGE (CADDR X)))))
                    (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADDR X))
                                        (BAGINT (PLUS-FRINGE (CADR X))
                                                (PLUS-FRINGE (CADDR X))))))
              (IF (AND (LISTP (CADR X))
                       (EQUAL (CAADR X) 'PLUS)
                       (MEMBER (CADDR X)
                               (PLUS-FRINGE (CADR X))))
                  (LIST 'IF
                        (LIST 'NUMBERP (CADDR X))
                        (LIST 'EQUAL
                              (PLUS-TREE (DELETE (CADDR X)
                                                 (PLUS-FRINGE (CADR X))))
                              ''0)
                        (LIST 'QUOTE F))
                  (IF (AND (LISTP (CADDR X))
                           (EQUAL (CAADDR X) 'PLUS)
                           (MEMBER (CADR X)
                                   (PLUS-FRINGE (CADDR X))))
                      (LIST 'IF
                            (LIST 'NUMBERP (CADR X))
                            (LIST 'EQUAL
                                  ''0
                                  (PLUS-TREE (DELETE (CADR X)
                                                     (PLUS-FRINGE (CADDR X)))))
                            (LIST 'QUOTE F))
                      X)))
          X))

     From the definition we can conclude that:
      (OR (LISTP (CANCEL X))
          (EQUAL (CANCEL X) X))
is a theorem.




[ 0.0 0.0 0.0 ]

CANCEL


(COMPILE-UNCOMPILED-DEFNS "tmp")
Loading tmp.o
Finished loading tmp.o

/v/hank/v28/boyer/nqthm-2nd/nqthm-1992/examples/basic/tmp.lisp


(PROVE-LEMMA NUMBERP-EVAL$-PLUS
             (REWRITE)
             (IMPLIES (AND (LISTP X) (EQUAL (CAR X) 'PLUS))
                      (NUMBERP (EVAL$ T X A))))

.

Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate (CAR X)
and (CDR X).  This produces:

      (IMPLIES (EQUAL Z 'PLUS)
               (NUMBERP (EVAL$ T (CONS Z V) A))),

which simplifies, applying REWRITE-EVAL$, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NUMBERP-EVAL$-PLUS


(PROVE-LEMMA NUMBERP-EVAL$-PLUS-TREE
             (REWRITE)
             (NUMBERP (EVAL$ T (PLUS-TREE L) A)))


     Call the conjecture *1.


     We will try to prove it by induction.  There is only one suggested
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP L) (p L A))
           (IMPLIES (AND (NOT (NLISTP L))
                         (NLISTP (CDR L)))
                    (p L A))
           (IMPLIES (AND (NOT (NLISTP L))
                         (NOT (NLISTP (CDR L)))
                         (NLISTP (CDDR L)))
                    (p L A))
           (IMPLIES (AND (NOT (NLISTP L))
                         (NOT (NLISTP (CDR L)))
                         (NOT (NLISTP (CDDR L)))
                         (p (CDR L) A))
                    (p L A))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP can be used to establish that the measure (COUNT L) decreases according
to the well-founded relation LESSP in each induction step of the scheme.  The
above induction scheme generates the following four new formulas:

Case 4. (IMPLIES (NLISTP L)
                 (NUMBERP (EVAL$ T (PLUS-TREE L) A))).

  This simplifies, expanding the definitions of NLISTP, PLUS-TREE, CDR, CAR,
  LISTP, LITATOM, EQUAL, EVAL$, and NUMBERP, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP L))
                      (NLISTP (CDR L)))
                 (NUMBERP (EVAL$ T (PLUS-TREE L) A))).

  This simplifies, appealing to the lemmas REWRITE-EVAL$ and CAR-CONS, and
  opening up NLISTP, PLUS-TREE, and FIX, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP L))
                      (NOT (NLISTP (CDR L)))
                      (NLISTP (CDDR L)))
                 (NUMBERP (EVAL$ T (PLUS-TREE L) A))).

  This simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and
  unfolding the definitions of NLISTP and PLUS-TREE, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP L))
                      (NOT (NLISTP (CDR L)))
                      (NOT (NLISTP (CDDR L)))
                      (NUMBERP (EVAL$ T (PLUS-TREE (CDR L)) A)))
                 (NUMBERP (EVAL$ T (PLUS-TREE L) A))),

  which simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and
  expanding the functions NLISTP and PLUS-TREE, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

NUMBERP-EVAL$-PLUS-TREE


(PROVE-LEMMA MEMBER-IMPLIES-PLUS-TREE-GREATEREQP
             (REWRITE)
             (IMPLIES (MEMBER X Y)
                      (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T X A)))))

WARNING:  When the linear lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP is stored
under (EVAL$ T (PLUS-TREE Y) A) it contains the free variable X which will be
chosen by instantiating the hypothesis (MEMBER X Y).


WARNING:  When the linear lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP is stored
under (EVAL$ T X A) it contains the free variable Y which will be chosen by
instantiating the hypothesis (MEMBER X Y).


WARNING:  Note that the proposed lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP is
to be stored as zero type prescription rules, zero compound recognizer rules,
two linear rules, and zero replacement rules.



     Give the conjecture the name *1.


     We will appeal to induction.  Three inductions are suggested by terms in
the conjecture.  They merge into two likely candidate inductions.  However,
only one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP Y) (p Y A X))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (EQUAL X (CAR Y)))
                    (p Y A X))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (NOT (EQUAL X (CAR Y)))
                         (p (CDR Y) A X))
                    (p Y A X))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP can be used to establish that the measure (COUNT Y) decreases according
to the well-founded relation LESSP in each induction step of the scheme.  The
above induction scheme leads to four new goals:

Case 4. (IMPLIES (AND (NLISTP Y) (MEMBER X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T X A)))),

  which simplifies, unfolding the functions NLISTP and MEMBER, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Y))
                      (EQUAL X (CAR Y))
                      (MEMBER X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T X A)))),

  which simplifies, opening up NLISTP, MEMBER, and PLUS-TREE, to three new
  formulas:

  Case 3.3.
          (IMPLIES (AND (LISTP Y) (NOT (LISTP (CDR Y))))
                   (NOT (LESSP (EVAL$ T (LIST 'FIX (CAR Y)) A)
                               (EVAL$ T (CAR Y) A)))),

    which again simplifies, rewriting with the lemmas REWRITE-EVAL$ and
    CAR-CONS, and expanding FIX, to two new goals:

    Case 3.3.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (LISTP (CDR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (NOT (LESSP 0 (EVAL$ T (CAR Y) A)))),

      which again simplifies, opening up the function LESSP, to:

            T.

    Case 3.3.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (LISTP (CDR Y)))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (NOT (LESSP (EVAL$ T (CAR Y) A)
                                 (EVAL$ T (CAR Y) A)))),

      which again simplifies, using linear arithmetic, to:

            T.

  Case 3.2.
          (IMPLIES (AND (LISTP Y)
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y)))
                   (NOT (LESSP (EVAL$ T
                                      (LIST 'PLUS
                                            (CAR Y)
                                            (PLUS-TREE (CDR Y)))
                                      A)
                               (EVAL$ T (CAR Y) A)))),

    which again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, and
    CDR-CONS, to the new conjecture:

          (IMPLIES (AND (LISTP Y)
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y)))
                   (NOT (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR Y)) A))
                               (EVAL$ T (CAR Y) A)))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Y)
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y))))
                   (NOT (LESSP (EVAL$ T
                                      (LIST 'PLUS (CAR Y) (CADR Y))
                                      A)
                               (EVAL$ T (CAR Y) A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS, to:

          (IMPLIES (AND (LISTP Y)
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y))))
                   (NOT (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                     (EVAL$ T (CADR Y) A))
                               (EVAL$ T (CAR Y) A)))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (NOT (MEMBER X (CDR Y)))
                      (MEMBER X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T X A)))),

  which simplifies, unfolding the functions NLISTP and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A)))
                      (MEMBER X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T X A)))),

  which simplifies, opening up NLISTP, MEMBER, and PLUS-TREE, to three new
  formulas:

  Case 1.3.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                    (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (NOT (LISTP (CDR Y))))
                   (NOT (LESSP (EVAL$ T (LIST 'FIX (CAR Y)) A)
                               (EVAL$ T X A)))),

    which again simplifies, applying the lemmas REWRITE-EVAL$ and CAR-CONS,
    and opening up the definition of FIX, to two new conjectures:

    Case 1.3.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                      (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (NOT (LESSP 0 (EVAL$ T X A)))),

      which again simplifies, expanding the functions EQUAL and LESSP, to:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                      (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                          (NOT (EQUAL (EVAL$ T X A) 0)))
                     (NOT (NUMBERP (EVAL$ T X A)))).

      This further simplifies, expanding the definitions of PLUS-TREE, CDR,
      CAR, LISTP, LITATOM, EQUAL, EVAL$, and LESSP, to:

            T.

    Case 1.3.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                      (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (NOT (LESSP (EVAL$ T (CAR Y) A)
                                 (EVAL$ T X A)))),

      which further simplifies, expanding PLUS-TREE, CDR, CAR, LISTP, LITATOM,
      EQUAL, EVAL$, LESSP, and MEMBER, to:

            T.

  Case 1.2.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                    (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y)))
                   (NOT (LESSP (EVAL$ T
                                      (LIST 'PLUS
                                            (CAR Y)
                                            (PLUS-TREE (CDR Y)))
                                      A)
                               (EVAL$ T X A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS, to:

          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                    (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y)))
                   (NOT (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR Y)) A))
                               (EVAL$ T X A)))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                    (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y))))
                   (NOT (LESSP (EVAL$ T
                                      (LIST 'PLUS (CAR Y) (CADR Y))
                                      A)
                               (EVAL$ T X A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS, to
    the new conjecture:

          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (NOT (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                    (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y))))
                   (NOT (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                     (EVAL$ T (CADR Y) A))
                               (EVAL$ T X A)))),

    which further simplifies, rewriting with the lemmas REWRITE-EVAL$,
    CAR-CONS, and PLUS-RIGHT-ID2, and opening up the functions PLUS-TREE and
    FIX, to two new conjectures:

    Case 1.1.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CADR Y) A)))
                          (NOT (LESSP 0 (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (NOT (LESSP (EVAL$ T (CAR Y) A)
                                 (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 1.1.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NUMBERP (EVAL$ T (CADR Y) A))
                          (NOT (LESSP (EVAL$ T (CADR Y) A)
                                      (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y))))
                     (NOT (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                       (EVAL$ T (CADR Y) A))
                                 (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic, to:

            T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.1 0.0 ]

MEMBER-IMPLIES-PLUS-TREE-GREATEREQP


(PROVE-LEMMA PLUS-TREE-DELETE
             (REWRITE)
             (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A)
                    (IF (MEMBER X Y)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T X A))
                        (EVAL$ T (PLUS-TREE Y) A))))

This simplifies, clearly, to the following two new formulas:

Case 2. (IMPLIES (NOT (MEMBER X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A)
                        (EVAL$ T (PLUS-TREE Y) A))).

  But this again simplifies, rewriting with DELETE-NON-MEMBER, to:

        T.

Case 1. (IMPLIES (MEMBER X Y)
                 (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T X A)))).

  Name the above subgoal *1.


     We will appeal to induction.  There are four plausible inductions.  They
merge into two likely candidate inductions.  However, only one is unflawed.
We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP Y) (p X Y A))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (EQUAL X (CAR Y)))
                    (p X Y A))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (NOT (EQUAL X (CAR Y)))
                         (p X (CDR Y) A))
                    (p X Y A))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP can be used to show that the measure (COUNT Y) decreases according to
the well-founded relation LESSP in each induction step of the scheme.  The
above induction scheme generates four new conjectures:

Case 4. (IMPLIES (AND (NLISTP Y) (MEMBER X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T X A)))),

  which simplifies, opening up the functions NLISTP and MEMBER, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Y))
                      (EQUAL X (CAR Y))
                      (MEMBER X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T X A)))),

  which simplifies, opening up the definitions of NLISTP, MEMBER, DELETE, and
  PLUS-TREE, to three new conjectures:

  Case 3.3.
          (IMPLIES (AND (LISTP Y) (NOT (LISTP (CDR Y))))
                   (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                          (DIFFERENCE (EVAL$ T (LIST 'FIX (CAR Y)) A)
                                      (EVAL$ T (CAR Y) A)))),

    which again simplifies, applying the lemmas REWRITE-EVAL$ and CAR-CONS,
    and opening up the definition of FIX, to two new formulas:

    Case 3.3.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (LISTP (CDR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                            (DIFFERENCE 0 (EVAL$ T (CAR Y) A)))),

      which again simplifies, using linear arithmetic and applying
      DIFFERENCE-0, to the new formula:

            (IMPLIES (AND (LISTP Y)
                          (NOT (LISTP (CDR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                            0)),

      which further simplifies, opening up the definitions of PLUS-TREE, CDR,
      CAR, LISTP, LITATOM, EQUAL, and EVAL$, to:

            T.

    Case 3.3.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (LISTP (CDR Y)))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                            (DIFFERENCE (EVAL$ T (CAR Y) A)
                                        (EVAL$ T (CAR Y) A)))),

      which again simplifies, using linear arithmetic and rewriting with
      DIFFERENCE-0, to:

            (IMPLIES (AND (LISTP Y)
                          (NOT (LISTP (CDR Y)))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                            0)),

      which further simplifies, expanding the functions PLUS-TREE, CDR, CAR,
      LISTP, LITATOM, EQUAL, and EVAL$, to:

            T.

  Case 3.2.
          (IMPLIES (AND (LISTP Y)
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y)))
                   (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS
                                                   (CAR Y)
                                                   (PLUS-TREE (CDR Y)))
                                             A)
                                      (EVAL$ T (CAR Y) A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, CDR-CONS,
    NUMBERP-EVAL$-PLUS-TREE, and DIFFERENCE-PLUS, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Y)
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y))))
                   (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS (CAR Y) (CADR Y))
                                             A)
                                      (EVAL$ T (CAR Y) A)))).

    However this again simplifies, appealing to the lemmas REWRITE-EVAL$,
    CAR-CONS, CDR-CONS, and DIFFERENCE-PLUS, to two new goals:

    Case 3.1.2.
            (IMPLIES (AND (LISTP Y)
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (NOT (NUMBERP (EVAL$ T (CADR Y) A))))
                     (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                            0)),

      which further simplifies, applying REWRITE-EVAL$ and CAR-CONS, and
      opening up the functions PLUS-TREE, FIX, and EQUAL, to:

            T.

    Case 3.1.1.
            (IMPLIES (AND (LISTP Y)
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (NUMBERP (EVAL$ T (CADR Y) A)))
                     (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                            (EVAL$ T (CADR Y) A))).

      But this further simplifies, rewriting with REWRITE-EVAL$ and CAR-CONS,
      and unfolding PLUS-TREE and FIX, to:

            T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (NOT (MEMBER X (CDR Y)))
                      (MEMBER X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T X A)))).

  This simplifies, unfolding NLISTP and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (EQUAL (EVAL$ T
                                    (PLUS-TREE (DELETE X (CDR Y)))
                                    A)
                             (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                         (EVAL$ T X A)))
                      (MEMBER X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (DELETE X Y)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T X A)))).

  This simplifies, rewriting with CAR-CONS and CDR-CONS, and expanding the
  functions NLISTP, MEMBER, DELETE, and PLUS-TREE, to nine new formulas:

  Case 1.9.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (NOT (LISTP (CDR Y)))
                        (NOT (LISTP (DELETE X (CDR Y)))))
                   (EQUAL (EVAL$ T (LIST 'FIX (CAR Y)) A)
                          (DIFFERENCE (EVAL$ T (LIST 'FIX (CAR Y)) A)
                                      (EVAL$ T X A)))),

    which again simplifies, rewriting with EQUAL-DIFFERENCE-0, REWRITE-EVAL$,
    CAR-CONS, and DIFFERENCE-CANCELLATION-0, and opening up the functions
    PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and FIX, to:

          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (NOT (LESSP (EVAL$ T X A)
                                    (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                        (MEMBER X (CDR Y))
                        (NOT (LISTP (CDR Y)))
                        (NOT (LISTP (DELETE X (CDR Y))))
                        (NUMBERP (EVAL$ T (CAR Y) A))
                        (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                        (NOT (EQUAL (EVAL$ T X A) 0)))
                   (NOT (NUMBERP (EVAL$ T X A)))),

    which again simplifies, using linear arithmetic and rewriting with
    MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to the following two new conjectures:

    Case 1.9.2.
            (IMPLIES (AND (NOT (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NUMBERP (EVAL$ T (CAR Y) A))
                          (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                          (NOT (EQUAL (EVAL$ T X A) 0)))
                     (NOT (NUMBERP (EVAL$ T X A)))).

      However this again simplifies, using linear arithmetic and rewriting
      with the lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

    Case 1.9.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A))
                          (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                 (EVAL$ T X A))
                          (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NUMBERP (EVAL$ T (CAR Y) A))
                          (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                          (NOT (EQUAL (EVAL$ T X A) 0)))
                     (NOT (NUMBERP (EVAL$ T X A)))),

      which again simplifies, clearly, to:

            (IMPLIES (AND (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                 (EVAL$ T X A))
                          (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NUMBERP (EVAL$ T (CAR Y) A))
                          (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                          (NOT (EQUAL (EVAL$ T X A) 0)))
                     (NOT (NUMBERP (EVAL$ T X A)))),

      which further simplifies, using linear arithmetic, applying the lemma
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, and unfolding EVAL$, EQUAL, LITATOM,
      LISTP, CAR, CDR, and PLUS-TREE, to:

            T.

  Case 1.8.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP (DELETE X (CDR Y)))
                        (LISTP (CDR (DELETE X (CDR Y)))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR Y)
                                       (PLUS-TREE (DELETE X (CDR Y))))
                                 A)
                          (DIFFERENCE (EVAL$ T (LIST 'FIX (CAR Y)) A)
                                      (EVAL$ T X A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS,
    and unfolding FIX, to the following two new formulas:

    Case 1.8.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (DELETE X (CDR Y)))
                                        A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (LISTP (CDR (DELETE X (CDR Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T
                                         (PLUS-TREE (DELETE X (CDR Y)))
                                         A))
                            (DIFFERENCE 0 (EVAL$ T X A)))).

      But this again simplifies, using linear arithmetic, applying the lemma
      DIFFERENCE-0, and opening up the function PLUS, to the goal:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (DELETE X (CDR Y)))
                                        A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (LISTP (CDR (DELETE X (CDR Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL (EVAL$ T
                                   (PLUS-TREE (DELETE X (CDR Y)))
                                   A)
                            0)).

      But this further simplifies, using linear arithmetic, rewriting with
      DIFFERENCE-0, and opening up the functions DELETE, PLUS-TREE, CDR, CAR,
      LISTP, LITATOM, EQUAL, EVAL$, and MEMBER, to:

            T.

    Case 1.8.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (DELETE X (CDR Y)))
                                        A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (LISTP (CDR (DELETE X (CDR Y))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T
                                         (PLUS-TREE (DELETE X (CDR Y)))
                                         A))
                            (DIFFERENCE (EVAL$ T (CAR Y) A)
                                        (EVAL$ T X A)))).

      This further simplifies, using linear arithmetic, rewriting with the
      lemma DIFFERENCE-0, and opening up the functions DELETE, PLUS-TREE, CDR,
      CAR, LISTP, LITATOM, EQUAL, EVAL$, and MEMBER, to:

            T.

  Case 1.7.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP (DELETE X (CDR Y)))
                        (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR Y)
                                       (CAR (DELETE X (CDR Y))))
                                 A)
                          (DIFFERENCE (EVAL$ T (LIST 'FIX (CAR Y)) A)
                                      (EVAL$ T X A)))),

    which again simplifies, appealing to the lemmas REWRITE-EVAL$, CAR-CONS,
    CDR-CONS, PLUS-RIGHT-ID2, and DIFFERENCE-CANCELLATION-0, and opening up
    PLUS-TREE and FIX, to three new conjectures:

    Case 1.7.3.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                          (EQUAL 0
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NUMBERP (EVAL$ T (CAR Y) A))
                          (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                          (NOT (EQUAL (EVAL$ T X A) 0)))
                     (NOT (NUMBERP (EVAL$ T X A)))),

      which again simplifies, rewriting with EQUAL-DIFFERENCE-0, to the new
      conjecture:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NUMBERP (EVAL$ T (CAR Y) A))
                          (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                          (NOT (EQUAL (EVAL$ T X A) 0)))
                     (NOT (NUMBERP (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic and appealing to the
      lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to two new goals:

      Case 1.7.3.2.
              (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (NOT (LISTP (CDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A))
                           (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                           (NOT (EQUAL (EVAL$ T X A) 0)))
                      (NOT (NUMBERP (EVAL$ T X A)))),

        which again simplifies, using linear arithmetic and applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 1.7.3.1.
              (IMPLIES
                      (AND (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (NOT (LISTP (CDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A))
                           (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                           (NOT (EQUAL (EVAL$ T X A) 0)))
                      (NOT (NUMBERP (EVAL$ T X A)))).

        This again simplifies, trivially, to:

              (IMPLIES
                      (AND (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (NOT (LISTP (CDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A))
                           (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                           (NOT (EQUAL (EVAL$ T X A) 0)))
                      (NOT (NUMBERP (EVAL$ T X A)))),

        which finally simplifies, using linear arithmetic, rewriting with the
        lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, and opening up the
        functions EVAL$, EQUAL, LITATOM, LISTP, CAR, CDR, and PLUS-TREE, to:

              T.

    Case 1.7.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                          (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                            (DIFFERENCE 0 (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic, applying the lemma
      DIFFERENCE-0, and opening up the definition of PLUS, to:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                            0)).

      But this further simplifies, using linear arithmetic, applying
      CAR-NLISTP and DIFFERENCE-0, and expanding DELETE, LISTP, LITATOM, EQUAL,
      EVAL$, PLUS-TREE, CDR, CAR, and MEMBER, to:

            T.

    Case 1.7.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                          (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                            (DIFFERENCE (EVAL$ T (CAR Y) A)
                                        (EVAL$ T X A)))).

      This again simplifies, trivially, to:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (NOT (LISTP (CDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                            (DIFFERENCE (EVAL$ T (CAR Y) A)
                                        (EVAL$ T X A)))),

      which further simplifies, using linear arithmetic, applying the lemmas
      CAR-NLISTP and DIFFERENCE-0, and opening up the definitions of DELETE,
      LISTP, LITATOM, EQUAL, EVAL$, PLUS-TREE, CDR, CAR, and MEMBER, to:

            T.

  Case 1.6.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y))
                        (NOT (LISTP (DELETE X (CDR Y)))))
                   (EQUAL (EVAL$ T (LIST 'FIX (CAR Y)) A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS
                                                   (CAR Y)
                                                   (PLUS-TREE (CDR Y)))
                                             A)
                                      (EVAL$ T X A)))),

    which again simplifies, applying EQUAL-DIFFERENCE-0, REWRITE-EVAL$,
    CAR-CONS, and CDR-CONS, and unfolding the functions PLUS-TREE, CDR, CAR,
    LISTP, LITATOM, EQUAL, EVAL$, and FIX, to the following two new goals:

    Case 1.6.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL 0
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))).

      This again simplifies, using linear arithmetic and appealing to the
      lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to three new goals:

      Case 1.6.2.3.
              (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (NOT (LISTP (DELETE X (CDR Y))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                      (EQUAL 0
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))),

        which again simplifies, applying NUMBERP-EVAL$-PLUS-TREE, to:

              T.

      Case 1.6.2.2.
              (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T X A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (NOT (LISTP (DELETE X (CDR Y))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                      (EQUAL 0
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))).

        However this again simplifies, using linear arithmetic, applying
        NUMBERP-EVAL$-PLUS-TREE, PLUS-RIGHT-ID2, COMMUTATIVITY-OF-PLUS, and
        DIFFERENCE-0, and expanding LESSP, NUMBERP, and EQUAL, to:

              T.

      Case 1.6.2.1.
              (IMPLIES (AND (NUMBERP (EVAL$ T X A))
                            (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A))
                            (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (LISTP (CDDR Y))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T X A))
                                          (EVAL$ T X A)))).

        However this again simplifies, applying PLUS-RIGHT-ID2,
        COMMUTATIVITY-OF-PLUS, and DIFFERENCE-0, and expanding EQUAL, to:

              T.

    Case 1.6.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (CAR Y) A)
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))).

      However this again simplifies, using linear arithmetic and rewriting
      with MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            (IMPLIES (AND (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                 (EVAL$ T X A))
                          (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (CAR Y) A)
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic and rewriting with the
      lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

  Case 1.5.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y))
                        (LISTP (DELETE X (CDR Y)))
                        (LISTP (CDR (DELETE X (CDR Y)))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR Y)
                                       (PLUS-TREE (DELETE X (CDR Y))))
                                 A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS
                                                   (CAR Y)
                                                   (PLUS-TREE (CDR Y)))
                                             A)
                                      (EVAL$ T X A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS, to:

          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y))
                        (LISTP (DELETE X (CDR Y)))
                        (LISTP (CDR (DELETE X (CDR Y)))))
                   (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                (EVAL$ T
                                       (PLUS-TREE (DELETE X (CDR Y)))
                                       A))
                          (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                            (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                      (EVAL$ T X A)))),

    which again simplifies, using linear arithmetic, to two new goals:

    Case 1.5.2.
            (IMPLIES (AND (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                 (EVAL$ T X A))
                          (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (DELETE X (CDR Y)))
                                        A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (LISTP (DELETE X (CDR Y)))
                          (LISTP (CDR (DELETE X (CDR Y)))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T
                                         (PLUS-TREE (DELETE X (CDR Y)))
                                         A))
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic and rewriting with
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

    Case 1.5.1.
            (IMPLIES (AND (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                 (EVAL$ T X A))
                          (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (DELETE X (CDR Y)))
                                        A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (LISTP (DELETE X (CDR Y)))
                          (LISTP (CDR (DELETE X (CDR Y)))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T
                                         (PLUS-TREE (DELETE X (CDR Y)))
                                         A))
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))).

      However this again simplifies, using linear arithmetic, to:

            (IMPLIES (AND (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                 (EVAL$ T X A))
                          (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                 (EVAL$ T X A))
                          (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (DELETE X (CDR Y)))
                                        A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (LISTP (DELETE X (CDR Y)))
                          (LISTP (CDR (DELETE X (CDR Y)))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T
                                         (PLUS-TREE (DELETE X (CDR Y)))
                                         A))
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))).

      But this again simplifies, using linear arithmetic and applying
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

  Case 1.4.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y))
                        (LISTP (DELETE X (CDR Y)))
                        (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR Y)
                                       (CAR (DELETE X (CDR Y))))
                                 A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS
                                                   (CAR Y)
                                                   (PLUS-TREE (CDR Y)))
                                             A)
                                      (EVAL$ T X A)))).

    However this again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
    CDR-CONS, and PLUS-RIGHT-ID2, and opening up the definitions of PLUS-TREE
    and FIX, to the following three new formulas:

    Case 1.4.3.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                          (EQUAL 0
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL 0
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))).

      However this again simplifies, applying the lemmas EQUAL-DIFFERENCE-0,
      NUMBERP-EVAL$-PLUS-TREE, and DIFFERENCE-0, and unfolding the definitions
      of PLUS and EQUAL, to:

            T.

    Case 1.4.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                          (EQUAL 0
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (CAR Y) A)
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic, to two new formulas:

      Case 1.4.2.2.
              (IMPLIES
                      (AND (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (EQUAL 0
                                  (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                              (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))),

        which again simplifies, using linear arithmetic and applying the lemma
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 1.4.2.1.
              (IMPLIES
                      (AND (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (EQUAL 0
                                  (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                              (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))),

        which again simplifies, using linear arithmetic, to the conjecture:

              (IMPLIES
                      (AND (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (EQUAL 0
                                  (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                              (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))).

        This again simplifies, using linear arithmetic and appealing to the
        lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

    Case 1.4.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                          (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (LISTP (CDDR Y))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                        (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic, to two new conjectures:

      Case 1.4.1.2.
              (IMPLIES
                      (AND (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                           (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                  (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                              (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                      (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                   (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))),

        which again simplifies, using linear arithmetic and applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 1.4.1.1.
              (IMPLIES
                      (AND (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                           (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                  (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                              (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                      (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                   (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))).

        This again simplifies, using linear arithmetic, to:

              (IMPLIES
                      (AND (LESSP (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                           (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                  (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                              (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (LISTP (CDDR Y))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                      (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                   (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (PLUS-TREE (CDR Y)) A))
                                         (EVAL$ T X A)))).

        This again simplifies, using linear arithmetic and rewriting with
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

  Case 1.3.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y)))
                        (NOT (LISTP (DELETE X (CDR Y)))))
                   (EQUAL (EVAL$ T (LIST 'FIX (CAR Y)) A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS (CAR Y) (CADR Y))
                                             A)
                                      (EVAL$ T X A)))).

    However this again simplifies, applying the lemmas EQUAL-DIFFERENCE-0,
    REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and opening up the functions
    PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and FIX, to two new
    conjectures:

    Case 1.3.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL 0
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic and rewriting with
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to the following three new formulas:

      Case 1.3.2.3.
              (IMPLIES (AND (NOT (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))).

        However this again simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE,
        to:

              T.

      Case 1.3.2.2.
              (IMPLIES (AND (NOT (NUMBERP (EVAL$ T X A)))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))).

        But this again simplifies, applying NUMBERP-EVAL$-PLUS-TREE, and
        opening up the definitions of LESSP, PLUS, and DIFFERENCE, to:

              (IMPLIES (AND (NOT (NUMBERP (EVAL$ T X A)))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                   0)
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (NOT (EQUAL (EVAL$ T (CADR Y) A) 0)))
                       (EQUAL 0 (EVAL$ T (CADR Y) A))),

        which again simplifies, obviously, to:

              (IMPLIES (AND (NOT (NUMBERP (EVAL$ T X A)))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                   0)
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                            (NUMBERP (EVAL$ T (CADR Y) A)))
                       (EQUAL 0 (EVAL$ T (CADR Y) A))),

        which finally simplifies, rewriting with REWRITE-EVAL$ and CAR-CONS,
        and expanding PLUS-TREE and FIX, to:

              T.

      Case 1.3.2.1.
              (IMPLIES (AND (NUMBERP (EVAL$ T X A))
                            (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A))
                            (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))).

        This again simplifies, applying the lemma EQUAL-DIFFERENCE-0, and
        unfolding PLUS, to two new conjectures:

        Case 1.3.2.1.2.
                (IMPLIES (AND (NUMBERP (EVAL$ T X A))
                              (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                     (EVAL$ T X A))
                              (LISTP Y)
                              (NOT (EQUAL X (CAR Y)))
                              (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                              (MEMBER X (CDR Y))
                              (LISTP (CDR Y))
                              (NOT (LISTP (CDDR Y)))
                              (NOT (LISTP (DELETE X (CDR Y))))
                              (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                              (NOT (NUMBERP (EVAL$ T (CADR Y) A))))
                         (NOT (LESSP (EVAL$ T X A) 0))),

          which again simplifies, using linear arithmetic, to:

                T.

        Case 1.3.2.1.1.
                (IMPLIES (AND (NUMBERP (EVAL$ T X A))
                              (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                     (EVAL$ T X A))
                              (LISTP Y)
                              (NOT (EQUAL X (CAR Y)))
                              (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                              (MEMBER X (CDR Y))
                              (LISTP (CDR Y))
                              (NOT (LISTP (CDDR Y)))
                              (NOT (LISTP (DELETE X (CDR Y))))
                              (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                              (NUMBERP (EVAL$ T (CADR Y) A)))
                         (NOT (LESSP (EVAL$ T X A)
                                     (EVAL$ T (CADR Y) A)))),

          which further simplifies, applying the lemmas REWRITE-EVAL$,
          CAR-CONS, CONS-CAR-CDR, and DELETE-NON-MEMBER, and opening up the
          definitions of PLUS-TREE, FIX, MEMBER, and DELETE, to:

                T.

    Case 1.3.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (NOT (LISTP (DELETE X (CDR Y))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (CAR Y) A)
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))),

      which again simplifies, using linear arithmetic and rewriting with the
      lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to three new conjectures:

      Case 1.3.1.3.
              (IMPLIES (AND (NOT (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))),

        which again simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE, to:

              T.

      Case 1.3.1.2.
              (IMPLIES (AND (NOT (NUMBERP (EVAL$ T X A)))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A)
                                        (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))).

        But this again simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE and
        PLUS-EQUAL-0, and expanding LESSP and DIFFERENCE, to the following two
        new conjectures:

        Case 1.3.1.2.2.
                (IMPLIES (AND (NOT (NUMBERP (EVAL$ T X A)))
                              (LISTP Y)
                              (NOT (EQUAL X (CAR Y)))
                              (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                     0)
                              (MEMBER X (CDR Y))
                              (LISTP (CDR Y))
                              (NOT (LISTP (CDDR Y)))
                              (NOT (LISTP (DELETE X (CDR Y))))
                              (NUMBERP (EVAL$ T (CAR Y) A))
                              (NOT (EQUAL (EVAL$ T (CADR Y) A) 0))
                              (NUMBERP (EVAL$ T (CADR Y) A)))
                         (EQUAL (EVAL$ T (CAR Y) A)
                                (PLUS (EVAL$ T (CAR Y) A)
                                      (EVAL$ T (CADR Y) A)))).

          But this further simplifies, appealing to the lemmas REWRITE-EVAL$
          and CAR-CONS, and expanding the definitions of PLUS-TREE and FIX, to:

                T.

        Case 1.3.1.2.1.
                (IMPLIES (AND (NOT (NUMBERP (EVAL$ T X A)))
                              (LISTP Y)
                              (NOT (EQUAL X (CAR Y)))
                              (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                     0)
                              (MEMBER X (CDR Y))
                              (LISTP (CDR Y))
                              (NOT (LISTP (CDDR Y)))
                              (NOT (LISTP (DELETE X (CDR Y))))
                              (NUMBERP (EVAL$ T (CAR Y) A))
                              (NOT (EQUAL (EVAL$ T (CAR Y) A) 0)))
                         (EQUAL (EVAL$ T (CAR Y) A)
                                (PLUS (EVAL$ T (CAR Y) A)
                                      (EVAL$ T (CADR Y) A)))),

          which further simplifies, applying the lemmas REWRITE-EVAL$,
          CAR-CONS, CONS-CAR-CDR, DELETE-NON-MEMBER, and COMMUTATIVITY-OF-PLUS,
          and unfolding the functions PLUS-TREE, FIX, MEMBER, DELETE, and PLUS,
          to:

                T.

      Case 1.3.1.1.
              (IMPLIES (AND (NUMBERP (EVAL$ T X A))
                            (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A))
                            (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))),

        which again simplifies, clearly, to:

              (IMPLIES (AND (NUMBERP (EVAL$ T X A))
                            (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (LISTP (DELETE X (CDR Y))))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))),

        which further simplifies, applying the lemmas REWRITE-EVAL$, CAR-CONS,
        CONS-CAR-CDR, DELETE-NON-MEMBER, COMMUTATIVITY-OF-PLUS, and
        DIFFERENCE-PLUS, and expanding PLUS-TREE, FIX, LESSP, MEMBER, DELETE,
        EQUAL, PLUS, and DIFFERENCE, to:

              T.

  Case 1.2.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP (DELETE X (CDR Y)))
                        (LISTP (CDR (DELETE X (CDR Y)))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR Y)
                                       (PLUS-TREE (DELETE X (CDR Y))))
                                 A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS (CAR Y) (CADR Y))
                                             A)
                                      (EVAL$ T X A)))),

    which again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, and
    CDR-CONS, to the new formula:

          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP (DELETE X (CDR Y)))
                        (LISTP (CDR (DELETE X (CDR Y)))))
                   (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                (EVAL$ T
                                       (PLUS-TREE (DELETE X (CDR Y)))
                                       A))
                          (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                            (EVAL$ T (CADR Y) A))
                                      (EVAL$ T X A)))),

    which further simplifies, rewriting with CONS-CAR-CDR, DELETE-NON-MEMBER,
    REWRITE-EVAL$, and CAR-CONS, and opening up the functions MEMBER, DELETE,
    PLUS-TREE, and FIX, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (DELETE X (CDR Y)))
                                      A)
                               (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                           (EVAL$ T X A)))
                        (MEMBER X (CDR Y))
                        (LISTP (CDR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP (DELETE X (CDR Y)))
                        (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR Y)
                                       (CAR (DELETE X (CDR Y))))
                                 A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS (CAR Y) (CADR Y))
                                             A)
                                      (EVAL$ T X A)))).

    This again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, CDR-CONS,
    and PLUS-RIGHT-ID2, and expanding the functions PLUS-TREE and FIX, to the
    following three new conjectures:

    Case 1.1.3.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                          (EQUAL 0
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL 0
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))).

      This again simplifies, rewriting with EQUAL-DIFFERENCE-0, and opening up
      the function PLUS, to the following two new goals:

      Case 1.1.3.2.
              (IMPLIES
                      (AND (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                           (NOT (NUMBERP (EVAL$ T (CADR Y) A))))
                      (NOT (LESSP (EVAL$ T X A) 0))).

        But this again simplifies, using linear arithmetic, to:

              T.

      Case 1.1.3.1.
              (IMPLIES
                      (AND (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                           (NUMBERP (EVAL$ T (CADR Y) A)))
                      (NOT (LESSP (EVAL$ T X A)
                                  (EVAL$ T (CADR Y) A)))),

        which again simplifies, using linear arithmetic and rewriting with
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to the following three new
        conjectures:

        Case 1.1.3.1.3.
                (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                           (NUMBERP (EVAL$ T (CADR Y) A)))
                      (NOT (LESSP (EVAL$ T X A)
                                  (EVAL$ T (CADR Y) A)))).

          But this again simplifies, applying NUMBERP-EVAL$-PLUS-TREE, to:

                T.

        Case 1.1.3.1.2.
                (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T X A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                           (NUMBERP (EVAL$ T (CADR Y) A)))
                      (NOT (LESSP (EVAL$ T X A)
                                  (EVAL$ T (CADR Y) A)))).

          But this again simplifies, applying the lemma
          NUMBERP-EVAL$-PLUS-TREE, and unfolding the function LESSP, to:

                (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T X A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  0)
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                           (NUMBERP (EVAL$ T (CADR Y) A)))
                      (EQUAL (EVAL$ T (CADR Y) A) 0)).

          However this finally simplifies, rewriting with CONS-CAR-CDR,
          DELETE-NON-MEMBER, REWRITE-EVAL$, and CAR-CONS, and unfolding the
          functions MEMBER, DELETE, PLUS-TREE, FIX, and EQUAL, to:

                T.

        Case 1.1.3.1.1.
                (IMPLIES
                      (AND (NUMBERP (EVAL$ T X A))
                           (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                           (NUMBERP (EVAL$ T (CADR Y) A)))
                      (NOT (LESSP (EVAL$ T X A)
                                  (EVAL$ T (CADR Y) A)))).

          This again simplifies, trivially, to the new conjecture:

                (IMPLIES
                      (AND (NUMBERP (EVAL$ T X A))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                           (NUMBERP (EVAL$ T (CADR Y) A)))
                      (NOT (LESSP (EVAL$ T X A)
                                  (EVAL$ T (CADR Y) A)))),

          which finally simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
          CONS-CAR-CDR, and DELETE-NON-MEMBER, and unfolding PLUS-TREE, FIX,
          MEMBER, and DELETE, to:

                T.

    Case 1.1.2.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                          (EQUAL 0
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (CAR Y) A)
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))).

      This again simplifies, appealing to the lemma EQUAL-DIFFERENCE-0, to:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                          (NOT (LESSP (EVAL$ T X A)
                                      (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (CAR Y) A)
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))).

      But this again simplifies, using linear arithmetic and rewriting with
      the lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to three new conjectures:

      Case 1.1.2.3.
              (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (CADR Y) A))
                                         (EVAL$ T X A)))),

        which again simplifies, rewriting with the lemma
        NUMBERP-EVAL$-PLUS-TREE, to:

              T.

      Case 1.1.2.2.
              (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T X A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A)
                                       (EVAL$ T (PLUS-TREE (CDR Y)) A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (CADR Y) A))
                                         (EVAL$ T X A)))),

        which again simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE and
        PLUS-EQUAL-0, and opening up LESSP and DIFFERENCE, to the following
        two new formulas:

        Case 1.1.2.2.2.
                (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T X A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  0)
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A))
                           (NOT (EQUAL (EVAL$ T (CADR Y) A) 0))
                           (NUMBERP (EVAL$ T (CADR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (PLUS (EVAL$ T (CAR Y) A)
                                   (EVAL$ T (CADR Y) A)))).

          But this finally simplifies, rewriting with CONS-CAR-CDR,
          DELETE-NON-MEMBER, REWRITE-EVAL$, and CAR-CONS, and opening up the
          definitions of MEMBER, DELETE, PLUS-TREE, FIX, and EQUAL, to:

                T.

        Case 1.1.2.2.1.
                (IMPLIES
                      (AND (NOT (NUMBERP (EVAL$ T X A)))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  0)
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A))
                           (NOT (EQUAL (EVAL$ T (CAR Y) A) 0)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (PLUS (EVAL$ T (CAR Y) A)
                                   (EVAL$ T (CADR Y) A)))).

          However this finally simplifies, applying the lemmas CONS-CAR-CDR,
          DELETE-NON-MEMBER, REWRITE-EVAL$, CAR-CONS, and PLUS-RIGHT-ID2, and
          expanding the definitions of MEMBER, DELETE, PLUS-TREE, FIX, and
          EQUAL, to:

                T.

      Case 1.1.2.1.
              (IMPLIES
                      (AND (NUMBERP (EVAL$ T X A))
                           (NUMBERP (EVAL$ T (PLUS-TREE (CDR Y)) A))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (CADR Y) A))
                                         (EVAL$ T X A)))),

        which again simplifies, clearly, to:

              (IMPLIES
                      (AND (NUMBERP (EVAL$ T X A))
                           (EQUAL (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                  (EVAL$ T X A))
                           (LISTP Y)
                           (NOT (EQUAL X (CAR Y)))
                           (NOT (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A)))
                           (NOT (LESSP (EVAL$ T X A) (EVAL$ T X A)))
                           (MEMBER X (CDR Y))
                           (LISTP (CDR Y))
                           (NOT (LISTP (CDDR Y)))
                           (LISTP (DELETE X (CDR Y)))
                           (NOT (LISTP (CDR (DELETE X (CDR Y)))))
                           (NUMBERP (EVAL$ T (CAR Y) A)))
                      (EQUAL (EVAL$ T (CAR Y) A)
                             (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                               (EVAL$ T (CADR Y) A))
                                         (EVAL$ T X A)))),

        which finally simplifies, applying REWRITE-EVAL$, CAR-CONS,
        CONS-CAR-CDR, DELETE-NON-MEMBER, and PLUS-RIGHT-ID2, and opening up
        the functions PLUS-TREE, FIX, MEMBER, DELETE, LESSP, EQUAL, and
        DIFFERENCE, to:

              T.

    Case 1.1.1.
            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NUMBERP (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                          (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))).

      This again simplifies, clearly, to:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (EQUAL (EVAL$ T (CAR (DELETE X (CDR Y))) A)
                                 (DIFFERENCE (EVAL$ T (PLUS-TREE (CDR Y)) A)
                                             (EVAL$ T X A)))
                          (MEMBER X (CDR Y))
                          (LISTP (CDR Y))
                          (NOT (LISTP (CDDR Y)))
                          (LISTP (DELETE X (CDR Y)))
                          (NOT (LISTP (CDR (DELETE X (CDR Y))))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T (CAR (DELETE X (CDR Y))) A))
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))),

      which further simplifies, rewriting with the lemmas CONS-CAR-CDR,
      DELETE-NON-MEMBER, REWRITE-EVAL$, CAR-CONS, PLUS-EQUAL-0, and
      DIFFERENCE-CANCELLATION-0, and expanding MEMBER, DELETE, PLUS-TREE, and
      FIX, to three new conjectures:

      Case 1.1.1.3.
              (IMPLIES (AND (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (NOT (EQUAL X (CADR Y)))
                            (EQUAL (EVAL$ T (CADR Y) A)
                                   (DIFFERENCE (EVAL$ T (CADR Y) A)
                                               (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                            (NUMBERP (EVAL$ T (CAR Y) A))
                            (NOT (EQUAL (EVAL$ T X A) 0)))
                       (NOT (NUMBERP (EVAL$ T X A)))),

        which again simplifies, using linear arithmetic, to the formula:

              (IMPLIES (AND (LESSP (EVAL$ T (CADR Y) A)
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (NOT (EQUAL X (CADR Y)))
                            (EQUAL (EVAL$ T (CADR Y) A)
                                   (DIFFERENCE (EVAL$ T (CADR Y) A)
                                               (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (EQUAL (EVAL$ T (CAR Y) A) 0))
                            (NUMBERP (EVAL$ T (CAR Y) A))
                            (NOT (EQUAL (EVAL$ T X A) 0)))
                       (NOT (NUMBERP (EVAL$ T X A)))).

        However this finally simplifies, using linear arithmetic, applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, CAR-CONS, and REWRITE-EVAL$, and
        expanding the functions FIX and PLUS-TREE, to:

              T.

      Case 1.1.1.2.
              (IMPLIES (AND (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (NOT (EQUAL X (CADR Y)))
                            (EQUAL (EVAL$ T (CADR Y) A)
                                   (DIFFERENCE (EVAL$ T (CADR Y) A)
                                               (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                            (NOT (EQUAL (EVAL$ T (CADR Y) A) 0))
                            (NOT (EQUAL (EVAL$ T X A) 0)))
                       (NOT (NUMBERP (EVAL$ T X A)))).

        However this again simplifies, using linear arithmetic, to:

              (IMPLIES (AND (LESSP (EVAL$ T (CADR Y) A)
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (NOT (EQUAL X (CADR Y)))
                            (EQUAL (EVAL$ T (CADR Y) A)
                                   (DIFFERENCE (EVAL$ T (CADR Y) A)
                                               (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A)))
                            (NOT (EQUAL (EVAL$ T (CADR Y) A) 0))
                            (NOT (EQUAL (EVAL$ T X A) 0)))
                       (NOT (NUMBERP (EVAL$ T X A)))).

        However this finally simplifies, using linear arithmetic, applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, CAR-CONS, and REWRITE-EVAL$, and
        expanding the functions FIX and PLUS-TREE, to:

              T.

      Case 1.1.1.1.
              (IMPLIES (AND (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (NOT (EQUAL X (CADR Y)))
                            (EQUAL (EVAL$ T (CADR Y) A)
                                   (DIFFERENCE (EVAL$ T (CADR Y) A)
                                               (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (EQUAL (EVAL$ T (CAR Y) A) 0)
                            (NOT (EQUAL (EVAL$ T (CADR Y) A) 0))
                            (NOT (EQUAL (EVAL$ T X A) 0)))
                       (NOT (NUMBERP (EVAL$ T X A)))).

        However this again simplifies, using linear arithmetic, to:

              (IMPLIES (AND (LESSP (EVAL$ T (CADR Y) A)
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (NOT (EQUAL X (CADR Y)))
                            (EQUAL (EVAL$ T (CADR Y) A)
                                   (DIFFERENCE (EVAL$ T (CADR Y) A)
                                               (EVAL$ T X A)))
                            (MEMBER X (CDR Y))
                            (LISTP (CDR Y))
                            (NOT (LISTP (CDDR Y)))
                            (EQUAL (EVAL$ T (CAR Y) A) 0)
                            (NOT (EQUAL (EVAL$ T (CADR Y) A) 0))
                            (NOT (EQUAL (EVAL$ T X A) 0)))
                       (NOT (NUMBERP (EVAL$ T X A)))).

        This finally simplifies, using linear arithmetic, appealing to the
        lemmas MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, CAR-CONS, and
        REWRITE-EVAL$, and opening up the functions FIX and PLUS-TREE, to:

              T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 1.4 0.1 ]

PLUS-TREE-DELETE


(PROVE-LEMMA SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP
             (REWRITE)
             (IMPLIES (SUBBAGP X Y)
                      (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (PLUS-TREE X) A)))))

WARNING:  When the linear lemma SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP is stored
under (EVAL$ T (PLUS-TREE Y) A) it contains the free variable X which will be
chosen by instantiating the hypothesis (SUBBAGP X Y).


WARNING:  When the linear lemma SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP is stored
under (EVAL$ T (PLUS-TREE X) A) it contains the free variable Y which will be
chosen by instantiating the hypothesis (SUBBAGP X Y).


WARNING:  Note that the proposed lemma SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP is
to be stored as zero type prescription rules, zero compound recognizer rules,
two linear rules, and zero replacement rules.



     Name the conjecture *1.


     Perhaps we can prove it by induction.  There are three plausible
inductions.  They merge into two likely candidate inductions.  However, only
one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (MEMBER (CAR X) Y)
                         (p (DELETE (CAR X) Y) A (CDR X)))
                    (p Y A X))
           (IMPLIES (AND (LISTP X)
                         (NOT (MEMBER (CAR X) Y)))
                    (p Y A X))
           (IMPLIES (NOT (LISTP X)) (p Y A X))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instance chosen for Y.  The above
induction scheme leads to the following four new formulas:

Case 4. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) Y)
                      (NOT (SUBBAGP (CDR X) (DELETE (CAR X) Y)))
                      (SUBBAGP X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T (PLUS-TREE X) A)))).

  This simplifies, opening up the definition of SUBBAGP, to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) Y)
                      (NOT (LESSP (EVAL$ T
                                         (PLUS-TREE (DELETE (CAR X) Y))
                                         A)
                                  (EVAL$ T (PLUS-TREE (CDR X)) A)))
                      (SUBBAGP X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T (PLUS-TREE X) A)))).

  This simplifies, applying PLUS-TREE-DELETE, and unfolding SUBBAGP and
  PLUS-TREE, to three new formulas:

  Case 3.3.
          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) Y)
                        (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                        (NOT (LISTP (CDR X))))
                   (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T (LIST 'FIX (CAR X)) A)))),

    which again simplifies, rewriting with the lemmas REWRITE-EVAL$ and
    CAR-CONS, and opening up the definition of FIX, to two new formulas:

    Case 3.3.2.
            (IMPLIES (AND (LISTP X)
                          (MEMBER (CAR X) Y)
                          (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                  (EVAL$ T (CAR X) A))
                                      (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                          (NOT (LISTP (CDR X)))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A) 0))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 3.3.1.
            (IMPLIES (AND (LISTP X)
                          (MEMBER (CAR X) Y)
                          (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                  (EVAL$ T (CAR X) A))
                                      (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                          (NOT (LISTP (CDR X)))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                 (EVAL$ T (CAR X) A)))),

      which again simplifies, using linear arithmetic and applying
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

  Case 3.2.
          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) Y)
                        (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                        (LISTP (CDR X))
                        (LISTP (CDDR X)))
                   (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T
                                      (LIST 'PLUS
                                            (CAR X)
                                            (PLUS-TREE (CDR X)))
                                      A)))).

    This again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, and
    CDR-CONS, to:

          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) Y)
                        (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                        (LISTP (CDR X))
                        (LISTP (CDDR X)))
                   (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                               (PLUS (EVAL$ T (CAR X) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A))))),

    which again simplifies, using linear arithmetic, to:

          (IMPLIES (AND (LESSP (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T (CAR X) A))
                        (LISTP X)
                        (MEMBER (CAR X) Y)
                        (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                        (LISTP (CDR X))
                        (LISTP (CDDR X)))
                   (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                               (PLUS (EVAL$ T (CAR X) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A))))).

    However this again simplifies, using linear arithmetic and applying
    MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) Y)
                        (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                        (LISTP (CDR X))
                        (NOT (LISTP (CDDR X))))
                   (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T
                                      (LIST 'PLUS (CAR X) (CADR X))
                                      A)))).

    This again simplifies, rewriting with the lemmas REWRITE-EVAL$, CAR-CONS,
    and CDR-CONS, to:

          (IMPLIES (AND (LISTP X)
                        (MEMBER (CAR X) Y)
                        (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                        (LISTP (CDR X))
                        (NOT (LISTP (CDDR X))))
                   (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                               (PLUS (EVAL$ T (CAR X) A)
                                     (EVAL$ T (CADR X) A))))).

    But this further simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, and
    PLUS-RIGHT-ID2, and expanding the definitions of PLUS-TREE and FIX, to the
    following three new formulas:

    Case 3.1.3.
            (IMPLIES (AND (LISTP X)
                          (MEMBER (CAR X) Y)
                          (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                          (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                  (EVAL$ T (CAR X) A))
                                      0))
                          (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A) 0))).

      However this again simplifies, using linear arithmetic, to:

            T.

    Case 3.1.2.
            (IMPLIES (AND (LISTP X)
                          (MEMBER (CAR X) Y)
                          (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                          (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                  (EVAL$ T (CAR X) A))
                                      0))
                          (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                 (EVAL$ T (CAR X) A)))),

      which again simplifies, using linear arithmetic and applying the lemma
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

    Case 3.1.1.
            (IMPLIES (AND (LISTP X)
                          (MEMBER (CAR X) Y)
                          (NUMBERP (EVAL$ T (CADR X) A))
                          (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                  (EVAL$ T (CAR X) A))
                                      (EVAL$ T (CADR X) A)))
                          (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X))))
                     (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                 (PLUS (EVAL$ T (CAR X) A)
                                       (EVAL$ T (CADR X) A))))),

      which again simplifies, using linear arithmetic, to:

            (IMPLIES (AND (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                 (EVAL$ T (CAR X) A))
                          (LISTP X)
                          (MEMBER (CAR X) Y)
                          (NUMBERP (EVAL$ T (CADR X) A))
                          (NOT (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                  (EVAL$ T (CAR X) A))
                                      (EVAL$ T (CADR X) A)))
                          (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X))))
                     (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                 (PLUS (EVAL$ T (CAR X) A)
                                       (EVAL$ T (CADR X) A))))).

      However this again simplifies, using linear arithmetic and applying
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) Y))
                      (SUBBAGP X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T (PLUS-TREE X) A)))).

  This simplifies, unfolding the definition of SUBBAGP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (SUBBAGP X Y))
                 (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                             (EVAL$ T (PLUS-TREE X) A)))).

  This simplifies, applying SUBBAGP-CDR2, and opening up SUBBAGP, PLUS-TREE,
  CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and LESSP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.1 0.0 ]

SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP


(PROVE-LEMMA PLUS-TREE-BAGDIFF
             (REWRITE)
             (IMPLIES (SUBBAGP X Y)
                      (EQUAL (EVAL$ T (PLUS-TREE (BAGDIFF Y X)) A)
                             (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                         (EVAL$ T (PLUS-TREE X) A)))))


     Give the conjecture the name *1.


     Perhaps we can prove it by induction.  Four inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (MEMBER (CAR X) Y)
                         (p (DELETE (CAR X) Y) (CDR X) A))
                    (p Y X A))
           (IMPLIES (AND (LISTP X)
                         (NOT (MEMBER (CAR X) Y))
                         (p Y (CDR X) A))
                    (p Y X A))
           (IMPLIES (NOT (LISTP X)) (p Y X A))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for Y.  The
above induction scheme generates the following five new goals:

Case 5. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) Y)
                      (NOT (SUBBAGP (CDR X) (DELETE (CAR X) Y)))
                      (SUBBAGP X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (BAGDIFF Y X)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (PLUS-TREE X) A)))).

  This simplifies, unfolding the definition of SUBBAGP, to:

        T.

Case 4. (IMPLIES
            (AND (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (EVAL$ T
                                           (PLUS-TREE (DELETE (CAR X) Y))
                                           A)
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP X Y))
            (EQUAL (EVAL$ T (PLUS-TREE (BAGDIFF Y X)) A)
                   (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T (PLUS-TREE X) A)))).

  This simplifies, rewriting with PLUS-TREE-DELETE, and expanding the
  functions SUBBAGP, BAGDIFF, and PLUS-TREE, to three new conjectures:

  Case 4.3.
          (IMPLIES
            (AND (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (NOT (LISTP (CDR X))))
            (EQUAL (EVAL$ T
                          (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                          A)
                   (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T (LIST 'FIX (CAR X)) A)))),

    which again simplifies, applying the lemmas REWRITE-EVAL$ and CAR-CONS,
    and expanding FIX, to two new goals:

    Case 4.3.2.
            (IMPLIES
             (AND
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (NOT (LISTP (CDR X)))
                 (NOT (NUMBERP (EVAL$ T (CAR X) A))))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                0))),

      which again simplifies, using linear arithmetic, appealing to the lemmas
      NUMBERP-EVAL$-PLUS-TREE and DIFFERENCE-0, and unfolding the functions
      DIFFERENCE and EQUAL, to the goal:

            (IMPLIES
             (AND
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NOT (EQUAL (EVAL$ T (PLUS-TREE Y) A) 0))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (NOT (LISTP (CDR X)))
                 (NOT (NUMBERP (EVAL$ T (CAR X) A))))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (EVAL$ T (PLUS-TREE Y) A))).

      This further simplifies, applying the lemmas NUMBERP-EVAL$-PLUS-TREE,
      PLUS-TREE-DELETE, and SUBBAGP-CDR2, and opening up BAGDIFF, DIFFERENCE,
      PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and SUBBAGP, to:

            T.

    Case 4.3.1.
            (IMPLIES
             (AND
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (NOT (LISTP (CDR X)))
                 (NUMBERP (EVAL$ T (CAR X) A)))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T (CAR X) A)))),

      which further simplifies, rewriting with the lemmas PLUS-TREE-DELETE,
      EQUAL-DIFFERENCE-0, and SUBBAGP-CDR2, and expanding the definitions of
      BAGDIFF, PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, DIFFERENCE,
      and SUBBAGP, to:

            T.

  Case 4.2.
          (IMPLIES
            (AND (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
            (EQUAL (EVAL$ T
                          (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                          A)
                   (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T
                                      (LIST 'PLUS
                                            (CAR X)
                                            (PLUS-TREE (CDR X)))
                                      A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS, to:

          (IMPLIES
            (AND (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
            (EQUAL (EVAL$ T
                          (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                          A)
                   (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                               (PLUS (EVAL$ T (CAR X) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A))))),

    which again simplifies, using linear arithmetic, to four new conjectures:

    Case 4.2.4.
            (IMPLIES
             (AND
                 (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (CAR X) A))
                        (EVAL$ T (PLUS-TREE (CDR X)) A))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (PLUS (EVAL$ T (CAR X) A)
                                      (EVAL$ T (PLUS-TREE (CDR X)) A))))),

      which again simplifies, using linear arithmetic and rewriting with
      SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP and PLUS-TREE-DELETE, to:

            (IMPLIES
             (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (EVAL$ T (CAR X) A))
                 (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (CAR X) A))
                        (EVAL$ T (PLUS-TREE (CDR X)) A))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (PLUS (EVAL$ T (CAR X) A)
                                      (EVAL$ T (PLUS-TREE (CDR X)) A))))),

      which again simplifies, using linear arithmetic and appealing to the
      lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

    Case 4.2.3.
            (IMPLIES
             (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (EVAL$ T (CAR X) A))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (PLUS (EVAL$ T (CAR X) A)
                                      (EVAL$ T (PLUS-TREE (CDR X)) A))))),

      which again simplifies, using linear arithmetic and rewriting with
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

            T.

    Case 4.2.2.
            (IMPLIES
             (AND
              (NOT
               (NUMBERP (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)))
              (LISTP X)
              (MEMBER (CAR X) Y)
              (EQUAL (EVAL$ T
                            (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                            A)
                     (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                             (EVAL$ T (CAR X) A))
                                 (EVAL$ T (PLUS-TREE (CDR X)) A)))
              (SUBBAGP (CDR X) (DELETE (CAR X) Y))
              (LISTP (CDR X))
              (LISTP (CDDR X)))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (PLUS (EVAL$ T (CAR X) A)
                                      (EVAL$ T (PLUS-TREE (CDR X)) A))))).

      This again simplifies, obviously, to:

            T.

    Case 4.2.1.
            (IMPLIES
             (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (PLUS (EVAL$ T (CAR X) A)
                              (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (PLUS (EVAL$ T (CAR X) A)
                                      (EVAL$ T (PLUS-TREE (CDR X)) A))))).

      But this again simplifies, using linear arithmetic, to two new
      conjectures:

      Case 4.2.1.2.
              (IMPLIES
               (AND
                 (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (CAR X) A))
                        (EVAL$ T (PLUS-TREE (CDR X)) A))
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (PLUS (EVAL$ T (CAR X) A)
                              (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (PLUS (EVAL$ T (CAR X) A)
                                        (EVAL$ T (PLUS-TREE (CDR X)) A))))),

        which again simplifies, using linear arithmetic and applying
        SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP and PLUS-TREE-DELETE, to:

              (IMPLIES
               (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (EVAL$ T (CAR X) A))
                 (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (CAR X) A))
                        (EVAL$ T (PLUS-TREE (CDR X)) A))
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (PLUS (EVAL$ T (CAR X) A)
                              (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (PLUS (EVAL$ T (CAR X) A)
                                        (EVAL$ T (PLUS-TREE (CDR X)) A))))),

        which again simplifies, using linear arithmetic and applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 4.2.1.1.
              (IMPLIES
               (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (EVAL$ T (CAR X) A))
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (PLUS (EVAL$ T (CAR X) A)
                              (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (LISTP (CDDR X)))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (PLUS (EVAL$ T (CAR X) A)
                                        (EVAL$ T (PLUS-TREE (CDR X)) A))))).

        But this again simplifies, using linear arithmetic and appealing to
        the lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

  Case 4.1.
          (IMPLIES
            (AND (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X))))
            (EQUAL (EVAL$ T
                          (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                          A)
                   (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                               (EVAL$ T
                                      (LIST 'PLUS (CAR X) (CADR X))
                                      A)))),

    which again simplifies, appealing to the lemmas REWRITE-EVAL$, CAR-CONS,
    and CDR-CONS, to:

          (IMPLIES
            (AND (LISTP X)
                 (MEMBER (CAR X) Y)
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (PLUS-TREE (CDR X)) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X))))
            (EQUAL (EVAL$ T
                          (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                          A)
                   (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                               (PLUS (EVAL$ T (CAR X) A)
                                     (EVAL$ T (CADR X) A))))).

    However this further simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
    and PLUS-RIGHT-ID2, and opening up the definitions of PLUS-TREE and FIX,
    to the following three new conjectures:

    Case 4.1.3.
            (IMPLIES
             (AND
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    0))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X)))
                 (NOT (NUMBERP (EVAL$ T (CAR X) A))))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                0))).

      This again simplifies, using linear arithmetic, applying the lemmas
      NUMBERP-EVAL$-PLUS-TREE and DIFFERENCE-0, and opening up the functions
      DIFFERENCE and EQUAL, to:

            T.

    Case 4.1.2.
            (IMPLIES
             (AND
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    0))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X)))
                 (NUMBERP (EVAL$ T (CAR X) A)))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T (CAR X) A)))),

      which again simplifies, using linear arithmetic, to three new goals:

      Case 4.1.2.3.
              (IMPLIES
               (AND
                 (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (CAR X) A))
                        0)
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    0))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X)))
                 (NUMBERP (EVAL$ T (CAR X) A)))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CAR X) A)))),

        which again simplifies, using linear arithmetic and rewriting with
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 4.1.2.2.
              (IMPLIES
               (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (EVAL$ T (CAR X) A))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    0))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X)))
                 (NUMBERP (EVAL$ T (CAR X) A)))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CAR X) A)))).

        However this again simplifies, using linear arithmetic and applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 4.1.2.1.
              (IMPLIES
               (AND
                (NOT
                 (NUMBERP
                        (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)))
                (LISTP X)
                (MEMBER (CAR X) Y)
                (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                (EQUAL (EVAL$ T
                              (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                              A)
                       (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                               (EVAL$ T (CAR X) A))
                                   0))
                (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                (LISTP (CDR X))
                (NOT (LISTP (CDDR X)))
                (NUMBERP (EVAL$ T (CAR X) A)))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CAR X) A)))).

        This again simplifies, clearly, to:

              T.

    Case 4.1.1.
            (IMPLIES
             (AND
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NUMBERP (EVAL$ T (CADR X) A))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X))))
             (EQUAL (EVAL$ T
                           (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                           A)
                    (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                (PLUS (EVAL$ T (CAR X) A)
                                      (EVAL$ T (CADR X) A))))).

      But this again simplifies, using linear arithmetic, to four new formulas:

      Case 4.1.1.4.
              (IMPLIES
               (AND
                 (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (CAR X) A))
                        (EVAL$ T (CADR X) A))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NUMBERP (EVAL$ T (CADR X) A))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X))))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (PLUS (EVAL$ T (CAR X) A)
                                        (EVAL$ T (CADR X) A))))),

        which again simplifies, using linear arithmetic, appealing to the
        lemma DIFFERENCE-0, and opening up EQUAL, to:

              (IMPLIES
               (AND
                 (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (CAR X) A))
                        (EVAL$ T (CADR X) A))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NUMBERP (EVAL$ T (CADR X) A))
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (EVAL$ T (CAR X) A))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X))))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      0)).

        But this finally simplifies, using linear arithmetic and rewriting
        with the lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 4.1.1.3.
              (IMPLIES
               (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (EVAL$ T (CAR X) A))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NUMBERP (EVAL$ T (CADR X) A))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X))))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (PLUS (EVAL$ T (CAR X) A)
                                        (EVAL$ T (CADR X) A))))),

        which again simplifies, using linear arithmetic and applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

              T.

      Case 4.1.1.2.
              (IMPLIES
               (AND
                (NOT
                 (NUMBERP
                        (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)))
                (LISTP X)
                (MEMBER (CAR X) Y)
                (NUMBERP (EVAL$ T (CADR X) A))
                (EQUAL (EVAL$ T
                              (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                              A)
                       (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                               (EVAL$ T (CAR X) A))
                                   (EVAL$ T (CADR X) A)))
                (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                (LISTP (CDR X))
                (NOT (LISTP (CDDR X))))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (PLUS (EVAL$ T (CAR X) A)
                                        (EVAL$ T (CADR X) A))))).

        This again simplifies, obviously, to:

              T.

      Case 4.1.1.1.
              (IMPLIES
               (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (PLUS (EVAL$ T (CAR X) A)
                              (EVAL$ T (CADR X) A)))
                 (LISTP X)
                 (MEMBER (CAR X) Y)
                 (NUMBERP (EVAL$ T (CADR X) A))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                 (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                 (LISTP (CDR X))
                 (NOT (LISTP (CDDR X))))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                  (PLUS (EVAL$ T (CAR X) A)
                                        (EVAL$ T (CADR X) A))))).

        But this again simplifies, using linear arithmetic, to two new goals:

        Case 4.1.1.1.2.
                (IMPLIES
                 (AND
                  (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (CAR X) A))
                         (EVAL$ T (CADR X) A))
                  (LESSP (EVAL$ T (PLUS-TREE Y) A)
                         (PLUS (EVAL$ T (CAR X) A)
                               (EVAL$ T (CADR X) A)))
                  (LISTP X)
                  (MEMBER (CAR X) Y)
                  (NUMBERP (EVAL$ T (CADR X) A))
                  (EQUAL
                        (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                  (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                  (LISTP (CDR X))
                  (NOT (LISTP (CDDR X))))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (EVAL$ T (CAR X) A)
                                          (EVAL$ T (CADR X) A))))),

          which again simplifies, using linear arithmetic, rewriting with
          DIFFERENCE-0, and unfolding EQUAL, to:

                (IMPLIES
                 (AND
                  (LESSP (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (CAR X) A))
                         (EVAL$ T (CADR X) A))
                  (LESSP (EVAL$ T (PLUS-TREE Y) A)
                         (PLUS (EVAL$ T (CAR X) A)
                               (EVAL$ T (CADR X) A)))
                  (LISTP X)
                  (MEMBER (CAR X) Y)
                  (NUMBERP (EVAL$ T (CADR X) A))
                  (LESSP (EVAL$ T (PLUS-TREE Y) A)
                         (EVAL$ T (CAR X) A))
                  (EQUAL
                        (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                  (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                  (LISTP (CDR X))
                  (NOT (LISTP (CDDR X))))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        0)),

          which finally simplifies, using linear arithmetic and applying
          MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

                T.

        Case 4.1.1.1.1.
                (IMPLIES
                 (AND
                  (LESSP (EVAL$ T (PLUS-TREE Y) A)
                         (EVAL$ T (CAR X) A))
                  (LESSP (EVAL$ T (PLUS-TREE Y) A)
                         (PLUS (EVAL$ T (CAR X) A)
                               (EVAL$ T (CADR X) A)))
                  (LISTP X)
                  (MEMBER (CAR X) Y)
                  (NUMBERP (EVAL$ T (CADR X) A))
                  (EQUAL
                        (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                                (EVAL$ T (CAR X) A))
                                    (EVAL$ T (CADR X) A)))
                  (SUBBAGP (CDR X) (DELETE (CAR X) Y))
                  (LISTP (CDR X))
                  (NOT (LISTP (CDDR X))))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (EVAL$ T (CAR X) A)
                                          (EVAL$ T (CADR X) A))))).

          However this finally simplifies, using linear arithmetic and
          applying the lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to:

                T.

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) Y))
                      (NOT (SUBBAGP (CDR X) Y))
                      (SUBBAGP X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (BAGDIFF Y X)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (PLUS-TREE X) A)))),

  which simplifies, expanding SUBBAGP, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) Y))
                      (EQUAL (EVAL$ T
                                    (PLUS-TREE (BAGDIFF Y (CDR X)))
                                    A)
                             (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                         (EVAL$ T (PLUS-TREE (CDR X)) A)))
                      (SUBBAGP X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (BAGDIFF Y X)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (PLUS-TREE X) A)))),

  which simplifies, opening up SUBBAGP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (SUBBAGP X Y))
                 (EQUAL (EVAL$ T (PLUS-TREE (BAGDIFF Y X)) A)
                        (DIFFERENCE (EVAL$ T (PLUS-TREE Y) A)
                                    (EVAL$ T (PLUS-TREE X) A)))),

  which simplifies, rewriting with SUBBAGP-CDR2 and NUMBERP-EVAL$-PLUS-TREE,
  and expanding the functions SUBBAGP, BAGDIFF, PLUS-TREE, CDR, CAR, LISTP,
  LITATOM, EQUAL, EVAL$, and DIFFERENCE, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.7 0.1 ]

PLUS-TREE-BAGDIFF


(PROVE-LEMMA NUMBERP-EVAL$-BRIDGE
             (REWRITE)
             (IMPLIES (EQUAL (EVAL$ T Z A)
                             (EVAL$ T (PLUS-TREE X) A))
                      (NUMBERP (EVAL$ T Z A))))

WARNING:  Note that NUMBERP-EVAL$-BRIDGE contains the free variable X which
will be chosen by instantiating the hypothesis:
      (EQUAL (EVAL$ T Z A)
             (EVAL$ T (PLUS-TREE X) A)).



.

We use the above equality hypothesis by substituting (EVAL$ T (PLUS-TREE X) A)
for (EVAL$ T Z A) and keeping the equality hypothesis.  This produces the new
goal:

      (IMPLIES (EQUAL (EVAL$ T Z A)
                      (EVAL$ T (PLUS-TREE X) A))
               (NUMBERP (EVAL$ T (PLUS-TREE X) A))),

which simplifies, trivially, to:

      (IMPLIES (EQUAL (EVAL$ T Z A)
                      (EVAL$ T (PLUS-TREE X) A))
               (NUMBERP (EVAL$ T Z 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 (EQUAL (EVAL$ T Z A)
                (EVAL$ T (PLUS-TREE X) A))
         (NUMBERP (EVAL$ T Z A))),

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.  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 (LITATOM Z) (p Z A X))
           (IMPLIES (AND (NOT (LITATOM Z)) (NLISTP Z))
                    (p Z A X))
           (IMPLIES (AND (NOT (LITATOM Z))
                         (NOT (NLISTP Z))
                         (EQUAL (CAR Z) 'QUOTE))
                    (p Z A X))
           (IMPLIES (AND (NOT (LITATOM Z))
                         (NOT (NLISTP Z))
                         (NOT (EQUAL (CAR Z) 'QUOTE))
                         (p (CDR Z) A X))
                    (p Z A X))).
Linear arithmetic, the lemmas CDR-LESSEQP, CDR-LESSP, CAR-LESSEQP, and
CAR-LESSP, and the definition of NLISTP inform us that the measure (COUNT Z)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces five new conjectures:

Case 5. (IMPLIES (AND (LITATOM Z)
                      (EQUAL (EVAL$ T Z A)
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (EVAL$ T Z A))),

  which simplifies, unfolding the functions EVAL$ and EQUAL, to:

        (IMPLIES (AND (LITATOM Z)
                      (EQUAL (CDR (ASSOC Z A))
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (CDR (ASSOC Z A)))).

  We use the above equality hypothesis by substituting:
        (EVAL$ T (PLUS-TREE X) A)
  for (CDR (ASSOC Z A)) and throwing away the equality.  We thus obtain:

        (IMPLIES (LITATOM Z)
                 (NUMBERP (EVAL$ T (PLUS-TREE X) A))),

  which further simplifies, rewriting with the lemma NUMBERP-EVAL$-PLUS-TREE,
  to:

        T.

Case 4. (IMPLIES (AND (NOT (LITATOM Z))
                      (NLISTP Z)
                      (EQUAL (EVAL$ T Z A)
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (EVAL$ T Z A))),

  which simplifies, opening up NLISTP, EVAL$, and EQUAL, to:

        (IMPLIES (AND (NOT (LITATOM Z))
                      (NOT (LISTP Z))
                      (EQUAL Z (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP Z)).

  But this again simplifies, applying NUMBERP-EVAL$-PLUS-TREE, to:

        T.

Case 3. (IMPLIES (AND (NOT (LITATOM Z))
                      (NOT (NLISTP Z))
                      (EQUAL (CAR Z) 'QUOTE)
                      (EQUAL (EVAL$ T Z A)
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (EVAL$ T Z A))).

  This simplifies, expanding the functions NLISTP, EVAL$, and EQUAL, to the
  new formula:

        (IMPLIES (AND (NOT (LITATOM Z))
                      (LISTP Z)
                      (EQUAL (CAR Z) 'QUOTE)
                      (EQUAL (CADR Z)
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (CADR Z))),

  which again simplifies, obviously, to:

        (IMPLIES (AND (LISTP Z)
                      (EQUAL (CAR Z) 'QUOTE)
                      (EQUAL (CADR Z)
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (CADR Z))).

  Applying the lemma CAR-CDR-ELIM, replace Z by (CONS V W) to eliminate
  (CAR Z) and (CDR Z) and W by (CONS D C) to eliminate (CAR W) and (CDR W).
  This produces the following two new conjectures:

  Case 3.2.
          (IMPLIES (AND (NOT (LISTP W))
                        (EQUAL V 'QUOTE)
                        (EQUAL (CAR W)
                               (EVAL$ T (PLUS-TREE X) A)))
                   (NUMBERP (CAR W))).

    But this further simplifies, rewriting with CAR-NLISTP, and unfolding the
    definition of NUMBERP, to:

          T.

  Case 3.1.
          (IMPLIES (AND (EQUAL V 'QUOTE)
                        (EQUAL D (EVAL$ T (PLUS-TREE X) A)))
                   (NUMBERP D)).

    However this further simplifies, applying NUMBERP-EVAL$-PLUS-TREE, to:

          T.

Case 2. (IMPLIES (AND (NOT (LITATOM Z))
                      (NOT (NLISTP Z))
                      (NOT (EQUAL (CAR Z) 'QUOTE))
                      (NOT (EQUAL (EVAL$ T (CDR Z) A)
                                  (EVAL$ T (PLUS-TREE X) A)))
                      (EQUAL (EVAL$ T Z A)
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (EVAL$ T Z A))).

  This simplifies, applying the lemma NUMBERP-EVAL$-PLUS-TREE, and opening up
  NLISTP, EVAL$, and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (LITATOM Z))
                      (NOT (NLISTP Z))
                      (NOT (EQUAL (CAR Z) 'QUOTE))
                      (NUMBERP (EVAL$ T (CDR Z) A))
                      (EQUAL (EVAL$ T Z A)
                             (EVAL$ T (PLUS-TREE X) A)))
                 (NUMBERP (EVAL$ T Z A))).

  This simplifies, applying the lemma NUMBERP-EVAL$-PLUS-TREE, and expanding
  the definitions of NLISTP, EVAL$, and EQUAL, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

NUMBERP-EVAL$-BRIDGE


(PROVE-LEMMA BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP
             (REWRITE)
             (IMPLIES (AND (SUBBAGP Y (PLUS-FRINGE Z))
                           (EQUAL (EVAL$ T Z A)
                                  (EVAL$ T
                                         (PLUS-TREE (PLUS-FRINGE Z))
                                         A)))
                      (EQUAL (LESSP (EVAL$ T Z A)
                                    (EVAL$ T (PLUS-TREE Y) A))
                             F)))

This conjecture simplifies, using linear arithmetic and applying
SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP


(PROVE-LEMMA EVAL$-PLUS-TREE-APPEND
             (REWRITE)
             (EQUAL (EVAL$ T (PLUS-TREE (APPEND X Y)) A)
                    (PLUS (EVAL$ T (PLUS-TREE X) A)
                          (EVAL$ T (PLUS-TREE Y) A))))


     Name the conjecture *1.


     We will appeal to induction.  The recursive terms in the conjecture
suggest three inductions.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP X) (p (CDR X) Y A))
                    (p X Y A))
           (IMPLIES (NOT (LISTP X)) (p X Y A))).
Linear arithmetic and the lemma CDR-LESSP establish 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 two new
conjectures:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (EVAL$ T
                                    (PLUS-TREE (APPEND (CDR X) Y))
                                    A)
                             (PLUS (EVAL$ T (PLUS-TREE (CDR X)) A)
                                   (EVAL$ T (PLUS-TREE Y) A))))
                 (EQUAL (EVAL$ T (PLUS-TREE (APPEND X Y)) A)
                        (PLUS (EVAL$ T (PLUS-TREE X) A)
                              (EVAL$ T (PLUS-TREE Y) A)))).

  This simplifies, rewriting with COMMUTATIVITY-OF-PLUS, CAR-CONS, and
  CDR-CONS, and expanding APPEND and PLUS-TREE, to nine new formulas:

  Case 2.9.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (APPEND (CDR X) Y))))
                   (EQUAL (EVAL$ T (LIST 'FIX (CAR X)) A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T (LIST 'FIX (CAR X)) A)))),

    which again simplifies, appealing to the lemmas NUMBERP-EVAL$-PLUS-TREE,
    PLUS-EQUAL-0, REWRITE-EVAL$, and CAR-CONS, and expanding the definitions
    of PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, FIX, and PLUS, to:

          T.

  Case 2.8.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (NOT (LISTP (CDR X)))
                        (LISTP (APPEND (CDR X) Y))
                        (LISTP (CDR (APPEND (CDR X) Y))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR X)
                                       (PLUS-TREE (APPEND (CDR X) Y)))
                                 A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T (LIST 'FIX (CAR X)) A)))),

    which again simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS,
    and expanding the definition of FIX, to the following two new goals:

    Case 2.8.2.
            (IMPLIES (AND (LISTP X)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (APPEND (CDR X) Y))
                                        A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (LISTP (CDR (APPEND (CDR X) Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (EQUAL (PLUS (EVAL$ T (CAR X) A)
                                  (EVAL$ T
                                         (PLUS-TREE (APPEND (CDR X) Y))
                                         A))
                            (PLUS (EVAL$ T (PLUS-TREE Y) A) 0))).

      This again simplifies, applying NUMBERP-EVAL$-PLUS-TREE and
      COMMUTATIVITY-OF-PLUS, and opening up PLUS and EQUAL, to:

            (IMPLIES (AND (LISTP X)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (APPEND (CDR X) Y))
                                        A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (LISTP (CDR (APPEND (CDR X) Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (EQUAL (EVAL$ T
                                   (PLUS-TREE (APPEND (CDR X) Y))
                                   A)
                            (EVAL$ T (PLUS-TREE Y) A))),

      which further simplifies, appealing to the lemmas
      NUMBERP-EVAL$-PLUS-TREE and COMMUTATIVITY-OF-PLUS, and expanding APPEND,
      PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and PLUS, to:

            T.

    Case 2.8.1.
            (IMPLIES (AND (LISTP X)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (APPEND (CDR X) Y))
                                        A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (LISTP (CDR (APPEND (CDR X) Y)))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (PLUS (EVAL$ T (CAR X) A)
                                  (EVAL$ T
                                         (PLUS-TREE (APPEND (CDR X) Y))
                                         A))
                            (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CAR X) A)))),

      which again simplifies, applying COMMUTATIVITY-OF-PLUS,
      NUMBERP-EVAL$-PLUS-TREE, and PLUS-CANCELLATION, to the new formula:

            (IMPLIES (AND (LISTP X)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (APPEND (CDR X) Y))
                                        A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (LISTP (CDR (APPEND (CDR X) Y)))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (EVAL$ T
                                   (PLUS-TREE (APPEND (CDR X) Y))
                                   A)
                            (EVAL$ T (PLUS-TREE Y) A))),

      which further simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE and
      COMMUTATIVITY-OF-PLUS, and unfolding APPEND, PLUS-TREE, CDR, CAR, LISTP,
      LITATOM, EQUAL, EVAL$, and PLUS, to:

            T.

  Case 2.7.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (NOT (LISTP (CDR X)))
                        (LISTP (APPEND (CDR X) Y))
                        (NOT (LISTP (CDR (APPEND (CDR X) Y)))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR X)
                                       (CAR (APPEND (CDR X) Y)))
                                 A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T (LIST 'FIX (CAR X)) A)))).

    However this again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
    CDR-CONS, and PLUS-RIGHT-ID2, and opening up the definitions of PLUS-TREE
    and FIX, to the following four new formulas:

    Case 2.7.4.
            (IMPLIES (AND (LISTP X)
                          (NOT (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A)))
                          (EQUAL 0
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (EQUAL 0
                            (PLUS (EVAL$ T (PLUS-TREE Y) A) 0))).

      However this again simplifies, using linear arithmetic, to:

            T.

    Case 2.7.3.
            (IMPLIES (AND (LISTP X)
                          (NOT (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A)))
                          (EQUAL 0
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (EVAL$ T (CAR X) A)
                            (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CAR X) A)))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 2.7.2.
            (IMPLIES (AND (LISTP X)
                          (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A))
                          (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (EQUAL (PLUS (EVAL$ T (CAR X) A)
                                  (EVAL$ T (CAR (APPEND (CDR X) Y)) A))
                            (PLUS (EVAL$ T (PLUS-TREE Y) A) 0))),

      which again simplifies, appealing to the lemmas NUMBERP-EVAL$-PLUS-TREE
      and COMMUTATIVITY-OF-PLUS, and expanding the functions PLUS and EQUAL,
      to the goal:

            (IMPLIES (AND (LISTP X)
                          (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                            (EVAL$ T (PLUS-TREE Y) A))).

      This further simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE,
      COMMUTATIVITY-OF-PLUS, REWRITE-EVAL$, CAR-CONS, and NUMBERP-EVAL$-BRIDGE,
      and opening up APPEND, PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$,
      PLUS, and FIX, to:

            T.

    Case 2.7.1.
            (IMPLIES (AND (LISTP X)
                          (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A))
                          (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (PLUS (EVAL$ T (CAR X) A)
                                  (EVAL$ T (CAR (APPEND (CDR X) Y)) A))
                            (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CAR X) A)))).

      However this again simplifies, appealing to the lemmas
      COMMUTATIVITY-OF-PLUS, NUMBERP-EVAL$-PLUS-TREE, and PLUS-CANCELLATION,
      to:

            (IMPLIES (AND (LISTP X)
                          (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (NOT (LISTP (CDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                            (EVAL$ T (PLUS-TREE Y) A))).

      But this further simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE,
      COMMUTATIVITY-OF-PLUS, REWRITE-EVAL$, CAR-CONS, and NUMBERP-EVAL$-BRIDGE,
      and opening up the functions APPEND, PLUS-TREE, CDR, CAR, LISTP, LITATOM,
      EQUAL, EVAL$, PLUS, and FIX, to:

            T.

  Case 2.6.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (NOT (LISTP (APPEND (CDR X) Y))))
                   (EQUAL (EVAL$ T (LIST 'FIX (CAR X)) A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T
                                       (LIST 'PLUS
                                             (CAR X)
                                             (PLUS-TREE (CDR X)))
                                       A)))).

    However this again simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE,
    PLUS-EQUAL-0, REWRITE-EVAL$, CAR-CONS, CDR-CONS, and COMMUTATIVITY-OF-PLUS,
    and expanding PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, FIX, and
    PLUS, to:

          T.

  Case 2.5.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (LISTP (APPEND (CDR X) Y))
                        (LISTP (CDR (APPEND (CDR X) Y))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR X)
                                       (PLUS-TREE (APPEND (CDR X) Y)))
                                 A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T
                                       (LIST 'PLUS
                                             (CAR X)
                                             (PLUS-TREE (CDR X)))
                                       A)))).

    However this again simplifies, rewriting with the lemmas REWRITE-EVAL$,
    CAR-CONS, CDR-CONS, and COMMUTATIVITY2-OF-PLUS, to:

          T.

  Case 2.4.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (LISTP (APPEND (CDR X) Y))
                        (NOT (LISTP (CDR (APPEND (CDR X) Y)))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR X)
                                       (CAR (APPEND (CDR X) Y)))
                                 A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T
                                       (LIST 'PLUS
                                             (CAR X)
                                             (PLUS-TREE (CDR X)))
                                       A)))),

    which again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, CDR-CONS,
    PLUS-RIGHT-ID2, COMMUTATIVITY-OF-PLUS, and COMMUTATIVITY2-OF-PLUS, and
    expanding the definitions of PLUS-TREE, FIX, EQUAL, and PLUS, to:

          T.

  Case 2.3.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (LISTP (CDR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (APPEND (CDR X) Y))))
                   (EQUAL (EVAL$ T (LIST 'FIX (CAR X)) A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T
                                       (LIST 'PLUS (CAR X) (CADR X))
                                       A)))).

    This again simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE,
    PLUS-EQUAL-0, REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and opening up
    PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and FIX, to the
    following two new goals:

    Case 2.3.2.
            (IMPLIES (AND (LISTP X)
                          (EQUAL 0 (EVAL$ T (PLUS-TREE Y) A))
                          (EQUAL 0
                                 (EVAL$ T (PLUS-TREE (CDR X)) A))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (NOT (LISTP (APPEND (CDR X) Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (EQUAL 0
                            (PLUS 0
                                  (EVAL$ T (CAR X) A)
                                  (EVAL$ T (CADR X) A)))).

      However this again simplifies, expanding PLUS and EQUAL, to:

            (IMPLIES (AND (LISTP X)
                          (EQUAL 0 (EVAL$ T (PLUS-TREE Y) A))
                          (EQUAL 0
                                 (EVAL$ T (PLUS-TREE (CDR X)) A))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (NOT (LISTP (APPEND (CDR X) Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A)))
                          (NUMBERP (EVAL$ T (CADR X) A)))
                     (EQUAL 0 (EVAL$ T (CADR X) A))).

      However this further simplifies, appealing to the lemmas REWRITE-EVAL$
      and CAR-CONS, and expanding the functions PLUS-TREE and FIX, to:

            T.

    Case 2.3.1.
            (IMPLIES (AND (LISTP X)
                          (EQUAL 0 (EVAL$ T (PLUS-TREE Y) A))
                          (EQUAL 0
                                 (EVAL$ T (PLUS-TREE (CDR X)) A))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (NOT (LISTP (APPEND (CDR X) Y)))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (EVAL$ T (CAR X) A)
                            (PLUS 0
                                  (EVAL$ T (CAR X) A)
                                  (EVAL$ T (CADR X) A)))),

      which again simplifies, unfolding EQUAL and PLUS, to:

            (IMPLIES (AND (LISTP X)
                          (EQUAL 0 (EVAL$ T (PLUS-TREE Y) A))
                          (EQUAL 0
                                 (EVAL$ T (PLUS-TREE (CDR X)) A))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (NOT (LISTP (APPEND (CDR X) Y)))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (EVAL$ T (CAR X) A)
                            (PLUS (EVAL$ T (CAR X) A)
                                  (EVAL$ T (CADR X) A)))).

      However this further simplifies, applying REWRITE-EVAL$, CAR-CONS,
      COMMUTATIVITY-OF-PLUS, and PLUS-RIGHT-ID2, and unfolding the functions
      PLUS-TREE, FIX, EQUAL, and PLUS, to:

            T.

  Case 2.2.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (LISTP (CDR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP (APPEND (CDR X) Y))
                        (LISTP (CDR (APPEND (CDR X) Y))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR X)
                                       (PLUS-TREE (APPEND (CDR X) Y)))
                                 A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T
                                       (LIST 'PLUS (CAR X) (CADR X))
                                       A)))).

    But this again simplifies, applying the lemmas REWRITE-EVAL$, CAR-CONS,
    CDR-CONS, COMMUTATIVITY2-OF-PLUS, and PLUS-CANCELLATION, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (LISTP (CDR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP (APPEND (CDR X) Y))
                        (LISTP (CDR (APPEND (CDR X) Y))))
                   (EQUAL (EVAL$ T
                                 (PLUS-TREE (APPEND (CDR X) Y))
                                 A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T (CADR X) A)))).

    This further simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
    NUMBERP-EVAL$-PLUS-TREE, COMMUTATIVITY-OF-PLUS, and PLUS-RIGHT-ID2, and
    expanding PLUS-TREE, FIX, EQUAL, and PLUS, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (APPEND (CDR X) Y))
                                      A)
                               (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                     (EVAL$ T (PLUS-TREE (CDR X)) A)))
                        (LISTP (CDR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP (APPEND (CDR X) Y))
                        (NOT (LISTP (CDR (APPEND (CDR X) Y)))))
                   (EQUAL (EVAL$ T
                                 (LIST 'PLUS
                                       (CAR X)
                                       (CAR (APPEND (CDR X) Y)))
                                 A)
                          (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                (EVAL$ T
                                       (LIST 'PLUS (CAR X) (CADR X))
                                       A)))).

    But this again simplifies, rewriting with the lemmas REWRITE-EVAL$,
    CAR-CONS, CDR-CONS, PLUS-RIGHT-ID2, COMMUTATIVITY2-OF-PLUS, and
    PLUS-CANCELLATION, and expanding PLUS-TREE and FIX, to three new formulas:

    Case 2.1.3.
            (IMPLIES (AND (LISTP X)
                          (NOT (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A)))
                          (EQUAL 0
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A))))
                     (EQUAL 0
                            (PLUS (EVAL$ T (CAR X) A)
                                  (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CADR X) A)))),

      which again simplifies, applying NUMBERP-EVAL$-PLUS-TREE and
      PLUS-EQUAL-0, and unfolding the functions EQUAL and PLUS, to:

            (IMPLIES (AND (LISTP X)
                          (NOT (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE Y) A))
                          (EQUAL 0
                                 (EVAL$ T (PLUS-TREE (CDR X)) A))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NOT (NUMBERP (EVAL$ T (CAR X) A)))
                          (NUMBERP (EVAL$ T (CADR X) A)))
                     (EQUAL 0 (EVAL$ T (CADR X) A))),

      which further simplifies, applying the lemmas REWRITE-EVAL$ and CAR-CONS,
      and opening up the definitions of PLUS-TREE and FIX, to:

            T.

    Case 2.1.2.
            (IMPLIES (AND (LISTP X)
                          (NOT (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A)))
                          (EQUAL 0
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                          (NUMBERP (EVAL$ T (CAR X) A)))
                     (EQUAL (EVAL$ T (CAR X) A)
                            (PLUS (EVAL$ T (CAR X) A)
                                  (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CADR X) A)))),

      which again simplifies, applying the lemmas NUMBERP-EVAL$-PLUS-TREE and
      PLUS-EQUAL-0, and expanding EQUAL and PLUS, to two new conjectures:

      Case 2.1.2.2.
              (IMPLIES
                      (AND (LISTP X)
                           (NOT (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A)))
                           (EQUAL 0 (EVAL$ T (PLUS-TREE Y) A))
                           (EQUAL 0
                                  (EVAL$ T (PLUS-TREE (CDR X)) A))
                           (LISTP (CDR X))
                           (NOT (LISTP (CDDR X)))
                           (LISTP (APPEND (CDR X) Y))
                           (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                           (NUMBERP (EVAL$ T (CAR X) A))
                           (NOT (NUMBERP (EVAL$ T (CADR X) A))))
                      (EQUAL (EVAL$ T (CAR X) A)
                             (PLUS (EVAL$ T (CAR X) A) 0))),

        which again simplifies, using linear arithmetic, to:

              T.

      Case 2.1.2.1.
              (IMPLIES
                      (AND (LISTP X)
                           (NOT (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A)))
                           (EQUAL 0 (EVAL$ T (PLUS-TREE Y) A))
                           (EQUAL 0
                                  (EVAL$ T (PLUS-TREE (CDR X)) A))
                           (LISTP (CDR X))
                           (NOT (LISTP (CDDR X)))
                           (LISTP (APPEND (CDR X) Y))
                           (NOT (LISTP (CDR (APPEND (CDR X) Y))))
                           (NUMBERP (EVAL$ T (CAR X) A))
                           (NUMBERP (EVAL$ T (CADR X) A)))
                      (EQUAL (EVAL$ T (CAR X) A)
                             (PLUS (EVAL$ T (CAR X) A)
                                   (EVAL$ T (CADR X) A)))),

        which further simplifies, appealing to the lemmas REWRITE-EVAL$,
        CAR-CONS, and COMMUTATIVITY-OF-PLUS, and expanding PLUS-TREE, FIX,
        NUMBERP, EQUAL, and PLUS, to:

              T.

    Case 2.1.1.
            (IMPLIES (AND (LISTP X)
                          (NUMBERP (EVAL$ T (CAR (APPEND (CDR X) Y)) A))
                          (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y)))))
                     (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                            (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CADR X) A)))),

      which again simplifies, clearly, to:

            (IMPLIES (AND (LISTP X)
                          (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                                 (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                       (EVAL$ T (PLUS-TREE (CDR X)) A)))
                          (LISTP (CDR X))
                          (NOT (LISTP (CDDR X)))
                          (LISTP (APPEND (CDR X) Y))
                          (NOT (LISTP (CDR (APPEND (CDR X) Y)))))
                     (EQUAL (EVAL$ T (CAR (APPEND (CDR X) Y)) A)
                            (PLUS (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T (CADR X) A)))),

      which further simplifies, appealing to the lemmas REWRITE-EVAL$,
      CAR-CONS, NUMBERP-EVAL$-PLUS-TREE, COMMUTATIVITY-OF-PLUS, and
      PLUS-RIGHT-ID2, and unfolding the definitions of PLUS-TREE, FIX, EQUAL,
      and PLUS, to:

            T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (EQUAL (EVAL$ T (PLUS-TREE (APPEND X Y)) A)
                        (PLUS (EVAL$ T (PLUS-TREE X) A)
                              (EVAL$ T (PLUS-TREE Y) A)))),

  which simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE, and unfolding the
  functions APPEND, PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and
  PLUS, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.4 0.0 ]

EVAL$-PLUS-TREE-APPEND


(PROVE-LEMMA PLUS-TREE-PLUS-FRINGE
             (REWRITE)
             (EQUAL (EVAL$ T
                           (PLUS-TREE (PLUS-FRINGE X))
                           A)
                    (FIX (EVAL$ T X A)))
             ((INDUCT (PLUS-FRINGE X))))

This formula can be simplified, using the abbreviations NOT, OR, and AND, to
the following two new conjectures:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (CAR X) 'PLUS)
                      (EQUAL (EVAL$ T
                                    (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                    A)
                             (FIX (EVAL$ T (CADDR X) A)))
                      (EQUAL (EVAL$ T
                                    (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                    A)
                             (FIX (EVAL$ T (CADR X) A))))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (PLUS-FRINGE X))
                               A)
                        (FIX (EVAL$ T X A)))).

  This simplifies, rewriting with EVAL$-PLUS-TREE-APPEND, NUMBERP-EVAL$-PLUS,
  and COMMUTATIVITY-OF-PLUS, and unfolding the definitions of FIX, EQUAL,
  PLUS-FRINGE, and PLUS, to four new goals:

  Case 2.4.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'PLUS)
                        (NOT (NUMBERP (EVAL$ T (CADDR X) A)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                      A)
                               0)
                        (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                      A)
                               0))
                   (EQUAL 0 (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS D W) to eliminate (CDR V) and (CAR V), and
    W by (CONS V C) to eliminate (CAR W) and (CDR W).  This produces the
    following three new goals:

    Case 2.4.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'PLUS)
                          (NOT (NUMBERP (EVAL$ T (CADR V) A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CADR V)))
                                        A)
                                 0)
                          (NOT (NUMBERP (EVAL$ T (CAR V) A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR V)))
                                        A)
                                 0))
                     (EQUAL 0 (EVAL$ T (CONS Z V) A))).

      However this further simplifies, rewriting with the lemma CDR-NLISTP,
      and opening up CAR, LISTP, LITATOM, EQUAL, EVAL$, and NUMBERP, to:

            T.

    Case 2.4.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'PLUS)
                          (NOT (NUMBERP (EVAL$ T (CAR W) A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR W)))
                                        A)
                                 0)
                          (NOT (NUMBERP (EVAL$ T D A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 0))
                     (EQUAL 0
                            (EVAL$ T (CONS Z (CONS D W)) A))),

      which further simplifies, applying CAR-NLISTP, and expanding the
      definitions of LISTP, LITATOM, EQUAL, EVAL$, and NUMBERP, to:

            T.

    Case 2.4.1.
            (IMPLIES (AND (EQUAL Z 'PLUS)
                          (NOT (NUMBERP (EVAL$ T V A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE V))
                                        A)
                                 0)
                          (NOT (NUMBERP (EVAL$ T D A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 0))
                     (EQUAL 0
                            (EVAL$ T
                                   (CONS Z (CONS D (CONS V C)))
                                   A))).

      This further simplifies, appealing to the lemmas REWRITE-EVAL$, CAR-CONS,
      CDR-CONS, and PLUS-RIGHT-ID2, and expanding the definition of EQUAL, to:

            T.

  Case 2.3.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'PLUS)
                        (NOT (NUMBERP (EVAL$ T (CADDR X) A)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                      A)
                               0)
                        (NUMBERP (EVAL$ T (CADR X) A))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                      A)
                               (EVAL$ T (CADR X) A)))
                   (EQUAL (EVAL$ T (CADR X) A)
                          (EVAL$ T X A))),

    which again simplifies, appealing to the lemma NUMBERP-EVAL$-BRIDGE, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'PLUS)
                        (NOT (NUMBERP (EVAL$ T (CADDR X) A)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                      A)
                               0)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                      A)
                               (EVAL$ T (CADR X) A)))
                   (EQUAL (EVAL$ T (CADR X) A)
                          (EVAL$ T X A))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS Z V) to
    eliminate (CAR X) and (CDR X), V by (CONS D W) to eliminate (CDR V) and
    (CAR V), and W by (CONS V C) to eliminate (CAR W) and (CDR W).  This
    generates three new formulas:

    Case 2.3.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'PLUS)
                          (NOT (NUMBERP (EVAL$ T (CADR V) A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CADR V)))
                                        A)
                                 0)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR V)))
                                        A)
                                 (EVAL$ T (CAR V) A)))
                     (EQUAL (EVAL$ T (CAR V) A)
                            (EVAL$ T (CONS Z V) A))),

      which further simplifies, rewriting with the lemma CDR-NLISTP, and
      unfolding CAR, LISTP, LITATOM, EQUAL, EVAL$, and NUMBERP, to:

            T.

    Case 2.3.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'PLUS)
                          (NOT (NUMBERP (EVAL$ T (CAR W) A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR W)))
                                        A)
                                 0)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 (EVAL$ T D A)))
                     (EQUAL (EVAL$ T D A)
                            (EVAL$ T (CONS Z (CONS D W)) A))),

      which further simplifies, rewriting with the lemma CAR-NLISTP, and
      opening up the functions LISTP, LITATOM, EQUAL, EVAL$, and NUMBERP, to:

            T.

    Case 2.3.1.
            (IMPLIES (AND (EQUAL Z 'PLUS)
                          (NOT (NUMBERP (EVAL$ T V A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE V))
                                        A)
                                 0)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 (EVAL$ T D A)))
                     (EQUAL (EVAL$ T D A)
                            (EVAL$ T
                                   (CONS Z (CONS D (CONS V C)))
                                   A))),

      which further simplifies, rewriting with the lemmas REWRITE-EVAL$,
      CAR-CONS, CDR-CONS, NUMBERP-EVAL$-BRIDGE, and PLUS-RIGHT-ID2, to:

            T.

  Case 2.2.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'PLUS)
                        (NUMBERP (EVAL$ T (CADDR X) A))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                      A)
                               (EVAL$ T (CADDR X) A))
                        (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                      A)
                               0))
                   (EQUAL (EVAL$ T (CADDR X) A)
                          (EVAL$ T X A))),

    which again simplifies, rewriting with NUMBERP-EVAL$-BRIDGE, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'PLUS)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                      A)
                               (EVAL$ T (CADDR X) A))
                        (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                      A)
                               0))
                   (EQUAL (EVAL$ T (CADDR X) A)
                          (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS D W) to eliminate (CDR V) and (CAR V), and
    W by (CONS V C) to eliminate (CAR W) and (CDR W).  We thus obtain the
    following three new formulas:

    Case 2.2.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'PLUS)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CADR V)))
                                        A)
                                 (EVAL$ T (CADR V) A))
                          (NOT (NUMBERP (EVAL$ T (CAR V) A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR V)))
                                        A)
                                 0))
                     (EQUAL (EVAL$ T (CADR V) A)
                            (EVAL$ T (CONS Z V) A))).

      However this further simplifies, rewriting with CDR-NLISTP,
      REWRITE-EVAL$, and CAR-NLISTP, and expanding CAR, PLUS-FRINGE, PLUS-TREE,
      LISTP, LITATOM, EQUAL, EVAL$, FIX, and NUMBERP, to:

            T.

    Case 2.2.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'PLUS)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR W)))
                                        A)
                                 (EVAL$ T (CAR W) A))
                          (NOT (NUMBERP (EVAL$ T D A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 0))
                     (EQUAL (EVAL$ T (CAR W) A)
                            (EVAL$ T (CONS Z (CONS D W)) A))).

      This further simplifies, applying CAR-NLISTP, REWRITE-EVAL$, CAR-CONS,
      CDR-CONS, PLUS-RIGHT-ID2, and COMMUTATIVITY-OF-PLUS, and expanding the
      functions PLUS-FRINGE, PLUS-TREE, CAR, LISTP, LITATOM, EQUAL, EVAL$, FIX,
      and NUMBERP, to:

            T.

    Case 2.2.1.
            (IMPLIES (AND (EQUAL Z 'PLUS)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE V))
                                        A)
                                 (EVAL$ T V A))
                          (NOT (NUMBERP (EVAL$ T D A)))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 0))
                     (EQUAL (EVAL$ T V A)
                            (EVAL$ T
                                   (CONS Z (CONS D (CONS V C)))
                                   A))).

      But this further simplifies, applying REWRITE-EVAL$, CAR-CONS, CDR-CONS,
      and NUMBERP-EVAL$-BRIDGE, and unfolding PLUS, to:

            T.

  Case 2.1.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'PLUS)
                        (NUMBERP (EVAL$ T (CADDR X) A))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                      A)
                               (EVAL$ T (CADDR X) A))
                        (NUMBERP (EVAL$ T (CADR X) A))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                      A)
                               (EVAL$ T (CADR X) A)))
                   (EQUAL (PLUS (EVAL$ T (CADR X) A)
                                (EVAL$ T (CADDR X) A))
                          (EVAL$ T X A))).

    But this again simplifies, rewriting with NUMBERP-EVAL$-BRIDGE, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'PLUS)
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADDR X)))
                                      A)
                               (EVAL$ T (CADDR X) A))
                        (EQUAL (EVAL$ T
                                      (PLUS-TREE (PLUS-FRINGE (CADR X)))
                                      A)
                               (EVAL$ T (CADR X) A)))
                   (EQUAL (PLUS (EVAL$ T (CADR X) A)
                                (EVAL$ T (CADDR X) A))
                          (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS D W) to eliminate (CDR V) and (CAR V), and
    W by (CONS V C) to eliminate (CAR W) and (CDR W).  We would thus like to
    prove the following three new conjectures:

    Case 2.1.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'PLUS)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CADR V)))
                                        A)
                                 (EVAL$ T (CADR V) A))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR V)))
                                        A)
                                 (EVAL$ T (CAR V) A)))
                     (EQUAL (PLUS (EVAL$ T (CAR V) A)
                                  (EVAL$ T (CADR V) A))
                            (EVAL$ T (CONS Z V) A))).

      But this further simplifies, applying CDR-NLISTP, REWRITE-EVAL$, and
      CAR-NLISTP, and opening up CAR, PLUS-FRINGE, PLUS-TREE, LISTP, LITATOM,
      EQUAL, EVAL$, FIX, and PLUS, to:

            T.

    Case 2.1.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'PLUS)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE (CAR W)))
                                        A)
                                 (EVAL$ T (CAR W) A))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 (EVAL$ T D A)))
                     (EQUAL (PLUS (EVAL$ T D A)
                                  (EVAL$ T (CAR W) A))
                            (EVAL$ T (CONS Z (CONS D W)) A))).

      However this further simplifies, rewriting with CAR-NLISTP,
      REWRITE-EVAL$, NUMBERP-EVAL$-BRIDGE, COMMUTATIVITY-OF-PLUS, CAR-CONS,
      and CDR-CONS, and opening up the definitions of PLUS-FRINGE, PLUS-TREE,
      CAR, LISTP, LITATOM, EQUAL, EVAL$, FIX, and PLUS, to:

            T.

    Case 2.1.1.
            (IMPLIES (AND (EQUAL Z 'PLUS)
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE V))
                                        A)
                                 (EVAL$ T V A))
                          (EQUAL (EVAL$ T
                                        (PLUS-TREE (PLUS-FRINGE D))
                                        A)
                                 (EVAL$ T D A)))
                     (EQUAL (PLUS (EVAL$ T D A) (EVAL$ T V A))
                            (EVAL$ T
                                   (CONS Z (CONS D (CONS V C)))
                                   A))).

      However this further simplifies, applying the lemmas REWRITE-EVAL$,
      CAR-CONS, and CDR-CONS, to:

            T.

Case 1. (IMPLIES (NOT (AND (LISTP X)
                           (EQUAL (CAR X) 'PLUS)))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (PLUS-FRINGE X))
                               A)
                        (FIX (EVAL$ T X A)))),

  which simplifies, applying CAR-CONS, CDR-CONS, and REWRITE-EVAL$, and
  unfolding the functions AND, PLUS-FRINGE, LISTP, PLUS-TREE, EQUAL, EVAL$,
  and FIX, to:

        T.

Q.E.D.


[ 0.0 0.2 0.0 ]

PLUS-TREE-PLUS-FRINGE


(PROVE-LEMMA MEMBER-IMPLIES-NUMBERP
             (REWRITE)
             (IMPLIES (AND (MEMBER C (PLUS-FRINGE X))
                           (NUMBERP (EVAL$ T C A)))
                      (NUMBERP (EVAL$ T X A)))
             ((INDUCT (PLUS-FRINGE X))))

WARNING:  Note that MEMBER-IMPLIES-NUMBERP contains the free variable C which
will be chosen by instantiating the hypothesis (MEMBER C (PLUS-FRINGE X)).


This formula can be simplified, using the abbreviations IMPLIES, NOT, OR, and
AND, to the following two new formulas:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (CAR X) 'PLUS)
                      (IMPLIES (AND (MEMBER C (PLUS-FRINGE (CADDR X)))
                                    (NUMBERP (EVAL$ T C A)))
                               (NUMBERP (EVAL$ T (CADDR X) A)))
                      (IMPLIES (AND (MEMBER C (PLUS-FRINGE (CADR X)))
                                    (NUMBERP (EVAL$ T C A)))
                               (NUMBERP (EVAL$ T (CADR X) A)))
                      (MEMBER C (PLUS-FRINGE X))
                      (NUMBERP (EVAL$ T C A)))
                 (NUMBERP (EVAL$ T X A))).

  This simplifies, applying NUMBERP-EVAL$-PLUS, and unfolding the definitions
  of AND, IMPLIES, EQUAL, and PLUS-FRINGE, to:

        T.

Case 1. (IMPLIES (AND (NOT (AND (LISTP X)
                                (EQUAL (CAR X) 'PLUS)))
                      (MEMBER C (PLUS-FRINGE X))
                      (NUMBERP (EVAL$ T C A)))
                 (NUMBERP (EVAL$ T X A))),

  which simplifies, rewriting with CDR-CONS and CAR-CONS, and opening up the
  definitions of AND, PLUS-FRINGE, MEMBER, LISTP, EQUAL, and EVAL$, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

MEMBER-IMPLIES-NUMBERP


(PROVE-LEMMA CADR-EVAL$-LIST
             (REWRITE)
             (AND (EQUAL (CAR (EVAL$ 'LIST X A))
                         (EVAL$ T (CAR X) A))
                  (EQUAL (CDR (EVAL$ 'LIST X A))
                         (IF (LISTP X)
                             (EVAL$ 'LIST (CDR X) A)
                             0))))

WARNING:  Note that the proposed lemma CADR-EVAL$-LIST is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and two replacement rules.


This formula can be simplified, using the abbreviation AND, to the following
two new conjectures:

Case 2. (EQUAL (CAR (EVAL$ 'LIST X A))
               (EVAL$ T (CAR X) A)).

  Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS Z V) to
  eliminate (CAR X) and (CDR X).  We must thus prove two new goals:

  Case 2.2.
          (IMPLIES (NOT (LISTP X))
                   (EQUAL (CAR (EVAL$ 'LIST X A))
                          (EVAL$ T (CAR X) A))),

    which simplifies, rewriting with CAR-NLISTP, and unfolding the functions
    EQUAL, EVAL$, CAR, LISTP, and LITATOM, to:

          T.

  Case 2.1.
          (EQUAL (CAR (EVAL$ 'LIST (CONS Z V) A))
                 (EVAL$ T Z A)).

    However this simplifies, applying CDR-CONS and CAR-CONS, and unfolding the
    definitions of EQUAL and EVAL$, to:

          T.

Case 1. (EQUAL (CDR (EVAL$ 'LIST X A))
               (IF (LISTP X)
                   (EVAL$ 'LIST (CDR X) A)
                   0)).

  This simplifies, trivially, to the following two new conjectures:

  Case 1.2.
          (IMPLIES (NOT (LISTP X))
                   (EQUAL (CDR (EVAL$ 'LIST X A)) 0)).

    However this again simplifies, unfolding the functions EQUAL, EVAL$, and
    CDR, to:

          T.

  Case 1.1.
          (IMPLIES (LISTP X)
                   (EQUAL (CDR (EVAL$ 'LIST X A))
                          (EVAL$ 'LIST (CDR X) A))).

    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:

          (EQUAL (CDR (EVAL$ 'LIST (CONS V Z) A))
                 (EVAL$ 'LIST Z A)),

    which further simplifies, appealing to the lemmas CDR-CONS and CAR-CONS,
    and expanding EQUAL and EVAL$, to:

          T.

Q.E.D.


[ 0.0 0.0 0.0 ]

CADR-EVAL$-LIST


(PROVE-LEMMA EVAL$-QUOTE
             (REWRITE)
             (EQUAL (EVAL$ T (CONS 'QUOTE ARGS) A)
                    (CAR ARGS)))

This conjecture simplifies, rewriting with CDR-CONS and CAR-CONS, and
unfolding EQUAL and EVAL$, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EVAL$-QUOTE


(PROVE-LEMMA LISTP-EVAL$
             (REWRITE)
             (EQUAL (LISTP (EVAL$ 'LIST X A))
                    (LISTP X)))


     Name the conjecture *1.


     We will appeal to induction.  There is only one plausible induction.  We
will induct according to the following scheme:
      (AND (IMPLIES (AND (EQUAL 'LIST 'LIST) (NLISTP X))
                    (p X A))
           (IMPLIES (AND (EQUAL 'LIST 'LIST)
                         (NOT (NLISTP X))
                         (p (CDR X) A)
                         (p (CAR X) A))
                    (p X A))
           (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                         (LITATOM X))
                    (p X A))
           (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                         (NOT (LITATOM X))
                         (NLISTP X))
                    (p X A))
           (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                         (NOT (LITATOM X))
                         (NOT (NLISTP X))
                         (EQUAL (CAR X) 'QUOTE))
                    (p X A))
           (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                         (NOT (LITATOM X))
                         (NOT (NLISTP X))
                         (NOT (EQUAL (CAR X) 'QUOTE))
                         (p (CDR X) A))
                    (p X A))).
Linear arithmetic, the lemmas CDR-LESSEQP, CDR-LESSP, CAR-LESSEQP, and
CAR-LESSP, and the definition of NLISTP 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 produces the following six new
formulas:

Case 6. (IMPLIES (AND (EQUAL 'LIST 'LIST) (NLISTP X))
                 (EQUAL (LISTP (EVAL$ 'LIST X A))
                        (LISTP X))).

  This simplifies, expanding the definitions of EQUAL, NLISTP, EVAL$, and
  LISTP, to:

        T.

Case 5. (IMPLIES (AND (EQUAL 'LIST 'LIST)
                      (NOT (NLISTP X))
                      (EQUAL (LISTP (EVAL$ 'LIST (CDR X) A))
                             (LISTP (CDR X)))
                      (EQUAL (LISTP (EVAL$ 'LIST (CAR X) A))
                             (LISTP (CAR X))))
                 (EQUAL (LISTP (EVAL$ 'LIST X A))
                        (LISTP X))).

  This simplifies, expanding the definitions of EQUAL, NLISTP, and EVAL$, to:

        T.

Case 4. (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                      (LITATOM X))
                 (EQUAL (LISTP (EVAL$ 'LIST X A))
                        (LISTP X))).

  This simplifies, trivially, to:

        T.

Case 3. (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                      (NOT (LITATOM X))
                      (NLISTP X))
                 (EQUAL (LISTP (EVAL$ 'LIST X A))
                        (LISTP X))).

  This simplifies, trivially, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                      (NOT (LITATOM X))
                      (NOT (NLISTP X))
                      (EQUAL (CAR X) 'QUOTE))
                 (EQUAL (LISTP (EVAL$ 'LIST X A))
                        (LISTP X))).

  This simplifies, obviously, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL 'LIST 'LIST))
                      (NOT (LITATOM X))
                      (NOT (NLISTP X))
                      (NOT (EQUAL (CAR X) 'QUOTE))
                      (EQUAL (LISTP (EVAL$ 'LIST (CDR X) A))
                             (LISTP (CDR X))))
                 (EQUAL (LISTP (EVAL$ 'LIST X A))
                        (LISTP X))).

  This simplifies, obviously, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

LISTP-EVAL$


(PROVE-LEMMA CORRECTNESS-OF-CANCEL
             ((META EQUAL))
             (EQUAL (EVAL$ T X A)
                    (EVAL$ T (CANCEL X) A))
             ((DISABLE EVAL$)))

This formula simplifies, opening up the function CANCEL, to the following five
new goals:

Case 5. (IMPLIES
         (AND (LISTP X)
              (EQUAL (CAR X) 'EQUAL)
              (NOT (EQUAL (CAADR X) 'PLUS))
              (LISTP (CADDR X))
              (EQUAL (CAADDR X) 'PLUS)
              (MEMBER (CADR X)
                      (PLUS-FRINGE (CADDR X))))
         (EQUAL
               (EVAL$ T X A)
               (EVAL$ T
                      (LIST 'IF
                            (LIST 'NUMBERP (CADR X))
                            (LIST 'EQUAL
                                  ''0
                                  (PLUS-TREE (DELETE (CADR X)
                                                     (PLUS-FRINGE (CADDR X)))))
                            (LIST 'QUOTE F))
                      A))).

  However this again simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
  CDR-CONS, EVAL$-QUOTE, MEMBER-IMPLIES-NUMBERP, PLUS-TREE-PLUS-FRINGE,
  PLUS-TREE-DELETE, and EQUAL-DIFFERENCE-0, and opening up CAR, to the
  following three new formulas:

  Case 5.3.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (EQUAL (CAADR X) 'PLUS))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (LESSP (EVAL$ T (CADR X) A)
                               (EVAL$ T (CADDR X) A)))
                   (EQUAL (EVAL$ T X A) F)).

    This again simplifies, clearly, to the new goal:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (EQUAL (CAADR X) 'PLUS))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (LESSP (EVAL$ T (CADR X) A)
                               (EVAL$ T (CADDR X) A)))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), W
    by (CONS V C) to eliminate (CAR W) and (CDR W), D by (CONS W X1) to
    eliminate (CAR D) and (CDR D), W by (CONS D Z1) to eliminate (CAR W) and
    (CDR W), D by (CONS V C) to eliminate (CAR D) and (CDR D), and V by
    (CONS D X1) to eliminate (CAR V) and (CDR V).  We would thus like to prove
    the following five new goals:

    Case 5.3.5.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAAR V) 'PLUS))
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (MEMBER (CAR V)
                                  (PLUS-FRINGE (CADR V)))
                          (LESSP (EVAL$ T (CAR V) A)
                                 (EVAL$ T (CADR V) A)))
                     (NOT (EVAL$ T (CONS Z V) A))).

      This further simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
      opening up the functions CAR, EQUAL, and LISTP, to:

            T.

    Case 5.3.4.
            (IMPLIES (AND (NOT (LISTP D))
                          (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CAR D)))
                          (LESSP (EVAL$ T W A)
                                 (EVAL$ T (CAR D) A)))
                     (NOT (EVAL$ T (CONS Z (CONS W D)) A))).

      But this further simplifies, appealing to the lemma CAR-NLISTP, and
      opening up the functions EQUAL and LISTP, to:

            T.

    Case 5.3.3.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (EQUAL D 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CONS D X1)))
                          (LESSP (EVAL$ T W A)
                                 (EVAL$ T (CONS D X1) A)))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS W (CONS (CONS D X1) C)))
                                 A))),

      which further simplifies, appealing to the lemmas CAR-NLISTP,
      REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and expanding EQUAL, to the goal:

            (IMPLIES (AND (NOT (LISTP W))
                          (MEMBER W
                                  (PLUS-FRINGE (CONS 'PLUS X1)))
                          (LESSP (EVAL$ T W A)
                                 (PLUS (EVAL$ T (CAR X1) A)
                                       (EVAL$ T (CADR X1) A))))
                     (NOT (EQUAL (EVAL$ T W A)
                                 (PLUS (EVAL$ T (CAR X1) A)
                                       (EVAL$ T (CADR X1) A))))).

      However this finally simplifies, using linear arithmetic, to:

            T.

    Case 5.3.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL V 'PLUS))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CAR D)))
                          (LESSP (EVAL$ T (CONS V C) A)
                                 (EVAL$ T (CAR D) A)))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) D))
                                 A))),

      which further simplifies, applying CAR-NLISTP, and opening up the
      definition of LISTP, to:

            T.

    Case 5.3.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (NOT (EQUAL V 'PLUS))
                          (EQUAL D 'PLUS)
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CONS D Z1)))
                          (LESSP (EVAL$ T (CONS V C) A)
                                 (EVAL$ T (CONS D Z1) A)))
                     (NOT (EVAL$ T
                                 (CONS Z
                                       (CONS (CONS V C)
                                             (CONS (CONS D Z1) X1)))
                                 A))).

      However this further simplifies, applying REWRITE-EVAL$, CAR-CONS, and
      CDR-CONS, to:

            (IMPLIES (AND (NOT (EQUAL V 'PLUS))
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CONS 'PLUS Z1)))
                          (LESSP (EVAL$ T (CONS V C) A)
                                 (PLUS (EVAL$ T (CAR Z1) A)
                                       (EVAL$ T (CADR Z1) A))))
                     (NOT (EQUAL (EVAL$ T (CONS V C) A)
                                 (PLUS (EVAL$ T (CAR Z1) A)
                                       (EVAL$ T (CADR Z1) A))))),

      which finally simplifies, using linear arithmetic, to:

            T.

  Case 5.2.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (EQUAL (CAADR X) 'PLUS))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (NOT (NUMBERP (EVAL$ T (CADR X) A))))
                   (EQUAL (EVAL$ T X A) F)),

    which again simplifies, trivially, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (EQUAL (CAADR X) 'PLUS))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (NOT (NUMBERP (EVAL$ T (CADR X) A))))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), W
    by (CONS V C) to eliminate (CAR W) and (CDR W), D by (CONS W X1) to
    eliminate (CAR D) and (CDR D), W by (CONS D Z1) to eliminate (CAR W) and
    (CDR W), D by (CONS V C) to eliminate (CAR D) and (CDR D), and V by
    (CONS D X1) to eliminate (CAR V) and (CDR V).  We thus obtain the
    following five new conjectures:

    Case 5.2.5.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAAR V) 'PLUS))
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (MEMBER (CAR V)
                                  (PLUS-FRINGE (CADR V)))
                          (NOT (NUMBERP (EVAL$ T (CAR V) A))))
                     (NOT (EVAL$ T (CONS Z V) A))).

      But this further simplifies, rewriting with CAR-NLISTP and CDR-NLISTP,
      and unfolding the definitions of CAR, EQUAL, and LISTP, to:

            T.

    Case 5.2.4.
            (IMPLIES (AND (NOT (LISTP D))
                          (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CAR D)))
                          (NOT (NUMBERP (EVAL$ T W A))))
                     (NOT (EVAL$ T (CONS Z (CONS W D)) A))).

      This further simplifies, applying CAR-NLISTP, and unfolding EQUAL and
      LISTP, to:

            T.

    Case 5.2.3.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (EQUAL D 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CONS D X1)))
                          (NOT (NUMBERP (EVAL$ T W A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS W (CONS (CONS D X1) C)))
                                 A))).

      However this further simplifies, rewriting with the lemmas CAR-NLISTP,
      REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and expanding the function EQUAL,
      to:

            T.

    Case 5.2.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL V 'PLUS))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CAR D)))
                          (NOT (NUMBERP (EVAL$ T (CONS V C) A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) D))
                                 A))),

      which further simplifies, applying CAR-NLISTP, and expanding the
      function LISTP, to:

            T.

    Case 5.2.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (NOT (EQUAL V 'PLUS))
                          (EQUAL D 'PLUS)
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CONS D Z1)))
                          (NOT (NUMBERP (EVAL$ T (CONS V C) A))))
                     (NOT (EVAL$ T
                                 (CONS Z
                                       (CONS (CONS V C)
                                             (CONS (CONS D Z1) X1)))
                                 A))).

      However this further simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
      and CDR-CONS, to:

            T.

  Case 5.1.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (EQUAL (CAADR X) 'PLUS))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (NUMBERP (EVAL$ T (CADR X) A))
                        (NOT (LESSP (EVAL$ T (CADR X) A)
                                    (EVAL$ T (CADDR X) A))))
                   (EQUAL (EVAL$ T X A) T)).

    Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS Z V) to
    eliminate (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and
    (CDR V), W by (CONS V C) to eliminate (CAR W) and (CDR W), D by
    (CONS W X1) to eliminate (CAR D) and (CDR D), W by (CONS D Z1) to
    eliminate (CAR W) and (CDR W), D by (CONS V C) to eliminate (CAR D) and
    (CDR D), and V by (CONS D X1) to eliminate (CAR V) and (CDR V).  We must
    thus prove five new conjectures:

    Case 5.1.5.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAAR V) 'PLUS))
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (MEMBER (CAR V)
                                  (PLUS-FRINGE (CADR V)))
                          (NUMBERP (EVAL$ T (CAR V) A))
                          (NOT (LESSP (EVAL$ T (CAR V) A)
                                      (EVAL$ T (CADR V) A))))
                     (EQUAL (EVAL$ T (CONS Z V) A) T)),

      which further simplifies, applying CAR-NLISTP and CDR-NLISTP, and
      unfolding CAR, EQUAL, and LISTP, to:

            T.

    Case 5.1.4.
            (IMPLIES (AND (NOT (LISTP D))
                          (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CAR D)))
                          (NUMBERP (EVAL$ T W A))
                          (NOT (LESSP (EVAL$ T W A)
                                      (EVAL$ T (CAR D) A))))
                     (EQUAL (EVAL$ T (CONS Z (CONS W D)) A)
                            T)).

      But this further simplifies, rewriting with CAR-NLISTP, and opening up
      EQUAL and LISTP, to:

            T.

    Case 5.1.3.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (EQUAL D 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CONS D X1)))
                          (NUMBERP (EVAL$ T W A))
                          (NOT (LESSP (EVAL$ T W A)
                                      (EVAL$ T (CONS D X1) A))))
                     (EQUAL (EVAL$ T
                                   (CONS Z (CONS W (CONS (CONS D X1) C)))
                                   A)
                            T)).

      This further simplifies, rewriting with the lemmas CAR-NLISTP,
      REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and opening up EQUAL, to:

            (IMPLIES (AND (NOT (LISTP W))
                          (MEMBER W
                                  (PLUS-FRINGE (CONS 'PLUS X1)))
                          (NUMBERP (EVAL$ T W A))
                          (NOT (LESSP (EVAL$ T W A)
                                      (PLUS (EVAL$ T (CAR X1) A)
                                            (EVAL$ T (CADR X1) A)))))
                     (EQUAL (EVAL$ T W A)
                            (PLUS (EVAL$ T (CAR X1) A)
                                  (EVAL$ T (CADR X1) A)))).

      But this again simplifies, using linear arithmetic and applying
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, PLUS-TREE-PLUS-FRINGE, and
      REWRITE-EVAL$, to:

            T.

    Case 5.1.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (NOT (EQUAL V 'PLUS))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CAR D)))
                          (NUMBERP (EVAL$ T (CONS V C) A))
                          (NOT (LESSP (EVAL$ T (CONS V C) A)
                                      (EVAL$ T (CAR D) A))))
                     (EQUAL (EVAL$ T
                                   (CONS Z (CONS (CONS V C) D))
                                   A)
                            T)).

      However this further simplifies, using linear arithmetic and rewriting
      with MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, PLUS-TREE-PLUS-FRINGE, and
      MEMBER-IMPLIES-NUMBERP, to the following two new goals:

      Case 5.1.2.2.
              (IMPLIES (AND (NOT (NUMBERP (EVAL$ T (CAR D) A)))
                            (NOT (LISTP D))
                            (NOT (EQUAL V 'PLUS))
                            (LISTP (CAR D))
                            (EQUAL (CAAR D) 'PLUS)
                            (MEMBER (CONS V C)
                                    (PLUS-FRINGE (CAR D)))
                            (NUMBERP (EVAL$ T (CONS V C) A))
                            (NOT (LESSP (EVAL$ T (CONS V C) A)
                                        (EVAL$ T (CAR D) A))))
                       (EQUAL (EVAL$ T
                                     (CONS 'EQUAL (CONS (CONS V C) D))
                                     A)
                              T)).

        This again simplifies, applying CAR-NLISTP, and opening up LISTP, to:

              T.

      Case 5.1.2.1.
              (IMPLIES (AND (NUMBERP (EVAL$ T (CAR D) A))
                            (EQUAL (EVAL$ T (CONS V C) A)
                                   (EVAL$ T (CAR D) A))
                            (NOT (LISTP D))
                            (NOT (EQUAL V 'PLUS))
                            (LISTP (CAR D))
                            (EQUAL (CAAR D) 'PLUS)
                            (MEMBER (CONS V C)
                                    (PLUS-FRINGE (CAR D)))
                            (NOT (LESSP (EVAL$ T (CAR D) A)
                                        (EVAL$ T (CAR D) A))))
                       (EQUAL (EVAL$ T
                                     (CONS 'EQUAL (CONS (CONS V C) D))
                                     A)
                              T)).

        But this again simplifies, rewriting with CAR-NLISTP, and unfolding
        the function LISTP, to:

              T.

    Case 5.1.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (NOT (EQUAL V 'PLUS))
                          (EQUAL D 'PLUS)
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CONS D Z1)))
                          (NUMBERP (EVAL$ T (CONS V C) A))
                          (NOT (LESSP (EVAL$ T (CONS V C) A)
                                      (EVAL$ T (CONS D Z1) A))))
                     (EQUAL (EVAL$ T
                                   (CONS Z
                                         (CONS (CONS V C)
                                               (CONS (CONS D Z1) X1)))
                                   A)
                            T)).

      This further simplifies, rewriting with the lemmas REWRITE-EVAL$,
      CAR-CONS, and CDR-CONS, to:

            (IMPLIES (AND (NOT (EQUAL V 'PLUS))
                          (MEMBER (CONS V C)
                                  (PLUS-FRINGE (CONS 'PLUS Z1)))
                          (NUMBERP (EVAL$ T (CONS V C) A))
                          (NOT (LESSP (EVAL$ T (CONS V C) A)
                                      (PLUS (EVAL$ T (CAR Z1) A)
                                            (EVAL$ T (CADR Z1) A)))))
                     (EQUAL (EVAL$ T (CONS V C) A)
                            (PLUS (EVAL$ T (CAR Z1) A)
                                  (EVAL$ T (CADR Z1) A)))).

      However this again simplifies, using linear arithmetic and applying
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, PLUS-TREE-PLUS-FRINGE, and
      REWRITE-EVAL$, to:

            T.

Case 4. (IMPLIES
         (AND (LISTP X)
              (EQUAL (CAR X) 'EQUAL)
              (NOT (LISTP (CADR X)))
              (LISTP (CADDR X))
              (EQUAL (CAADDR X) 'PLUS)
              (MEMBER (CADR X)
                      (PLUS-FRINGE (CADDR X))))
         (EQUAL
               (EVAL$ T X A)
               (EVAL$ T
                      (LIST 'IF
                            (LIST 'NUMBERP (CADR X))
                            (LIST 'EQUAL
                                  ''0
                                  (PLUS-TREE (DELETE (CADR X)
                                                     (PLUS-FRINGE (CADDR X)))))
                            (LIST 'QUOTE F))
                      A))).

  But this again simplifies, applying REWRITE-EVAL$, CAR-CONS, CDR-CONS,
  EVAL$-QUOTE, MEMBER-IMPLIES-NUMBERP, PLUS-TREE-PLUS-FRINGE, PLUS-TREE-DELETE,
  and EQUAL-DIFFERENCE-0, and unfolding CAR, to the following three new goals:

  Case 4.3.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (LISTP (CADR X)))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (LESSP (EVAL$ T (CADR X) A)
                               (EVAL$ T (CADDR X) A)))
                   (EQUAL (EVAL$ T X A) F)).

    This again simplifies, obviously, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (LISTP (CADR X)))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (LESSP (EVAL$ T (CADR X) A)
                               (EVAL$ T (CADDR X) A)))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), D
    by (CONS V C) to eliminate (CAR D) and (CDR D), and V by (CONS D X1) to
    eliminate (CAR V) and (CDR V).  We would thus like to prove the following
    three new conjectures:

    Case 4.3.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (NOT (LISTP (CAR V)))
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (MEMBER (CAR V)
                                  (PLUS-FRINGE (CADR V)))
                          (LESSP (EVAL$ T (CAR V) A)
                                 (EVAL$ T (CADR V) A)))
                     (NOT (EVAL$ T (CONS Z V) A))).

      This further simplifies, applying CAR-NLISTP and CDR-NLISTP, and
      expanding the functions LISTP and CAR, to:

            T.

    Case 4.3.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (NOT (LISTP W))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CAR D)))
                          (LESSP (EVAL$ T W A)
                                 (EVAL$ T (CAR D) A)))
                     (NOT (EVAL$ T (CONS Z (CONS W D)) A))).

      This further simplifies, rewriting with CAR-NLISTP, and expanding the
      definition of LISTP, to:

            T.

    Case 4.3.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (NOT (LISTP W))
                          (EQUAL D 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CONS D X1)))
                          (LESSP (EVAL$ T W A)
                                 (EVAL$ T (CONS D X1) A)))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS W (CONS (CONS D X1) C)))
                                 A))).

      This further simplifies, rewriting with REWRITE-EVAL$, CAR-CONS, and
      CDR-CONS, to:

            (IMPLIES (AND (NOT (LISTP W))
                          (MEMBER W
                                  (PLUS-FRINGE (CONS 'PLUS X1)))
                          (LESSP (EVAL$ T W A)
                                 (PLUS (EVAL$ T (CAR X1) A)
                                       (EVAL$ T (CADR X1) A))))
                     (NOT (EQUAL (EVAL$ T W A)
                                 (PLUS (EVAL$ T (CAR X1) A)
                                       (EVAL$ T (CADR X1) A))))),

      which finally simplifies, using linear arithmetic, to:

            T.

  Case 4.2.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (LISTP (CADR X)))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (NOT (NUMBERP (EVAL$ T (CADR X) A))))
                   (EQUAL (EVAL$ T X A) F)),

    which again simplifies, clearly, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (LISTP (CADR X)))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (NOT (NUMBERP (EVAL$ T (CADR X) A))))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), D
    by (CONS V C) to eliminate (CAR D) and (CDR D), and V by (CONS D X1) to
    eliminate (CAR V) and (CDR V).  We thus obtain the following three new
    formulas:

    Case 4.2.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (NOT (LISTP (CAR V)))
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (MEMBER (CAR V)
                                  (PLUS-FRINGE (CADR V)))
                          (NOT (NUMBERP (EVAL$ T (CAR V) A))))
                     (NOT (EVAL$ T (CONS Z V) A))).

      However this further simplifies, applying CAR-NLISTP and CDR-NLISTP, and
      unfolding the functions LISTP and CAR, to:

            T.

    Case 4.2.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (NOT (LISTP W))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CAR D)))
                          (NOT (NUMBERP (EVAL$ T W A))))
                     (NOT (EVAL$ T (CONS Z (CONS W D)) A))).

      But this further simplifies, rewriting with CAR-NLISTP, and opening up
      the function LISTP, to:

            T.

    Case 4.2.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (NOT (LISTP W))
                          (EQUAL D 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CONS D X1)))
                          (NOT (NUMBERP (EVAL$ T W A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS W (CONS (CONS D X1) C)))
                                 A))).

      This further simplifies, appealing to the lemmas REWRITE-EVAL$, CAR-CONS,
      and CDR-CONS, to:

            T.

  Case 4.1.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (NOT (LISTP (CADR X)))
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (MEMBER (CADR X)
                                (PLUS-FRINGE (CADDR X)))
                        (NUMBERP (EVAL$ T (CADR X) A))
                        (NOT (LESSP (EVAL$ T (CADR X) A)
                                    (EVAL$ T (CADDR X) A))))
                   (EQUAL (EVAL$ T X A) T)).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), D
    by (CONS V C) to eliminate (CAR D) and (CDR D), and V by (CONS D X1) to
    eliminate (CAR V) and (CDR V).  This produces the following three new
    formulas:

    Case 4.1.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (NOT (LISTP (CAR V)))
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (MEMBER (CAR V)
                                  (PLUS-FRINGE (CADR V)))
                          (NUMBERP (EVAL$ T (CAR V) A))
                          (NOT (LESSP (EVAL$ T (CAR V) A)
                                      (EVAL$ T (CADR V) A))))
                     (EQUAL (EVAL$ T (CONS Z V) A) T)).

      This further simplifies, applying CAR-NLISTP and CDR-NLISTP, and opening
      up the functions LISTP and CAR, to:

            T.

    Case 4.1.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (NOT (LISTP W))
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CAR D)))
                          (NUMBERP (EVAL$ T W A))
                          (NOT (LESSP (EVAL$ T W A)
                                      (EVAL$ T (CAR D) A))))
                     (EQUAL (EVAL$ T (CONS Z (CONS W D)) A)
                            T)).

      This further simplifies, rewriting with CAR-NLISTP, and expanding the
      function LISTP, to:

            T.

    Case 4.1.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (NOT (LISTP W))
                          (EQUAL D 'PLUS)
                          (MEMBER W (PLUS-FRINGE (CONS D X1)))
                          (NUMBERP (EVAL$ T W A))
                          (NOT (LESSP (EVAL$ T W A)
                                      (EVAL$ T (CONS D X1) A))))
                     (EQUAL (EVAL$ T
                                   (CONS Z (CONS W (CONS (CONS D X1) C)))
                                   A)
                            T)).

      However this further simplifies, applying REWRITE-EVAL$, CAR-CONS, and
      CDR-CONS, to:

            (IMPLIES (AND (NOT (LISTP W))
                          (MEMBER W
                                  (PLUS-FRINGE (CONS 'PLUS X1)))
                          (NUMBERP (EVAL$ T W A))
                          (NOT (LESSP (EVAL$ T W A)
                                      (PLUS (EVAL$ T (CAR X1) A)
                                            (EVAL$ T (CADR X1) A)))))
                     (EQUAL (EVAL$ T W A)
                            (PLUS (EVAL$ T (CAR X1) A)
                                  (EVAL$ T (CADR X1) A)))),

      which again simplifies, using linear arithmetic and applying
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, PLUS-TREE-PLUS-FRINGE, and
      REWRITE-EVAL$, to:

            T.

Case 3. (IMPLIES
         (AND (LISTP X)
              (EQUAL (CAR X) 'EQUAL)
              (LISTP (CADR X))
              (EQUAL (CAADR X) 'PLUS)
              (NOT (EQUAL (CAADDR X) 'PLUS))
              (MEMBER (CADDR X)
                      (PLUS-FRINGE (CADR X))))
         (EQUAL
           (EVAL$ T X A)
           (EVAL$ T
                  (LIST 'IF
                        (LIST 'NUMBERP (CADDR X))
                        (CONS 'EQUAL
                              (CONS (PLUS-TREE (DELETE (CADDR X)
                                                       (PLUS-FRINGE (CADR X))))
                                    '('0)))
                        (LIST 'QUOTE F))
                  A))).

  However this again simplifies, applying REWRITE-EVAL$, CAR-CONS, CDR-CONS,
  MEMBER-IMPLIES-NUMBERP, PLUS-TREE-PLUS-FRINGE, PLUS-TREE-DELETE, EVAL$-QUOTE,
  and EQUAL-DIFFERENCE-0, and expanding CAR, to the following three new
  conjectures:

  Case 3.3.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (EQUAL (CAADDR X) 'PLUS))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (LESSP (EVAL$ T (CADDR X) A)
                               (EVAL$ T (CADR X) A)))
                   (EQUAL (EVAL$ T X A) F)).

    This again simplifies, obviously, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (EQUAL (CAADDR X) 'PLUS))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (LESSP (EVAL$ T (CADDR X) A)
                               (EVAL$ T (CADR X) A)))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), W
    by (CONS V C) to eliminate (CAR W) and (CDR W), D by (CONS W X1) to
    eliminate (CAR D) and (CDR D), and W by (CONS D Z1) to eliminate (CAR W)
    and (CDR W).  This produces the following four new goals:

    Case 3.3.4.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (LISTP (CAR V))
                          (EQUAL (CAAR V) 'PLUS)
                          (NOT (EQUAL (CAADR V) 'PLUS))
                          (MEMBER (CADR V)
                                  (PLUS-FRINGE (CAR V)))
                          (LESSP (EVAL$ T (CADR V) A)
                                 (EVAL$ T (CAR V) A)))
                     (NOT (EVAL$ T (CONS Z V) A))).

      However this further simplifies, applying the lemma CAR-NLISTP, and
      unfolding the function LISTP, to:

            T.

    Case 3.3.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (EQUAL (CAAR D) 'PLUS))
                          (MEMBER (CAR D)
                                  (PLUS-FRINGE (CONS V C)))
                          (LESSP (EVAL$ T (CAR D) A)
                                 (EVAL$ T (CONS V C) A)))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) D))
                                 A))),

      which further simplifies, applying the lemmas CAR-NLISTP, REWRITE-EVAL$,
      CAR-CONS, and CDR-CONS, and unfolding the definitions of CAR and EQUAL,
      to the goal:

            (IMPLIES (AND (NOT (LISTP D))
                          (MEMBER 0
                                  (PLUS-FRINGE (CONS 'PLUS C)))
                          (LESSP (EVAL$ T 0 A)
                                 (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))))
                     (NOT (EQUAL (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))
                                 (EVAL$ T 0 A)))).

      But this finally simplifies, using linear arithmetic, to:

            T.

    Case 3.3.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (MEMBER W (PLUS-FRINGE (CONS V C)))
                          (LESSP (EVAL$ T W A)
                                 (EVAL$ T (CONS V C) A)))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) (CONS W X1)))
                                 A))),

      which further simplifies, applying CAR-NLISTP, REWRITE-EVAL$, CAR-CONS,
      and CDR-CONS, and unfolding the function EQUAL, to the new formula:

            (IMPLIES (AND (NOT (LISTP W))
                          (MEMBER W
                                  (PLUS-FRINGE (CONS 'PLUS C)))
                          (LESSP (EVAL$ T W A)
                                 (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))))
                     (NOT (EQUAL (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))
                                 (EVAL$ T W A)))),

      which finally simplifies, using linear arithmetic, to:

            T.

    Case 3.3.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (EQUAL D 'PLUS))
                          (MEMBER (CONS D Z1)
                                  (PLUS-FRINGE (CONS V C)))
                          (LESSP (EVAL$ T (CONS D Z1) A)
                                 (EVAL$ T (CONS V C) A)))
                     (NOT (EVAL$ T
                                 (CONS Z
                                       (CONS (CONS V C)
                                             (CONS (CONS D Z1) X1)))
                                 A))),

      which further simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS,
      to the new conjecture:

            (IMPLIES (AND (NOT (EQUAL D 'PLUS))
                          (MEMBER (CONS D Z1)
                                  (PLUS-FRINGE (CONS 'PLUS C)))
                          (LESSP (EVAL$ T (CONS D Z1) A)
                                 (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))))
                     (NOT (EQUAL (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))
                                 (EVAL$ T (CONS D Z1) A)))),

      which finally simplifies, using linear arithmetic, to:

            T.

  Case 3.2.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (EQUAL (CAADDR X) 'PLUS))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (NOT (NUMBERP (EVAL$ T (CADDR X) A))))
                   (EQUAL (EVAL$ T X A) F)),

    which again simplifies, clearly, to:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (EQUAL (CAADDR X) 'PLUS))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (NOT (NUMBERP (EVAL$ T (CADDR X) A))))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), W
    by (CONS V C) to eliminate (CAR W) and (CDR W), D by (CONS W X1) to
    eliminate (CAR D) and (CDR D), and W by (CONS D Z1) to eliminate (CAR W)
    and (CDR W).  We thus obtain the following four new goals:

    Case 3.2.4.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (LISTP (CAR V))
                          (EQUAL (CAAR V) 'PLUS)
                          (NOT (EQUAL (CAADR V) 'PLUS))
                          (MEMBER (CADR V)
                                  (PLUS-FRINGE (CAR V)))
                          (NOT (NUMBERP (EVAL$ T (CADR V) A))))
                     (NOT (EVAL$ T (CONS Z V) A))).

      However this further simplifies, applying the lemma CAR-NLISTP, and
      opening up LISTP, to:

            T.

    Case 3.2.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (EQUAL (CAAR D) 'PLUS))
                          (MEMBER (CAR D)
                                  (PLUS-FRINGE (CONS V C)))
                          (NOT (NUMBERP (EVAL$ T (CAR D) A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) D))
                                 A))),

      which further simplifies, applying the lemmas CAR-NLISTP, REWRITE-EVAL$,
      CAR-CONS, and CDR-CONS, and opening up CAR and EQUAL, to:

            T.

    Case 3.2.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (EQUAL (CAR W) 'PLUS))
                          (MEMBER W (PLUS-FRINGE (CONS V C)))
                          (NOT (NUMBERP (EVAL$ T W A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) (CONS W X1)))
                                 A))),

      which further simplifies, rewriting with the lemmas CAR-NLISTP,
      REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and expanding the definition of
      EQUAL, to:

            T.

    Case 3.2.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (EQUAL D 'PLUS))
                          (MEMBER (CONS D Z1)
                                  (PLUS-FRINGE (CONS V C)))
                          (NOT (NUMBERP (EVAL$ T (CONS D Z1) A))))
                     (NOT (EVAL$ T
                                 (CONS Z
                                       (CONS (CONS V C)
                                             (CONS (CONS D Z1) X1)))
                                 A))),

      which further simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS,
      to:

            T.

  Case 3.1.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (EQUAL (CAADDR X) 'PLUS))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (NUMBERP (EVAL$ T (CADDR X) A))
                        (NOT (LESSP (EVAL$ T (CADDR X) A)
                                    (EVAL$ T (CADR X) A))))
                   (EQUAL (EVAL$ T X A) T)).

    However this again simplifies, using linear arithmetic and rewriting with
    MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, PLUS-TREE-PLUS-FRINGE, and
    MEMBER-IMPLIES-NUMBERP, to the following two new conjectures:

    Case 3.1.2.
            (IMPLIES (AND (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                          (LISTP X)
                          (EQUAL (CAR X) 'EQUAL)
                          (LISTP (CADR X))
                          (EQUAL (CAADR X) 'PLUS)
                          (NOT (EQUAL (CAADDR X) 'PLUS))
                          (MEMBER (CADDR X)
                                  (PLUS-FRINGE (CADR X)))
                          (NUMBERP (EVAL$ T (CADDR X) A))
                          (NOT (LESSP (EVAL$ T (CADDR X) A)
                                      (EVAL$ T (CADR X) A))))
                     (EQUAL (EVAL$ T X A) T)).

      However this again simplifies, rewriting with MEMBER-IMPLIES-NUMBERP, to:

            T.

    Case 3.1.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T (CADR X) A))
                          (EQUAL (EVAL$ T (CADDR X) A)
                                 (EVAL$ T (CADR X) A))
                          (LISTP X)
                          (EQUAL (CAR X) 'EQUAL)
                          (LISTP (CADR X))
                          (EQUAL (CAADR X) 'PLUS)
                          (NOT (EQUAL (CAADDR X) 'PLUS))
                          (MEMBER (CADDR X)
                                  (PLUS-FRINGE (CADR X)))
                          (NOT (LESSP (EVAL$ T (CADR X) A)
                                      (EVAL$ T (CADR X) A))))
                     (EQUAL (EVAL$ T X A) T)).

      But this again simplifies, applying the lemmas NUMBERP-EVAL$-PLUS and
      MEMBER-IMPLIES-NUMBERP, to:

            (IMPLIES (AND (EQUAL (EVAL$ T (CADDR X) A)
                                 (EVAL$ T (CADR X) A))
                          (LISTP X)
                          (EQUAL (CAR X) 'EQUAL)
                          (LISTP (CADR X))
                          (EQUAL (CAADR X) 'PLUS)
                          (NOT (EQUAL (CAADDR X) 'PLUS))
                          (MEMBER (CADDR X)
                                  (PLUS-FRINGE (CADR X)))
                          (NOT (LESSP (EVAL$ T (CADR X) A)
                                      (EVAL$ T (CADR X) A))))
                     (EQUAL (EVAL$ T X A) T)).

      Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS V Z) to
      eliminate (CDR X) and (CAR X), Z by (CONS D W) to eliminate (CDR Z) and
      (CAR Z), W by (CONS Z C) to eliminate (CAR W) and (CDR W), Z by
      (CONS W X1) to eliminate (CAR Z) and (CDR Z), D by (CONS Z Z1) to
      eliminate (CAR D) and (CDR D), D by (CONS W X1) to eliminate (CAR D) and
      (CDR D), and D by (CONS Z C) to eliminate (CAR D) and (CDR D).  We must
      thus prove four new conjectures:

      Case 3.1.1.4.
              (IMPLIES (AND (NOT (LISTP Z))
                            (EQUAL (EVAL$ T (CADR Z) A)
                                   (EVAL$ T (CAR Z) A))
                            (EQUAL V 'EQUAL)
                            (LISTP (CAR Z))
                            (EQUAL (CAAR Z) 'PLUS)
                            (NOT (EQUAL (CAADR Z) 'PLUS))
                            (MEMBER (CADR Z)
                                    (PLUS-FRINGE (CAR Z)))
                            (NOT (LESSP (EVAL$ T (CAR Z) A)
                                        (EVAL$ T (CAR Z) A))))
                       (EQUAL (EVAL$ T (CONS V Z) A) T)),

        which finally simplifies, applying the lemmas CDR-NLISTP and
        CAR-NLISTP, and expanding the definitions of CAR and LISTP, to:

              T.

      Case 3.1.1.3.
              (IMPLIES (AND (NOT (LISTP W))
                            (EQUAL (EVAL$ T (CAR W) A)
                                   (EVAL$ T (CONS Z C) A))
                            (EQUAL V 'EQUAL)
                            (EQUAL Z 'PLUS)
                            (NOT (EQUAL (CAAR W) 'PLUS))
                            (MEMBER (CAR W)
                                    (PLUS-FRINGE (CONS Z C)))
                            (NOT (LESSP (EVAL$ T (CONS Z C) A)
                                        (EVAL$ T (CONS Z C) A))))
                       (EQUAL (EVAL$ T
                                     (CONS V (CONS (CONS Z C) W))
                                     A)
                              T)),

        which finally simplifies, rewriting with CAR-NLISTP, REWRITE-EVAL$,
        CAR-CONS, and CDR-CONS, and opening up the definitions of CAR and
        EQUAL, to:

              T.

      Case 3.1.1.2.
              (IMPLIES (AND (NOT (LISTP Z))
                            (EQUAL (EVAL$ T Z A)
                                   (EVAL$ T (CONS W X1) A))
                            (EQUAL V 'EQUAL)
                            (EQUAL W 'PLUS)
                            (NOT (EQUAL (CAR Z) 'PLUS))
                            (MEMBER Z (PLUS-FRINGE (CONS W X1)))
                            (NOT (LESSP (EVAL$ T (CONS W X1) A)
                                        (EVAL$ T (CONS W X1) A))))
                       (EQUAL (EVAL$ T
                                     (CONS V (CONS (CONS W X1) (CONS Z C)))
                                     A)
                              T)).

        But this finally simplifies, appealing to the lemmas REWRITE-EVAL$,
        CAR-NLISTP, CAR-CONS, and CDR-CONS, and opening up the definition of
        EQUAL, to:

              T.

      Case 3.1.1.1.
              (IMPLIES (AND (EQUAL (EVAL$ T (CONS W X1) A)
                                   (EVAL$ T (CONS Z Z1) A))
                            (EQUAL V 'EQUAL)
                            (EQUAL Z 'PLUS)
                            (NOT (EQUAL W 'PLUS))
                            (MEMBER (CONS W X1)
                                    (PLUS-FRINGE (CONS Z Z1)))
                            (NOT (LESSP (EVAL$ T (CONS Z Z1) A)
                                        (EVAL$ T (CONS Z Z1) A))))
                       (EQUAL (EVAL$ T
                                     (CONS V
                                           (CONS (CONS Z Z1)
                                                 (CONS (CONS W X1) C)))
                                     A)
                              T)),

        which finally simplifies, applying REWRITE-EVAL$, CAR-CONS, and
        CDR-CONS, and unfolding EQUAL, to:

              T.

Case 2. (IMPLIES
         (AND (LISTP X)
              (EQUAL (CAR X) 'EQUAL)
              (LISTP (CADR X))
              (EQUAL (CAADR X) 'PLUS)
              (NOT (LISTP (CADDR X)))
              (MEMBER (CADDR X)
                      (PLUS-FRINGE (CADR X))))
         (EQUAL
           (EVAL$ T X A)
           (EVAL$ T
                  (LIST 'IF
                        (LIST 'NUMBERP (CADDR X))
                        (CONS 'EQUAL
                              (CONS (PLUS-TREE (DELETE (CADDR X)
                                                       (PLUS-FRINGE (CADR X))))
                                    '('0)))
                        (LIST 'QUOTE F))
                  A))).

  However this again simplifies, applying REWRITE-EVAL$, CAR-CONS, CDR-CONS,
  MEMBER-IMPLIES-NUMBERP, PLUS-TREE-PLUS-FRINGE, PLUS-TREE-DELETE, EVAL$-QUOTE,
  and EQUAL-DIFFERENCE-0, and unfolding the definition of CAR, to the
  following three new conjectures:

  Case 2.3.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (LISTP (CADDR X)))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (LESSP (EVAL$ T (CADDR X) A)
                               (EVAL$ T (CADR X) A)))
                   (EQUAL (EVAL$ T X A) F)).

    This again simplifies, trivially, to the new conjecture:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (LISTP (CADDR X)))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (LESSP (EVAL$ T (CADDR X) A)
                               (EVAL$ T (CADR X) A)))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), W
    by (CONS V C) to eliminate (CAR W) and (CDR W), and D by (CONS W X1) to
    eliminate (CAR D) and (CDR D).  We thus obtain the following three new
    formulas:

    Case 2.3.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (LISTP (CAR V))
                          (EQUAL (CAAR V) 'PLUS)
                          (NOT (LISTP (CADR V)))
                          (MEMBER (CADR V)
                                  (PLUS-FRINGE (CAR V)))
                          (LESSP (EVAL$ T (CADR V) A)
                                 (EVAL$ T (CAR V) A)))
                     (NOT (EVAL$ T (CONS Z V) A))).

      However this further simplifies, applying CAR-NLISTP, and unfolding the
      definition of LISTP, to:

            T.

    Case 2.3.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (LISTP (CAR D)))
                          (MEMBER (CAR D)
                                  (PLUS-FRINGE (CONS V C)))
                          (LESSP (EVAL$ T (CAR D) A)
                                 (EVAL$ T (CONS V C) A)))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) D))
                                 A))).

      This further simplifies, appealing to the lemmas CAR-NLISTP,
      REWRITE-EVAL$, CAR-CONS, and CDR-CONS, and expanding LISTP, to:

            (IMPLIES (AND (NOT (LISTP D))
                          (MEMBER 0
                                  (PLUS-FRINGE (CONS 'PLUS C)))
                          (LESSP (EVAL$ T 0 A)
                                 (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))))
                     (NOT (EQUAL (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))
                                 (EVAL$ T 0 A)))).

      But this finally simplifies, using linear arithmetic, to:

            T.

    Case 2.3.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (LISTP W))
                          (MEMBER W (PLUS-FRINGE (CONS V C)))
                          (LESSP (EVAL$ T W A)
                                 (EVAL$ T (CONS V C) A)))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) (CONS W X1)))
                                 A))),

      which further simplifies, applying REWRITE-EVAL$, CAR-CONS, and CDR-CONS,
      to:

            (IMPLIES (AND (NOT (LISTP W))
                          (MEMBER W
                                  (PLUS-FRINGE (CONS 'PLUS C)))
                          (LESSP (EVAL$ T W A)
                                 (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))))
                     (NOT (EQUAL (PLUS (EVAL$ T (CAR C) A)
                                       (EVAL$ T (CADR C) A))
                                 (EVAL$ T W A)))),

      which finally simplifies, using linear arithmetic, to:

            T.

  Case 2.2.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (LISTP (CADDR X)))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (NOT (NUMBERP (EVAL$ T (CADDR X) A))))
                   (EQUAL (EVAL$ T X A) F)),

    which again simplifies, obviously, to the new formula:

          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (LISTP (CADDR X)))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (NOT (NUMBERP (EVAL$ T (CADDR X) A))))
                   (NOT (EVAL$ T X A))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), W
    by (CONS V C) to eliminate (CAR W) and (CDR W), and D by (CONS W X1) to
    eliminate (CAR D) and (CDR D).  This produces the following three new
    goals:

    Case 2.2.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (LISTP (CAR V))
                          (EQUAL (CAAR V) 'PLUS)
                          (NOT (LISTP (CADR V)))
                          (MEMBER (CADR V)
                                  (PLUS-FRINGE (CAR V)))
                          (NOT (NUMBERP (EVAL$ T (CADR V) A))))
                     (NOT (EVAL$ T (CONS Z V) A))).

      However this further simplifies, appealing to the lemma CAR-NLISTP, and
      unfolding LISTP, to:

            T.

    Case 2.2.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (LISTP (CAR D)))
                          (MEMBER (CAR D)
                                  (PLUS-FRINGE (CONS V C)))
                          (NOT (NUMBERP (EVAL$ T (CAR D) A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) D))
                                 A))),

      which further simplifies, rewriting with CAR-NLISTP, REWRITE-EVAL$,
      CAR-CONS, and CDR-CONS, and unfolding the definition of LISTP, to:

            T.

    Case 2.2.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (NOT (LISTP W))
                          (MEMBER W (PLUS-FRINGE (CONS V C)))
                          (NOT (NUMBERP (EVAL$ T W A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) (CONS W X1)))
                                 A))).

      However this further simplifies, applying the lemmas REWRITE-EVAL$,
      CAR-CONS, and CDR-CONS, to:

            T.

  Case 2.1.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (NOT (LISTP (CADDR X)))
                        (MEMBER (CADDR X)
                                (PLUS-FRINGE (CADR X)))
                        (NUMBERP (EVAL$ T (CADDR X) A))
                        (NOT (LESSP (EVAL$ T (CADDR X) A)
                                    (EVAL$ T (CADR X) A))))
                   (EQUAL (EVAL$ T X A) T)),

    which again simplifies, using linear arithmetic and applying
    MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, PLUS-TREE-PLUS-FRINGE, and
    MEMBER-IMPLIES-NUMBERP, to the following two new goals:

    Case 2.1.2.
            (IMPLIES (AND (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                          (LISTP X)
                          (EQUAL (CAR X) 'EQUAL)
                          (LISTP (CADR X))
                          (EQUAL (CAADR X) 'PLUS)
                          (NOT (LISTP (CADDR X)))
                          (MEMBER (CADDR X)
                                  (PLUS-FRINGE (CADR X)))
                          (NUMBERP (EVAL$ T (CADDR X) A))
                          (NOT (LESSP (EVAL$ T (CADDR X) A)
                                      (EVAL$ T (CADR X) A))))
                     (EQUAL (EVAL$ T X A) T)).

      But this again simplifies, applying MEMBER-IMPLIES-NUMBERP, to:

            T.

    Case 2.1.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T (CADR X) A))
                          (EQUAL (EVAL$ T (CADDR X) A)
                                 (EVAL$ T (CADR X) A))
                          (LISTP X)
                          (EQUAL (CAR X) 'EQUAL)
                          (LISTP (CADR X))
                          (EQUAL (CAADR X) 'PLUS)
                          (NOT (LISTP (CADDR X)))
                          (MEMBER (CADDR X)
                                  (PLUS-FRINGE (CADR X)))
                          (NOT (LESSP (EVAL$ T (CADR X) A)
                                      (EVAL$ T (CADR X) A))))
                     (EQUAL (EVAL$ T X A) T)).

      However this again simplifies, applying the lemmas NUMBERP-EVAL$-PLUS
      and MEMBER-IMPLIES-NUMBERP, to:

            (IMPLIES (AND (EQUAL (EVAL$ T (CADDR X) A)
                                 (EVAL$ T (CADR X) A))
                          (LISTP X)
                          (EQUAL (CAR X) 'EQUAL)
                          (LISTP (CADR X))
                          (EQUAL (CAADR X) 'PLUS)
                          (NOT (LISTP (CADDR X)))
                          (MEMBER (CADDR X)
                                  (PLUS-FRINGE (CADR X)))
                          (NOT (LESSP (EVAL$ T (CADR X) A)
                                      (EVAL$ T (CADR X) A))))
                     (EQUAL (EVAL$ T X A) T)).

      Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS V Z) to
      eliminate (CDR X) and (CAR X), Z by (CONS D W) to eliminate (CDR Z) and
      (CAR Z), W by (CONS Z C) to eliminate (CAR W) and (CDR W), D by
      (CONS W X1) to eliminate (CAR D) and (CDR D), and D by (CONS Z C) to
      eliminate (CAR D) and (CDR D).  We must thus prove three new formulas:

      Case 2.1.1.3.
              (IMPLIES (AND (NOT (LISTP Z))
                            (EQUAL (EVAL$ T (CADR Z) A)
                                   (EVAL$ T (CAR Z) A))
                            (EQUAL V 'EQUAL)
                            (LISTP (CAR Z))
                            (EQUAL (CAAR Z) 'PLUS)
                            (NOT (LISTP (CADR Z)))
                            (MEMBER (CADR Z)
                                    (PLUS-FRINGE (CAR Z)))
                            (NOT (LESSP (EVAL$ T (CAR Z) A)
                                        (EVAL$ T (CAR Z) A))))
                       (EQUAL (EVAL$ T (CONS V Z) A) T)),

        which finally simplifies, rewriting with CDR-NLISTP and CAR-NLISTP,
        and unfolding the definitions of CAR and LISTP, to:

              T.

      Case 2.1.1.2.
              (IMPLIES (AND (NOT (LISTP W))
                            (EQUAL (EVAL$ T (CAR W) A)
                                   (EVAL$ T (CONS Z C) A))
                            (EQUAL V 'EQUAL)
                            (EQUAL Z 'PLUS)
                            (NOT (LISTP (CAR W)))
                            (MEMBER (CAR W)
                                    (PLUS-FRINGE (CONS Z C)))
                            (NOT (LESSP (EVAL$ T (CONS Z C) A)
                                        (EVAL$ T (CONS Z C) A))))
                       (EQUAL (EVAL$ T
                                     (CONS V (CONS (CONS Z C) W))
                                     A)
                              T)).

        This finally simplifies, applying CAR-NLISTP, REWRITE-EVAL$, CAR-CONS,
        and CDR-CONS, and opening up the functions LISTP and EQUAL, to:

              T.

      Case 2.1.1.1.
              (IMPLIES (AND (EQUAL (EVAL$ T Z A)
                                   (EVAL$ T (CONS W X1) A))
                            (EQUAL V 'EQUAL)
                            (EQUAL W 'PLUS)
                            (NOT (LISTP Z))
                            (MEMBER Z (PLUS-FRINGE (CONS W X1)))
                            (NOT (LESSP (EVAL$ T (CONS W X1) A)
                                        (EVAL$ T (CONS W X1) A))))
                       (EQUAL (EVAL$ T
                                     (CONS V (CONS (CONS W X1) (CONS Z C)))
                                     A)
                              T)).

        However this finally simplifies, applying REWRITE-EVAL$, CAR-CONS, and
        CDR-CONS, and unfolding EQUAL, to:

              T.

Case 1. (IMPLIES
         (AND (LISTP X)
              (EQUAL (CAR X) 'EQUAL)
              (LISTP (CADR X))
              (EQUAL (CAADR X) 'PLUS)
              (LISTP (CADDR X))
              (EQUAL (CAADDR X) 'PLUS))
         (EQUAL
           (EVAL$ T X A)
           (EVAL$ T
                  (LIST 'EQUAL
                        (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADR X))
                                            (BAGINT (PLUS-FRINGE (CADR X))
                                                    (PLUS-FRINGE (CADDR X)))))
                        (PLUS-TREE (BAGDIFF (PLUS-FRINGE (CADDR X))
                                            (BAGINT (PLUS-FRINGE (CADR X))
                                                    (PLUS-FRINGE (CADDR X))))))
                  A))).

  This again simplifies, applying REWRITE-EVAL$, CAR-CONS, SUBBAGP-BAGINT1,
  NUMBERP-EVAL$-PLUS, PLUS-TREE-PLUS-FRINGE, PLUS-TREE-BAGDIFF, CDR-CONS,
  SUBBAGP-BAGINT2, BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP, and
  DIFFERENCE-CANCELLATION-1, to the following two new goals:

  Case 1.2.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (NOT (EQUAL (EVAL$ T (CADR X) A)
                                    (EVAL$ T (CADDR X) A))))
                   (NOT (EVAL$ T X A))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS Z V) to
    eliminate (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and
    (CDR V), W by (CONS V C) to eliminate (CAR W) and (CDR W), D by
    (CONS W X1) to eliminate (CAR D) and (CDR D), and W by (CONS D Z1) to
    eliminate (CAR W) and (CDR W).  The result is three new formulas:

    Case 1.2.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (LISTP (CAR V))
                          (EQUAL (CAAR V) 'PLUS)
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (NOT (EQUAL (EVAL$ T (CAR V) A)
                                      (EVAL$ T (CADR V) A))))
                     (NOT (EVAL$ T (CONS Z V) A))),

      which further simplifies, applying CAR-NLISTP, and expanding LISTP, to:

            T.

    Case 1.2.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (NOT (EQUAL (EVAL$ T (CONS V C) A)
                                      (EVAL$ T (CAR D) A))))
                     (NOT (EVAL$ T
                                 (CONS Z (CONS (CONS V C) D))
                                 A))).

      This further simplifies, rewriting with CAR-NLISTP, and expanding the
      function LISTP, to:

            T.

    Case 1.2.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (EQUAL D 'PLUS)
                          (NOT (EQUAL (EVAL$ T (CONS V C) A)
                                      (EVAL$ T (CONS D Z1) A))))
                     (NOT (EVAL$ T
                                 (CONS Z
                                       (CONS (CONS V C)
                                             (CONS (CONS D Z1) X1)))
                                 A))).

      But this further simplifies, rewriting with the lemmas REWRITE-EVAL$,
      CAR-CONS, and CDR-CONS, to:

            T.

  Case 1.1.
          (IMPLIES (AND (LISTP X)
                        (EQUAL (CAR X) 'EQUAL)
                        (LISTP (CADR X))
                        (EQUAL (CAADR X) 'PLUS)
                        (LISTP (CADDR X))
                        (EQUAL (CAADDR X) 'PLUS)
                        (EQUAL (EVAL$ T (CADR X) A)
                               (EVAL$ T (CADDR X) A)))
                   (EQUAL (EVAL$ T X A) T)).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS W D) to eliminate (CAR V) and (CDR V), W
    by (CONS V C) to eliminate (CAR W) and (CDR W), D by (CONS W X1) to
    eliminate (CAR D) and (CDR D), and W by (CONS D Z1) to eliminate (CAR W)
    and (CDR W).  We would thus like to prove the following three new formulas:

    Case 1.1.3.
            (IMPLIES (AND (NOT (LISTP V))
                          (EQUAL Z 'EQUAL)
                          (LISTP (CAR V))
                          (EQUAL (CAAR V) 'PLUS)
                          (LISTP (CADR V))
                          (EQUAL (CAADR V) 'PLUS)
                          (EQUAL (EVAL$ T (CAR V) A)
                                 (EVAL$ T (CADR V) A)))
                     (EQUAL (EVAL$ T (CONS Z V) A) T)).

      This further simplifies, applying CAR-NLISTP, and unfolding the
      definition of LISTP, to:

            T.

    Case 1.1.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (LISTP (CAR D))
                          (EQUAL (CAAR D) 'PLUS)
                          (EQUAL (EVAL$ T (CONS V C) A)
                                 (EVAL$ T (CAR D) A)))
                     (EQUAL (EVAL$ T
                                   (CONS Z (CONS (CONS V C) D))
                                   A)
                            T)).

      This further simplifies, applying CAR-NLISTP, and unfolding the
      definition of LISTP, to:

            T.

    Case 1.1.1.
            (IMPLIES (AND (EQUAL Z 'EQUAL)
                          (EQUAL V 'PLUS)
                          (EQUAL D 'PLUS)
                          (EQUAL (EVAL$ T (CONS V C) A)
                                 (EVAL$ T (CONS D Z1) A)))
                     (EQUAL (EVAL$ T
                                   (CONS Z
                                         (CONS (CONS V C)
                                               (CONS (CONS D Z1) X1)))
                                   A)
                            T)).

      But this further simplifies, applying the lemmas REWRITE-EVAL$, CAR-CONS,
      and CDR-CONS, and opening up the definition of EQUAL, to:

            T.

Q.E.D.


[ 0.0 0.5 0.1 ]

CORRECTNESS-OF-CANCEL


(DEFN REVERSE
      (X)
      (IF (LISTP X)
          (APPEND (REVERSE (CDR X))
                  (CONS (CAR X) NIL))
          NIL))

     Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, REVERSE is accepted under the principle of definition.
Note that (OR (LITATOM (REVERSE X)) (LISTP (REVERSE X))) is a theorem.




[ 0.0 0.0 0.0 ]

REVERSE


(PROVE-LEMMA ASSOCIATIVITY-OF-APPEND
             (REWRITE)
             (EQUAL (APPEND (APPEND X Y) Z)
                    (APPEND X (APPEND Y Z))))


     Call the conjecture *1.


     Perhaps we can prove it by induction.  Three inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP X) (p (CDR X) Y Z))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP X)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT X) decreases according to the well-founded relation LESSP in
each induction step of the scheme.  The above induction scheme leads to two
new goals:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (APPEND (APPEND (CDR X) Y) Z)
                             (APPEND (CDR X) (APPEND Y Z))))
                 (EQUAL (APPEND (APPEND X Y) Z)
                        (APPEND X (APPEND Y Z)))),

  which simplifies, applying the lemmas CDR-CONS and CAR-CONS, and opening up
  the definition of APPEND, to:

        T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (EQUAL (APPEND (APPEND X Y) Z)
                        (APPEND X (APPEND Y Z)))),

  which simplifies, unfolding the function APPEND, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

ASSOCIATIVITY-OF-APPEND


(DEFN PLISTP
      (X)
      (IF (NLISTP X)
          (EQUAL X NIL)
          (PLISTP (CDR X))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP can be used to establish that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, PLISTP is accepted under the principle of definition.  From the
definition we can conclude that (OR (FALSEP (PLISTP X)) (TRUEP (PLISTP X))) is
a theorem.




[ 0.0 0.0 0.0 ]

PLISTP


(PROVE-LEMMA APPEND-RIGHT-ID
             (REWRITE)
             (IMPLIES (PLISTP X)
                      (EQUAL (APPEND X NIL) X)))


     Name the conjecture *1.


     We will appeal to induction.  The recursive terms in the conjecture
suggest two inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP X) (p X))
           (IMPLIES (AND (NOT (NLISTP X)) (p (CDR X)))
                    (p X))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP 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 produces the following three new formulas:

Case 3. (IMPLIES (AND (NLISTP X) (PLISTP X))
                 (EQUAL (APPEND X NIL) X)).

  This simplifies, expanding the definitions of NLISTP, PLISTP, APPEND, and
  EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP X))
                      (NOT (PLISTP (CDR X)))
                      (PLISTP X))
                 (EQUAL (APPEND X NIL) X)).

  This simplifies, expanding the definitions of NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP X))
                      (EQUAL (APPEND (CDR X) NIL) (CDR X))
                      (PLISTP X))
                 (EQUAL (APPEND X NIL) X)).

  This simplifies, appealing to the lemma CONS-CAR-CDR, and unfolding the
  functions NLISTP, PLISTP, and APPEND, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

APPEND-RIGHT-ID


(PROVE-LEMMA PLISTP-REVERSE
             (GENERALIZE REWRITE)
             (PLISTP (REVERSE X)))


     Call the conjecture *1.


     Let us appeal to the induction principle.  There is only one suggested
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X) (p (CDR X)))
                    (p X))
           (IMPLIES (NOT (LISTP X)) (p X))).
Linear arithmetic and the lemma CDR-LESSP 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 leads to two new goals:

Case 2. (IMPLIES (AND (LISTP X)
                      (PLISTP (REVERSE (CDR X))))
                 (PLISTP (REVERSE X))),

  which simplifies, expanding the definition of REVERSE, to the conjecture:

        (IMPLIES (AND (LISTP X)
                      (PLISTP (REVERSE (CDR X))))
                 (PLISTP (APPEND (REVERSE (CDR X))
                                 (LIST (CAR X))))).

  Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS V Z) to
  eliminate (CDR X) and (CAR X).  This generates:

        (IMPLIES (PLISTP (REVERSE Z))
                 (PLISTP (APPEND (REVERSE Z) (LIST V)))).

  We will try to prove the above formula by generalizing it, replacing
  (REVERSE Z) by Y.  The result is:

        (IMPLIES (PLISTP Y)
                 (PLISTP (APPEND Y (LIST V)))).

  Give the above formula the name *1.1.

Case 1. (IMPLIES (NOT (LISTP X))
                 (PLISTP (REVERSE X))).

  This simplifies, expanding REVERSE and PLISTP, to:

        T.


     So let us turn our attention to:

      (IMPLIES (PLISTP Y)
               (PLISTP (APPEND Y (LIST V)))),

named *1.1 above.  Perhaps we can prove it by induction.  The recursive terms
in the conjecture suggest two inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP Y) (p Y V))
           (IMPLIES (AND (NOT (NLISTP Y)) (p (CDR Y) V))
                    (p Y V))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT Y) 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 (NLISTP Y) (PLISTP Y))
                 (PLISTP (APPEND Y (LIST V)))).

  This simplifies, applying CDR-CONS, and unfolding the definitions of NLISTP,
  PLISTP, LISTP, and APPEND, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (PLISTP (CDR Y)))
                      (PLISTP Y))
                 (PLISTP (APPEND Y (LIST V)))),

  which simplifies, unfolding NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (PLISTP (APPEND (CDR Y) (LIST V)))
                      (PLISTP Y))
                 (PLISTP (APPEND Y (LIST V)))),

  which simplifies, applying CDR-CONS, and opening up NLISTP, PLISTP, and
  APPEND, to:

        T.


     That finishes the proof of *1.1, which, consequently, also finishes the
proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

PLISTP-REVERSE


(PROVE-LEMMA APPEND-REVERSE
             (REWRITE)
             (EQUAL (REVERSE (APPEND A B))
                    (APPEND (REVERSE B) (REVERSE A))))


     Call the conjecture *1.


     Perhaps we can prove it by induction.  Three inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP A) (p (CDR A) B))
                    (p A B))
           (IMPLIES (NOT (LISTP A)) (p A B))).
Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT A) decreases according to the well-founded relation LESSP in
each induction step of the scheme.  The above induction scheme leads to two
new goals:

Case 2. (IMPLIES (AND (LISTP A)
                      (EQUAL (REVERSE (APPEND (CDR A) B))
                             (APPEND (REVERSE B)
                                     (REVERSE (CDR A)))))
                 (EQUAL (REVERSE (APPEND A B))
                        (APPEND (REVERSE B) (REVERSE A)))),

  which simplifies, applying the lemmas CAR-CONS and CDR-CONS, and opening up
  the definitions of APPEND and REVERSE, to:

        (IMPLIES (AND (LISTP A)
                      (EQUAL (REVERSE (APPEND (CDR A) B))
                             (APPEND (REVERSE B)
                                     (REVERSE (CDR A)))))
                 (EQUAL (APPEND (REVERSE (APPEND (CDR A) B))
                                (LIST (CAR A)))
                        (APPEND (REVERSE B)
                                (APPEND (REVERSE (CDR A))
                                        (LIST (CAR A)))))).

  Appealing to the lemma CAR-CDR-ELIM, we now replace A by (CONS Z X) to
  eliminate (CDR A) and (CAR A).  This generates the goal:

        (IMPLIES (EQUAL (REVERSE (APPEND X B))
                        (APPEND (REVERSE B) (REVERSE X)))
                 (EQUAL (APPEND (REVERSE (APPEND X B))
                                (LIST Z))
                        (APPEND (REVERSE B)
                                (APPEND (REVERSE X) (LIST Z))))).

  We use the above equality hypothesis by substituting:
        (APPEND (REVERSE B) (REVERSE X))
  for (REVERSE (APPEND X B)) and throwing away the equality.  This produces
  the new conjecture:

        (EQUAL (APPEND (APPEND (REVERSE B) (REVERSE X))
                       (LIST Z))
               (APPEND (REVERSE B)
                       (APPEND (REVERSE X) (LIST Z)))),

  which further simplifies, applying ASSOCIATIVITY-OF-APPEND, to:

        T.

Case 1. (IMPLIES (NOT (LISTP A))
                 (EQUAL (REVERSE (APPEND A B))
                        (APPEND (REVERSE B) (REVERSE A)))).

  This simplifies, applying PLISTP-REVERSE and APPEND-RIGHT-ID, and opening up
  APPEND and REVERSE, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

APPEND-REVERSE


(PROVE-LEMMA TIMES-ZERO2
             (REWRITE)
             (IMPLIES (NOT (NUMBERP Y))
                      (EQUAL (TIMES X Y) 0)))


     Call the conjecture *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 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 prove that the measure (COUNT X) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme leads to two new goals:

Case 2. (IMPLIES (AND (ZEROP X) (NOT (NUMBERP Y)))
                 (EQUAL (TIMES X Y) 0)),

  which simplifies, opening up the definitions of ZEROP, EQUAL, and TIMES, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (EQUAL (TIMES (SUB1 X) Y) 0)
                      (NOT (NUMBERP Y)))
                 (EQUAL (TIMES X Y) 0)),

  which simplifies, applying PLUS-RIGHT-ID2 and COMMUTATIVITY-OF-PLUS, and
  unfolding ZEROP, TIMES, NUMBERP, and EQUAL, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

TIMES-ZERO2


(PROVE-LEMMA DISTRIBUTIVITY-OF-TIMES-OVER-PLUS
             (REWRITE)
             (EQUAL (TIMES X (PLUS Y Z))
                    (PLUS (TIMES X Y) (TIMES X Z))))


     Call the conjecture *1.


     We will try to prove it by induction.  There are four plausible
inductions.  They merge into two likely candidate inductions.  However, only
one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP X) (p X Y Z))
           (IMPLIES (AND (NOT (ZEROP X)) (p (SUB1 X) Y Z))
                    (p X Y Z))).
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 two new goals:

Case 2. (IMPLIES (ZEROP X)
                 (EQUAL (TIMES X (PLUS Y Z))
                        (PLUS (TIMES X Y) (TIMES X Z)))),

  which simplifies, opening up the functions ZEROP, EQUAL, TIMES, and PLUS, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (EQUAL (TIMES (SUB1 X) (PLUS Y Z))
                             (PLUS (TIMES (SUB1 X) Y)
                                   (TIMES (SUB1 X) Z))))
                 (EQUAL (TIMES X (PLUS Y Z))
                        (PLUS (TIMES X Y) (TIMES X Z)))),

  which simplifies, applying ASSOCIATIVITY-OF-PLUS and COMMUTATIVITY2-OF-PLUS,
  and unfolding the functions ZEROP and TIMES, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

DISTRIBUTIVITY-OF-TIMES-OVER-PLUS


(PROVE-LEMMA TIMES-ADD1
             (REWRITE)
             (EQUAL (TIMES X (ADD1 Y))
                    (IF (NUMBERP Y)
                        (PLUS X (TIMES X Y))
                        (FIX X))))

This conjecture simplifies, unfolding the definition of FIX, to three new
conjectures:

Case 3. (IMPLIES (AND (NOT (NUMBERP Y)) (NUMBERP X))
                 (EQUAL (TIMES X (ADD1 Y)) X)),

  which again simplifies, rewriting with SUB1-TYPE-RESTRICTION, to the new
  formula:

        (IMPLIES (AND (NOT (NUMBERP Y)) (NUMBERP X))
                 (EQUAL (TIMES X 1) X)),

  which we will name *1.

Case 2. (IMPLIES (AND (NOT (NUMBERP Y))
                      (NOT (NUMBERP X)))
                 (EQUAL (TIMES X (ADD1 Y)) 0)).

  However this again simplifies, applying SUB1-TYPE-RESTRICTION, and opening
  up the definitions of TIMES and EQUAL, to:

        T.

Case 1. (IMPLIES (NUMBERP Y)
                 (EQUAL (TIMES X (ADD1 Y))
                        (PLUS X (TIMES X Y)))),

  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 (TIMES X (ADD1 Y))
       (IF (NUMBERP Y)
           (PLUS X (TIMES X Y))
           (FIX X))),

which we named *1 above.  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 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
establish that the measure (COUNT X) decreases according to the well-founded
relation LESSP in each induction step of the scheme.  The above induction
scheme leads to the following two new formulas:

Case 2. (IMPLIES (ZEROP X)
                 (EQUAL (TIMES X (ADD1 Y))
                        (IF (NUMBERP Y)
                            (PLUS X (TIMES X Y))
                            (FIX X)))).

  This simplifies, rewriting with PLUS-RIGHT-ID2 and COMMUTATIVITY-OF-PLUS,
  and expanding the definitions of ZEROP, EQUAL, TIMES, PLUS, FIX, and NUMBERP,
  to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (EQUAL (TIMES (SUB1 X) (ADD1 Y))
                             (IF (NUMBERP Y)
                                 (PLUS (SUB1 X) (TIMES (SUB1 X) Y))
                                 (FIX (SUB1 X)))))
                 (EQUAL (TIMES X (ADD1 Y))
                        (IF (NUMBERP Y)
                            (PLUS X (TIMES X Y))
                            (FIX X)))),

  which simplifies, applying SUB1-TYPE-RESTRICTION and SUB1-ADD1, and
  unfolding the functions ZEROP, FIX, TIMES, and PLUS, to the following two
  new formulas:

  Case 1.2.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (NUMBERP Y))
                        (EQUAL (TIMES (SUB1 X) (ADD1 Y))
                               (SUB1 X)))
                   (EQUAL (TIMES X 1) X)).

    But this further simplifies, rewriting with SUB1-TYPE-RESTRICTION, and
    unfolding TIMES, to the new formula:

          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (NUMBERP Y))
                        (EQUAL (TIMES (SUB1 X) 1) (SUB1 X)))
                   (EQUAL (PLUS 1 (SUB1 X)) X)),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NUMBERP Y)
                        (EQUAL (TIMES (SUB1 X) (ADD1 Y))
                               (PLUS (SUB1 X) (TIMES (SUB1 X) Y))))
                   (EQUAL (ADD1 (PLUS Y (TIMES (SUB1 X) (ADD1 Y))))
                          (PLUS X Y (TIMES (SUB1 X) Y)))),

    which again simplifies, using linear arithmetic, to:

          T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

TIMES-ADD1


(PROVE-LEMMA COMMUTATIVITY-OF-TIMES
             (REWRITE)
             (EQUAL (TIMES X Y) (TIMES Y X)))

WARNING:  the newly proposed lemma, COMMUTATIVITY-OF-TIMES, could be applied
whenever the previously added lemma TIMES-ADD1 could.




WARNING:  the newly proposed lemma, COMMUTATIVITY-OF-TIMES, could be applied
whenever the previously added lemma DISTRIBUTIVITY-OF-TIMES-OVER-PLUS could.




WARNING:  the newly proposed lemma, COMMUTATIVITY-OF-TIMES, could be applied
whenever the previously added lemma TIMES-ZERO2 could.





     Give the conjecture the name *1.


     We will appeal to induction.  Two inductions are suggested by terms in
the conjecture, both of which are flawed.  We limit our consideration to the
two suggested by the largest number of nonprimitive recursive functions in the
conjecture.  Since both of these are equally likely, we will choose
arbitrarily.  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 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
produces the following two new conjectures:

Case 2. (IMPLIES (ZEROP X)
                 (EQUAL (TIMES X Y) (TIMES Y X))).

  This simplifies, applying TIMES-ZERO2, and opening up the functions ZEROP,
  EQUAL, and TIMES, to:

        (IMPLIES (EQUAL X 0)
                 (EQUAL 0 (TIMES Y 0))).

  This again simplifies, obviously, to:

        (EQUAL 0 (TIMES Y 0)),

  which we will name *1.1.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (EQUAL (TIMES (SUB1 X) Y)
                             (TIMES Y (SUB1 X))))
                 (EQUAL (TIMES X Y) (TIMES Y X))).

  This simplifies, unfolding the definitions of ZEROP and TIMES, to the new
  goal:

        (IMPLIES (AND (NOT (EQUAL X 0))
                      (NUMBERP X)
                      (EQUAL (TIMES (SUB1 X) Y)
                             (TIMES Y (SUB1 X))))
                 (EQUAL (PLUS Y (TIMES Y (SUB1 X)))
                        (TIMES Y X))).

  Applying the lemma SUB1-ELIM, replace X by (ADD1 Z) to eliminate (SUB1 X).
  We employ the type restriction lemma noted when SUB1 was introduced to
  restrict the new variable.  This produces the new goal:

        (IMPLIES (AND (NUMBERP Z)
                      (NOT (EQUAL (ADD1 Z) 0))
                      (EQUAL (TIMES Z Y) (TIMES Y Z)))
                 (EQUAL (PLUS Y (TIMES Y Z))
                        (TIMES Y (ADD1 Z)))),

  which further simplifies, applying the lemma TIMES-ADD1, to:

        T.


     So we now return to:

      (EQUAL 0 (TIMES Y 0)),

which is formula *1.1 above.  We will try to prove it by induction.  There is
only one suggested induction.  We will induct according to the following
scheme:
      (AND (IMPLIES (ZEROP Y) (p Y))
           (IMPLIES (AND (NOT (ZEROP Y)) (p (SUB1 Y)))
                    (p Y))).
Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP
establish that the measure (COUNT Y) decreases according to the well-founded
relation LESSP in each induction step of the scheme.  The above induction
scheme produces two new conjectures:

Case 2. (IMPLIES (ZEROP Y)
                 (EQUAL 0 (TIMES Y 0))),

  which simplifies, unfolding ZEROP, TIMES, and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP Y))
                      (EQUAL 0 (TIMES (SUB1 Y) 0)))
                 (EQUAL 0 (TIMES Y 0))),

  which simplifies, unfolding the definitions of ZEROP, TIMES, PLUS, and EQUAL,
  to:

        T.


     That finishes the proof of *1.1, which, in turn, finishes the proof of *1.
Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUTATIVITY-OF-TIMES


(PROVE-LEMMA COMMUTATIVITY2-OF-TIMES
             (REWRITE)
             (EQUAL (TIMES X (TIMES Y Z))
                    (TIMES Y (TIMES X Z))))

WARNING:  the previously added lemma, COMMUTATIVITY-OF-TIMES, could be applied
whenever the newly proposed COMMUTATIVITY2-OF-TIMES could!



     Call the conjecture *1.


     Perhaps we can prove it by induction.  Four inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions,
both of which are unflawed.  Since both of these are equally likely, we will
choose arbitrarily.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP Y) (p X Y Z))
           (IMPLIES (AND (NOT (ZEROP Y)) (p X (SUB1 Y) Z))
                    (p X Y Z))).
Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP can be
used to prove that the measure (COUNT Y) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme leads to two new goals:

Case 2. (IMPLIES (ZEROP Y)
                 (EQUAL (TIMES X Y Z) (TIMES Y X Z))),

  which simplifies, applying the lemma COMMUTATIVITY-OF-TIMES, and opening up
  the definitions of ZEROP, EQUAL, and TIMES, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP Y))
                      (EQUAL (TIMES X (SUB1 Y) Z)
                             (TIMES (SUB1 Y) X Z)))
                 (EQUAL (TIMES X Y Z) (TIMES Y X Z))),

  which simplifies, rewriting with DISTRIBUTIVITY-OF-TIMES-OVER-PLUS, and
  opening up the functions ZEROP and TIMES, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUTATIVITY2-OF-TIMES


(PROVE-LEMMA ASSOCIATIVITY-OF-TIMES
             (REWRITE)
             (EQUAL (TIMES (TIMES X Y) Z)
                    (TIMES X (TIMES Y Z))))

WARNING:  the previously added lemma, COMMUTATIVITY-OF-TIMES, could be applied
whenever the newly proposed ASSOCIATIVITY-OF-TIMES could!


This simplifies, rewriting with COMMUTATIVITY-OF-TIMES and
COMMUTATIVITY2-OF-TIMES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ASSOCIATIVITY-OF-TIMES


(PROVE-LEMMA EQUAL-TIMES-0
             (REWRITE)
             (EQUAL (EQUAL (TIMES X Y) 0)
                    (OR (ZEROP X) (ZEROP Y))))

This simplifies, opening up the functions ZEROP and OR, to five new
conjectures:

Case 5. (IMPLIES (NOT (EQUAL (TIMES X Y) 0))
                 (NUMBERP Y)),

  which again simplifies, applying TIMES-ZERO2, and unfolding the function
  EQUAL, to:

        T.

Case 4. (IMPLIES (NOT (EQUAL (TIMES X Y) 0))
                 (NOT (EQUAL Y 0))).

  However this again simplifies, applying COMMUTATIVITY-OF-TIMES, and
  unfolding the functions EQUAL and TIMES, to:

        T.

Case 3. (IMPLIES (NOT (EQUAL (TIMES X Y) 0))
                 (NUMBERP X)).

  This again simplifies, opening up the definitions of TIMES and EQUAL, to:

        T.

Case 2. (IMPLIES (NOT (EQUAL (TIMES X Y) 0))
                 (NOT (EQUAL X 0))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (TIMES X Y) 0)
                      (NOT (EQUAL X 0))
                      (NUMBERP X)
                      (NOT (EQUAL Y 0)))
                 (NOT (NUMBERP Y))),

  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 X) (p Y X))
           (IMPLIES (AND (NOT (ZEROP X)) (p Y (SUB1 X)))
                    (p Y X))).
Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP can be
used to establish 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)
                      (EQUAL (TIMES X Y) 0)
                      (NOT (EQUAL X 0))
                      (NUMBERP X)
                      (NOT (EQUAL Y 0)))
                 (NOT (NUMBERP Y))),

  which simplifies, unfolding the function ZEROP, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP X))
                      (NOT (EQUAL (TIMES (SUB1 X) Y) 0))
                      (EQUAL (TIMES X Y) 0)
                      (NOT (EQUAL X 0))
                      (NUMBERP X)
                      (NOT (EQUAL Y 0)))
                 (NOT (NUMBERP Y))),

  which simplifies, rewriting with the lemma PLUS-EQUAL-0, and expanding the
  functions ZEROP and TIMES, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (EQUAL (SUB1 X) 0)
                      (EQUAL (TIMES X Y) 0)
                      (NOT (EQUAL X 0))
                      (NUMBERP X)
                      (NOT (EQUAL Y 0)))
                 (NOT (NUMBERP Y))),

  which simplifies, rewriting with the lemma PLUS-EQUAL-0, and expanding the
  definitions of ZEROP and TIMES, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

EQUAL-TIMES-0


(ADD-SHELL PUSH NIL STACKP
           ((TOP (NONE-OF) ZERO)
            (POP (NONE-OF) ZERO)))

[ 0.0 0.0 0.0 ]

PUSH


(CONSTRAIN NUMBERP-CALL
           (REWRITE)
           (NUMBERP (CALL FN X Y))
           ((CALL (LAMBDA (FN X Y) 1))
            (GETVALUE (LAMBDA (X Y) NIL))))

WARNING:  Note that the proposed lemma NUMBERP-CALL is to be stored as one
type prescription rule, zero compound recognizer rules, zero linear rules, and
zero replacement rules.



We will verify the consistency and the conservative nature of this constraint
by attempting to prove (NUMBERP 1).

This simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NUMBERP-CALL


(DEFN EXPRESSIONP
      (X)
      (IF (LISTP X)
          (IF (LISTP (CAR X))
              F
              (IF (LISTP (CDR X))
                  (IF (LISTP (CDDR X))
                      (IF (EXPRESSIONP (CADR X))
                          (EXPRESSIONP (CADDR X))
                          F)
                      F)
                  F))
          T))

     Linear arithmetic and the lemmas CAR-LESSP, CDR-LESSEQP, and CDR-LESSP
establish that the measure (COUNT X) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, EXPRESSIONP is accepted under
the principle of definition.  From the definition we can conclude that:
      (OR (FALSEP (EXPRESSIONP X))
          (TRUEP (EXPRESSIONP X)))
is a theorem.




[ 0.0 0.0 0.0 ]

EXPRESSIONP


(PROVE-LEMMA CADR-CROCK
             (REWRITE)
             (IMPLIES (LISTP (CDDR X))
                      (LESSP (COUNT (CADR X)) (COUNT X))))

WARNING:  Note that the proposed lemma CADR-CROCK is to be stored as zero type
prescription rules, zero compound recognizer rules, one linear rule, and zero
replacement rules.


This formula simplifies, using linear arithmetic and applying CDR-LESSEQP and
CAR-LESSEQP, to:

      (IMPLIES (AND (EQUAL (COUNT (CDR X)) (COUNT X))
                    (LISTP (CDDR X)))
               (LESSP (COUNT (CADR X)) (COUNT X))).

Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate (CDR X)
and (CAR X) and Z by (CONS D W) to eliminate (CDR Z) and (CAR Z).  We would
thus like to prove the following three new conjectures:

Case 3. (IMPLIES (AND (NOT (LISTP X))
                      (EQUAL (COUNT (CDR X)) (COUNT X))
                      (LISTP (CDDR X)))
                 (LESSP (COUNT (CADR X)) (COUNT X))).

  But this further simplifies, applying the lemma CDR-NLISTP, and opening up
  COUNT, CDR, and LISTP, to:

        T.

Case 2. (IMPLIES (AND (NOT (LISTP Z))
                      (EQUAL (COUNT Z) (COUNT (CONS V Z)))
                      (LISTP (CDR Z)))
                 (LESSP (COUNT (CAR Z))
                        (COUNT (CONS V Z)))),

  which further simplifies, applying COUNT-CONS and CDR-NLISTP, and expanding
  LISTP, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (COUNT (CONS D W))
                             (COUNT (CONS V (CONS D W))))
                      (LISTP W))
                 (LESSP (COUNT D)
                        (COUNT (CONS V (CONS D W))))).

  This further simplifies, rewriting with COUNT-CONS, COMMUTATIVITY2-OF-PLUS,
  PLUS-ADD1, ADD1-EQUAL, and SUB1-ADD1, and expanding the function LESSP, to
  the new formula:

        (IMPLIES (AND (EQUAL (PLUS (COUNT D) (COUNT W))
                             (ADD1 (PLUS (COUNT D) (COUNT V) (COUNT W))))
                      (LISTP W)
                      (NOT (EQUAL (COUNT D) 0)))
                 (LESSP (SUB1 (COUNT D))
                        (PLUS (COUNT D) (COUNT W)))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

CADR-CROCK


(DEFN TERM-EVAL
      (FORM ENVRN)
      (IF (NUMBERP FORM)
          FORM
          (IF (LISTP (CDDR FORM))
              (CALL (CAR FORM)
                    (TERM-EVAL (CADR FORM) ENVRN)
                    (TERM-EVAL (CADDR FORM) ENVRN))
              (GETVALUE FORM ENVRN))))

     Linear arithmetic and the lemmas CAR-LESSP, CDR-LESSEQP, and CADR-CROCK
inform us that the measure (COUNT FORM) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, TERM-EVAL is
accepted under the principle of definition.




[ 0.0 0.0 0.0 ]

TERM-EVAL


(DEFN OPTIMIZE
      (FORM)
      (IF (LISTP (CDDR FORM))
          (IF (NUMBERP (OPTIMIZE (CADR FORM)))
              (IF (NUMBERP (OPTIMIZE (CADDR FORM)))
                  (CALL (CAR FORM)
                        (OPTIMIZE (CADR FORM))
                        (OPTIMIZE (CADDR FORM)))
                  (LIST (CAR FORM)
                        (OPTIMIZE (CADR FORM))
                        (OPTIMIZE (CADDR FORM))))
              (LIST (CAR FORM)
                    (OPTIMIZE (CADR FORM))
                    (OPTIMIZE (CADDR FORM))))
          FORM))

     Linear arithmetic and the lemmas CADR-CROCK, CAR-LESSP, and CDR-LESSEQP
establish that the measure (COUNT FORM) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, OPTIMIZE is
accepted under the principle of definition.  Observe that:
      (OR (OR (NUMBERP (OPTIMIZE FORM))
              (LISTP (OPTIMIZE FORM)))
          (EQUAL (OPTIMIZE FORM) FORM))
is a theorem.




[ 0.0 0.0 0.0 ]

OPTIMIZE


(DEFN CODEGEN
      (FORM INS)
      (IF (NUMBERP FORM)
          (CONS (LIST 'PUSHI FORM) INS)
          (IF (LISTP (CDDR FORM))
              (CONS (CAR FORM)
                    (CODEGEN (CADDR FORM)
                             (CODEGEN (CADR FORM) INS)))
              (CONS (LIST 'PUSHV FORM) INS))))

     Linear arithmetic and the lemmas CAR-LESSP, CDR-LESSEQP, and CADR-CROCK
inform us that the measure (COUNT FORM) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, CODEGEN is
accepted under the principle of definition.  From the definition we can
conclude that (LISTP (CODEGEN FORM INS)) is a theorem.




[ 0.0 0.0 0.0 ]

CODEGEN


(DEFN COMPILE
      (FORM)
      (REVERSE (CODEGEN (OPTIMIZE FORM) NIL)))

     From the definition we can conclude that:
      (OR (LITATOM (COMPILE FORM))
          (LISTP (COMPILE FORM)))
is a theorem.




[ 0.0 0.0 0.0 ]

COMPILE


(PROVE-LEMMA FORMP-OPTIMIZE
             (REWRITE)
             (IMPLIES (EXPRESSIONP X)
                      (EXPRESSIONP (OPTIMIZE X))))


     Give the conjecture the name *1.


     We will appeal to induction.  Two 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 (AND (LISTP X) (LISTP (CAR X)))
                    (p X))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (LISTP (CDDR X))
                         (EXPRESSIONP (CADR X))
                         (p (CADDR X))
                         (p (CADR X)))
                    (p X))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (LISTP (CDDR X))
                         (NOT (EXPRESSIONP (CADR X)))
                         (p (CADR X)))
                    (p X))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (NOT (LISTP (CDDR X))))
                    (p X))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (NOT (LISTP (CDR X))))
                    (p X))
           (IMPLIES (NOT (LISTP X)) (p X))).
Linear arithmetic and the lemmas CAR-LESSP, CDR-LESSEQP, and CDR-LESSP 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
produces the following seven new conjectures:

Case 7. (IMPLIES (AND (LISTP X)
                      (LISTP (CAR X))
                      (EXPRESSIONP X))
                 (EXPRESSIONP (OPTIMIZE X))).

  This simplifies, expanding the function EXPRESSIONP, to:

        T.

Case 6. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (EXPRESSIONP (CADR X))
                      (NOT (EXPRESSIONP (CADDR X)))
                      (EXPRESSIONP (OPTIMIZE (CADR X)))
                      (EXPRESSIONP X))
                 (EXPRESSIONP (OPTIMIZE X))).

  This simplifies, opening up EXPRESSIONP, to:

        T.

Case 5. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (EXPRESSIONP (CADR X))
                      (EXPRESSIONP (OPTIMIZE (CADDR X)))
                      (EXPRESSIONP (OPTIMIZE (CADR X)))
                      (EXPRESSIONP X))
                 (EXPRESSIONP (OPTIMIZE X))).

  This simplifies, unfolding the definitions of EXPRESSIONP and OPTIMIZE, to
  the following three new conjectures:

  Case 5.3.
          (IMPLIES (AND (LISTP X)
                        (NOT (LISTP (CAR X)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (EXPRESSIONP (CADR X))
                        (EXPRESSIONP (OPTIMIZE (CADDR X)))
                        (EXPRESSIONP (OPTIMIZE (CADR X)))
                        (EXPRESSIONP (CADDR X))
                        (NOT (NUMBERP (OPTIMIZE (CADDR X)))))
                   (EXPRESSIONP (LIST (CAR X)
                                      (OPTIMIZE (CADR X))
                                      (OPTIMIZE (CADDR X))))).

    This again simplifies, rewriting with CDR-CONS and CAR-CONS, and opening
    up the function EXPRESSIONP, to:

          T.

  Case 5.2.
          (IMPLIES (AND (LISTP X)
                        (NOT (LISTP (CAR X)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (EXPRESSIONP (CADR X))
                        (EXPRESSIONP (OPTIMIZE (CADDR X)))
                        (EXPRESSIONP (OPTIMIZE (CADR X)))
                        (EXPRESSIONP (CADDR X))
                        (NOT (NUMBERP (OPTIMIZE (CADR X)))))
                   (EXPRESSIONP (LIST (CAR X)
                                      (OPTIMIZE (CADR X))
                                      (OPTIMIZE (CADDR X))))).

    However this again simplifies, rewriting with CDR-CONS and CAR-CONS, and
    opening up EXPRESSIONP, to:

          T.

  Case 5.1.
          (IMPLIES (AND (LISTP X)
                        (NOT (LISTP (CAR X)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (EXPRESSIONP (CADR X))
                        (EXPRESSIONP (OPTIMIZE (CADDR X)))
                        (EXPRESSIONP (OPTIMIZE (CADR X)))
                        (EXPRESSIONP (CADDR X))
                        (NUMBERP (OPTIMIZE (CADR X)))
                        (NUMBERP (OPTIMIZE (CADDR X))))
                   (EXPRESSIONP (CALL (CAR X)
                                      (OPTIMIZE (CADR X))
                                      (OPTIMIZE (CADDR X))))).

    This again simplifies, opening up the definition of EXPRESSIONP, to:

          T.

Case 4. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (NOT (EXPRESSIONP (CADR X)))
                      (EXPRESSIONP X))
                 (EXPRESSIONP (OPTIMIZE X))),

  which simplifies, unfolding the function EXPRESSIONP, to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (NOT (LISTP (CDDR X)))
                      (EXPRESSIONP X))
                 (EXPRESSIONP (OPTIMIZE X))),

  which simplifies, expanding the definition of EXPRESSIONP, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (NOT (LISTP (CDR X)))
                      (EXPRESSIONP X))
                 (EXPRESSIONP (OPTIMIZE X))),

  which simplifies, unfolding EXPRESSIONP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (EXPRESSIONP X))
                 (EXPRESSIONP (OPTIMIZE X))),

  which simplifies, rewriting with CDR-NLISTP, and expanding the functions
  EXPRESSIONP, OPTIMIZE, CDR, and LISTP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

FORMP-OPTIMIZE


(PROVE-LEMMA CORRECTNESS-OF-OPTIMIZE
             (REWRITE)
             (IMPLIES (EXPRESSIONP X)
                      (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                             (TERM-EVAL X ENVRN))))


     Name the conjecture *1.


     Let us appeal to the induction principle.  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 (AND (LISTP X) (LISTP (CAR X)))
                    (p X ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (LISTP (CDDR X))
                         (EXPRESSIONP (CADR X))
                         (p (CADR X) ENVRN)
                         (p (CADDR X) ENVRN))
                    (p X ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (LISTP (CDDR X))
                         (NOT (EXPRESSIONP (CADR X)))
                         (p (CADR X) ENVRN))
                    (p X ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (NOT (LISTP (CDDR X))))
                    (p X ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (NOT (LISTP (CDR X))))
                    (p X ENVRN))
           (IMPLIES (NOT (LISTP X))
                    (p X ENVRN))).
Linear arithmetic and the lemmas CAR-LESSP, CDR-LESSEQP, and CDR-LESSP 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 leads to the following seven new goals:

Case 7. (IMPLIES (AND (LISTP X)
                      (LISTP (CAR X))
                      (EXPRESSIONP X))
                 (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                        (TERM-EVAL X ENVRN))).

  This simplifies, expanding the definition of EXPRESSIONP, to:

        T.

Case 6. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (EXPRESSIONP (CADR X))
                      (EQUAL (TERM-EVAL (OPTIMIZE (CADR X)) ENVRN)
                             (TERM-EVAL (CADR X) ENVRN))
                      (NOT (EXPRESSIONP (CADDR X)))
                      (EXPRESSIONP X))
                 (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                        (TERM-EVAL X ENVRN))).

  This simplifies, unfolding EXPRESSIONP, to:

        T.

Case 5. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (EXPRESSIONP (CADR X))
                      (EQUAL (TERM-EVAL (OPTIMIZE (CADR X)) ENVRN)
                             (TERM-EVAL (CADR X) ENVRN))
                      (EQUAL (TERM-EVAL (OPTIMIZE (CADDR X)) ENVRN)
                             (TERM-EVAL (CADDR X) ENVRN))
                      (EXPRESSIONP X))
                 (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                        (TERM-EVAL X ENVRN))).

  This simplifies, unfolding the definitions of EXPRESSIONP, OPTIMIZE, and
  TERM-EVAL, to the following three new goals:

  Case 5.3.
          (IMPLIES (AND (LISTP X)
                        (NOT (LISTP (CAR X)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (EXPRESSIONP (CADR X))
                        (EQUAL (TERM-EVAL (OPTIMIZE (CADR X)) ENVRN)
                               (TERM-EVAL (CADR X) ENVRN))
                        (EQUAL (TERM-EVAL (OPTIMIZE (CADDR X)) ENVRN)
                               (TERM-EVAL (CADDR X) ENVRN))
                        (EXPRESSIONP (CADDR X))
                        (NOT (NUMBERP (OPTIMIZE (CADDR X)))))
                   (EQUAL (TERM-EVAL (LIST (CAR X)
                                           (OPTIMIZE (CADR X))
                                           (OPTIMIZE (CADDR X)))
                                     ENVRN)
                          (CALL (CAR X)
                                (TERM-EVAL (CADR X) ENVRN)
                                (TERM-EVAL (CADDR X) ENVRN)))).

    This again simplifies, rewriting with CAR-CONS and CDR-CONS, and expanding
    the definition of TERM-EVAL, to:

          T.

  Case 5.2.
          (IMPLIES (AND (LISTP X)
                        (NOT (LISTP (CAR X)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (EXPRESSIONP (CADR X))
                        (EQUAL (TERM-EVAL (OPTIMIZE (CADR X)) ENVRN)
                               (TERM-EVAL (CADR X) ENVRN))
                        (EQUAL (TERM-EVAL (OPTIMIZE (CADDR X)) ENVRN)
                               (TERM-EVAL (CADDR X) ENVRN))
                        (EXPRESSIONP (CADDR X))
                        (NOT (NUMBERP (OPTIMIZE (CADR X)))))
                   (EQUAL (TERM-EVAL (LIST (CAR X)
                                           (OPTIMIZE (CADR X))
                                           (OPTIMIZE (CADDR X)))
                                     ENVRN)
                          (CALL (CAR X)
                                (TERM-EVAL (CADR X) ENVRN)
                                (TERM-EVAL (CADDR X) ENVRN)))).

    But this again simplifies, appealing to the lemmas CAR-CONS and CDR-CONS,
    and unfolding the function TERM-EVAL, to:

          T.

  Case 5.1.
          (IMPLIES (AND (LISTP X)
                        (NOT (LISTP (CAR X)))
                        (LISTP (CDR X))
                        (LISTP (CDDR X))
                        (EXPRESSIONP (CADR X))
                        (EQUAL (TERM-EVAL (OPTIMIZE (CADR X)) ENVRN)
                               (TERM-EVAL (CADR X) ENVRN))
                        (EQUAL (TERM-EVAL (OPTIMIZE (CADDR X)) ENVRN)
                               (TERM-EVAL (CADDR X) ENVRN))
                        (EXPRESSIONP (CADDR X))
                        (NUMBERP (OPTIMIZE (CADR X)))
                        (NUMBERP (OPTIMIZE (CADDR X))))
                   (EQUAL (TERM-EVAL (CALL (CAR X)
                                           (OPTIMIZE (CADR X))
                                           (OPTIMIZE (CADDR X)))
                                     ENVRN)
                          (CALL (CAR X)
                                (TERM-EVAL (CADR X) ENVRN)
                                (TERM-EVAL (CADDR X) ENVRN)))),

    which again simplifies, unfolding TERM-EVAL, to:

          T.

Case 4. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (NOT (EXPRESSIONP (CADR X)))
                      (EXPRESSIONP X))
                 (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                        (TERM-EVAL X ENVRN))),

  which simplifies, expanding the definition of EXPRESSIONP, to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (NOT (LISTP (CDDR X)))
                      (EXPRESSIONP X))
                 (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                        (TERM-EVAL X ENVRN))),

  which simplifies, opening up the definition of EXPRESSIONP, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (NOT (LISTP (CDR X)))
                      (EXPRESSIONP X))
                 (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                        (TERM-EVAL X ENVRN))),

  which simplifies, unfolding EXPRESSIONP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (EXPRESSIONP X))
                 (EQUAL (TERM-EVAL (OPTIMIZE X) ENVRN)
                        (TERM-EVAL X ENVRN))),

  which simplifies, rewriting with CDR-NLISTP, and opening up EXPRESSIONP,
  OPTIMIZE, CDR, LISTP, and TERM-EVAL, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.1 0.0 ]

CORRECTNESS-OF-OPTIMIZE


(DEFN EXEC
      (PC PDS ENVRN)
      (IF (NLISTP PC)
          PDS
          (IF (LISTP (CAR PC))
              (IF (EQUAL (CAAR PC) 'PUSHI)
                  (EXEC (CDR PC)
                        (PUSH (CADAR PC) PDS)
                        ENVRN)
                  (EXEC (CDR PC)
                        (PUSH (GETVALUE (CADAR PC) ENVRN) PDS)
                        ENVRN))
              (EXEC (CDR PC)
                    (PUSH (CALL (CAR PC)
                                (TOP (POP PDS))
                                (TOP PDS))
                          (POP (POP PDS)))
                    ENVRN))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP can be used to establish that the measure (COUNT PC)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, EXEC is accepted under the principle of definition.  From the
definition we can conclude that:
      (OR (STACKP (EXEC PC PDS ENVRN))
          (EQUAL (EXEC PC PDS ENVRN) PDS))
is a theorem.




[ 0.0 0.0 0.0 ]

EXEC


(PROVE-LEMMA SEQUENTIAL-EXECUTION
             (REWRITE)
             (EQUAL (EXEC (APPEND X Y) PDS ENVRN)
                    (EXEC Y (EXEC X PDS ENVRN) ENVRN)))


     Call the conjecture *1.


     We will try to prove it by induction.  There are three plausible
inductions.  They merge into two likely candidate inductions.  However, only
one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (p (CDR X)
                            Y
                            (PUSH (CALL (CAR X)
                                        (TOP (POP PDS))
                                        (TOP PDS))
                                  (POP (POP PDS)))
                            ENVRN)
                         (p (CDR X)
                            Y
                            (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                            ENVRN)
                         (p (CDR X)
                            Y
                            (PUSH (CADAR X) PDS)
                            ENVRN))
                    (p X Y PDS ENVRN))
           (IMPLIES (NOT (LISTP X))
                    (p X Y PDS ENVRN))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for PDS.  The
above induction scheme generates two new goals:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (EXEC (APPEND (CDR X) Y)
                                   (PUSH (CALL (CAR X)
                                               (TOP (POP PDS))
                                               (TOP PDS))
                                         (POP (POP PDS)))
                                   ENVRN)
                             (EXEC Y
                                   (EXEC (CDR X)
                                         (PUSH (CALL (CAR X)
                                                     (TOP (POP PDS))
                                                     (TOP PDS))
                                               (POP (POP PDS)))
                                         ENVRN)
                                   ENVRN))
                      (EQUAL (EXEC (APPEND (CDR X) Y)
                                   (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                   ENVRN)
                             (EXEC Y
                                   (EXEC (CDR X)
                                         (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                         ENVRN)
                                   ENVRN))
                      (EQUAL (EXEC (APPEND (CDR X) Y)
                                   (PUSH (CADAR X) PDS)
                                   ENVRN)
                             (EXEC Y
                                   (EXEC (CDR X)
                                         (PUSH (CADAR X) PDS)
                                         ENVRN)
                                   ENVRN)))
                 (EQUAL (EXEC (APPEND X Y) PDS ENVRN)
                        (EXEC Y (EXEC X PDS ENVRN) ENVRN))),

  which simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  unfolding APPEND and EXEC, to three new formulas:

  Case 2.3.
          (IMPLIES
                  (AND (LISTP X)
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (CALL (CAR X)
                                                (TOP (POP PDS))
                                                (TOP PDS))
                                          (POP (POP PDS)))
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (CALL (CAR X)
                                                      (TOP (POP PDS))
                                                      (TOP PDS))
                                                (POP (POP PDS)))
                                          ENVRN)
                                    ENVRN))
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                          ENVRN)
                                    ENVRN))
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (CADAR X) PDS)
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (CADAR X) PDS)
                                          ENVRN)
                                    ENVRN))
                       (NOT (LISTP (CAR X))))
                  (EQUAL (EXEC (APPEND (CDR X) Y)
                               (PUSH (CALL (CAR X)
                                           (TOP (POP PDS))
                                           (TOP PDS))
                                     (POP (POP PDS)))
                               ENVRN)
                         (EXEC Y
                               (EXEC (CDR X)
                                     (PUSH (CALL (CAR X)
                                                 (TOP (POP PDS))
                                                 (TOP PDS))
                                           (POP (POP PDS)))
                                     ENVRN)
                               ENVRN))),

    which again simplifies, clearly, to:

          T.

  Case 2.2.
          (IMPLIES
                  (AND (LISTP X)
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (CALL (CAR X)
                                                (TOP (POP PDS))
                                                (TOP PDS))
                                          (POP (POP PDS)))
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (CALL (CAR X)
                                                      (TOP (POP PDS))
                                                      (TOP PDS))
                                                (POP (POP PDS)))
                                          ENVRN)
                                    ENVRN))
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                          ENVRN)
                                    ENVRN))
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (CADAR X) PDS)
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (CADAR X) PDS)
                                          ENVRN)
                                    ENVRN))
                       (LISTP (CAR X))
                       (EQUAL (CAAR X) 'PUSHI))
                  (EQUAL (EXEC (APPEND (CDR X) Y)
                               (PUSH (CADAR X) PDS)
                               ENVRN)
                         (EXEC Y
                               (EXEC (CDR X)
                                     (PUSH (CADAR X) PDS)
                                     ENVRN)
                               ENVRN))).

    This again simplifies, trivially, to:

          T.

  Case 2.1.
          (IMPLIES
                  (AND (LISTP X)
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (CALL (CAR X)
                                                (TOP (POP PDS))
                                                (TOP PDS))
                                          (POP (POP PDS)))
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (CALL (CAR X)
                                                      (TOP (POP PDS))
                                                      (TOP PDS))
                                                (POP (POP PDS)))
                                          ENVRN)
                                    ENVRN))
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                          ENVRN)
                                    ENVRN))
                       (EQUAL (EXEC (APPEND (CDR X) Y)
                                    (PUSH (CADAR X) PDS)
                                    ENVRN)
                              (EXEC Y
                                    (EXEC (CDR X)
                                          (PUSH (CADAR X) PDS)
                                          ENVRN)
                                    ENVRN))
                       (LISTP (CAR X))
                       (NOT (EQUAL (CAAR X) 'PUSHI)))
                  (EQUAL (EXEC (APPEND (CDR X) Y)
                               (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                               ENVRN)
                         (EXEC Y
                               (EXEC (CDR X)
                                     (PUSH (GETVALUE (CADAR X) ENVRN) PDS)
                                     ENVRN)
                               ENVRN))).

    This again simplifies, clearly, to:

          T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (EQUAL (EXEC (APPEND X Y) PDS ENVRN)
                        (EXEC Y (EXEC X PDS ENVRN) ENVRN))).

  This simplifies, opening up the functions APPEND and EXEC, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SEQUENTIAL-EXECUTION


(PROVE-LEMMA CORRECTNESS-OF-CODEGEN
             (REWRITE)
             (IMPLIES (EXPRESSIONP X)
                      (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                                   PDS ENVRN)
                             (PUSH (TERM-EVAL X ENVRN)
                                   (EXEC (REVERSE INS) PDS ENVRN)))))


     Call the conjecture *1.


     We will appeal to induction.  Four inductions are suggested by terms in
the conjecture.  They merge into two likely candidate inductions.  However,
only one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X) (LISTP (CAR X)))
                    (p X INS PDS ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (LISTP (CDDR X))
                         (EXPRESSIONP (CADR X))
                         (p (CADR X) INS PDS ENVRN)
                         (p (CADDR X)
                            (CODEGEN (CADR X) INS)
                            PDS ENVRN))
                    (p X INS PDS ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (LISTP (CDDR X))
                         (NOT (EXPRESSIONP (CADR X)))
                         (p (CADR X) INS PDS ENVRN))
                    (p X INS PDS ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (LISTP (CDR X))
                         (NOT (LISTP (CDDR X))))
                    (p X INS PDS ENVRN))
           (IMPLIES (AND (LISTP X)
                         (NOT (LISTP (CAR X)))
                         (NOT (LISTP (CDR X))))
                    (p X INS PDS ENVRN))
           (IMPLIES (NOT (LISTP X))
                    (p X INS PDS ENVRN))).
Linear arithmetic and the lemmas CAR-LESSP, CDR-LESSEQP, and CDR-LESSP inform
us that the measure (COUNT X) decreases according to the well-founded relation
LESSP in each induction step of the scheme.  Note, however, the inductive
instances chosen for INS.  The above induction scheme leads to the following
seven new conjectures:

Case 7. (IMPLIES (AND (LISTP X)
                      (LISTP (CAR X))
                      (EXPRESSIONP X))
                 (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                              PDS ENVRN)
                        (PUSH (TERM-EVAL X ENVRN)
                              (EXEC (REVERSE INS) PDS ENVRN)))).

  This simplifies, unfolding the function EXPRESSIONP, to:

        T.

Case 6. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (EXPRESSIONP (CADR X))
                      (EQUAL (EXEC (REVERSE (CODEGEN (CADR X) INS))
                                   PDS ENVRN)
                             (PUSH (TERM-EVAL (CADR X) ENVRN)
                                   (EXEC (REVERSE INS) PDS ENVRN)))
                      (NOT (EXPRESSIONP (CADDR X)))
                      (EXPRESSIONP X))
                 (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                              PDS ENVRN)
                        (PUSH (TERM-EVAL X ENVRN)
                              (EXEC (REVERSE INS) PDS ENVRN)))).

  This simplifies, expanding EXPRESSIONP, to:

        T.

Case 5. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (EXPRESSIONP (CADR X))
                      (EQUAL (EXEC (REVERSE (CODEGEN (CADR X) INS))
                                   PDS ENVRN)
                             (PUSH (TERM-EVAL (CADR X) ENVRN)
                                   (EXEC (REVERSE INS) PDS ENVRN)))
                      (EQUAL (EXEC (REVERSE (CODEGEN (CADDR X)
                                                     (CODEGEN (CADR X) INS)))
                                   PDS ENVRN)
                             (PUSH (TERM-EVAL (CADDR X) ENVRN)
                                   (EXEC (REVERSE (CODEGEN (CADR X) INS))
                                         PDS ENVRN)))
                      (EXPRESSIONP X))
                 (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                              PDS ENVRN)
                        (PUSH (TERM-EVAL X ENVRN)
                              (EXEC (REVERSE INS) PDS ENVRN)))).

  This simplifies, rewriting with CAR-CONS, CDR-CONS, SEQUENTIAL-EXECUTION,
  TOP-PUSH, and PUSH-EQUAL, and opening up the functions EXPRESSIONP, CODEGEN,
  REVERSE, EXEC, LISTP, and TERM-EVAL, to two new formulas:

  Case 5.2.
          (IMPLIES
           (AND (LISTP X)
                (NOT (LISTP (CAR X)))
                (LISTP (CDR X))
                (LISTP (CDDR X))
                (EXPRESSIONP (CADR X))
                (EQUAL (EXEC (REVERSE (CODEGEN (CADR X) INS))
                             PDS ENVRN)
                       (PUSH (TERM-EVAL (CADR X) ENVRN)
                             (EXEC (REVERSE INS) PDS ENVRN)))
                (EQUAL (EXEC (REVERSE (CODEGEN (CADDR X)
                                               (CODEGEN (CADR X) INS)))
                             PDS ENVRN)
                       (PUSH (TERM-EVAL (CADDR X) ENVRN)
                             (EXEC (REVERSE (CODEGEN (CADR X) INS))
                                   PDS ENVRN)))
                (EXPRESSIONP (CADDR X)))
           (EQUAL
               (CALL (CAR X)
                     (TOP (POP (EXEC (REVERSE (CODEGEN (CADDR X)
                                                       (CODEGEN (CADR X) INS)))
                                     PDS ENVRN)))
                     (TOP (EXEC (REVERSE (CODEGEN (CADDR X)
                                                  (CODEGEN (CADR X) INS)))
                                PDS ENVRN)))
               (CALL (CAR X)
                     (TERM-EVAL (CADR X) ENVRN)
                     (TERM-EVAL (CADDR X) ENVRN)))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
    (CAR X) and (CDR X), V by (CONS D W) to eliminate (CDR V) and (CAR V), and
    W by (CONS V C) to eliminate (CAR W) and (CDR W).  We thus obtain:

          (IMPLIES
             (AND (NOT (LISTP Z))
                  (EXPRESSIONP D)
                  (EQUAL (EXEC (REVERSE (CODEGEN D INS))
                               PDS ENVRN)
                         (PUSH (TERM-EVAL D ENVRN)
                               (EXEC (REVERSE INS) PDS ENVRN)))
                  (EQUAL (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                               PDS ENVRN)
                         (PUSH (TERM-EVAL V ENVRN)
                               (EXEC (REVERSE (CODEGEN D INS))
                                     PDS ENVRN)))
                  (EXPRESSIONP V))
             (EQUAL (CALL Z
                          (TOP (POP (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                          PDS ENVRN)))
                          (TOP (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                     PDS ENVRN)))
                    (CALL Z
                          (TERM-EVAL D ENVRN)
                          (TERM-EVAL V ENVRN)))).

    We use the first equality hypothesis by substituting:
          (PUSH (TERM-EVAL D ENVRN)
                (EXEC (REVERSE INS) PDS ENVRN))
    for (EXEC (REVERSE (CODEGEN D INS)) PDS ENVRN) and throwing away the
    equality.  The result is the conjecture:

          (IMPLIES
             (AND (NOT (LISTP Z))
                  (EXPRESSIONP D)
                  (EQUAL (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                               PDS ENVRN)
                         (PUSH (TERM-EVAL V ENVRN)
                               (PUSH (TERM-EVAL D ENVRN)
                                     (EXEC (REVERSE INS) PDS ENVRN))))
                  (EXPRESSIONP V))
             (EQUAL (CALL Z
                          (TOP (POP (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                          PDS ENVRN)))
                          (TOP (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                     PDS ENVRN)))
                    (CALL Z
                          (TERM-EVAL D ENVRN)
                          (TERM-EVAL V ENVRN)))).

    We use the above equality hypothesis by substituting:
          (PUSH (TERM-EVAL V ENVRN)
                (PUSH (TERM-EVAL D ENVRN)
                      (EXEC (REVERSE INS) PDS ENVRN)))
    for (EXEC (REVERSE (CODEGEN V (CODEGEN D INS))) PDS ENVRN) and throwing
    away the equality.  This produces the new conjecture:

          (IMPLIES
           (AND (NOT (LISTP Z))
                (EXPRESSIONP D)
                (EXPRESSIONP V))
           (EQUAL
                 (CALL Z
                       (TOP (POP (PUSH (TERM-EVAL V ENVRN)
                                       (PUSH (TERM-EVAL D ENVRN)
                                             (EXEC (REVERSE INS) PDS ENVRN)))))
                       (TOP (PUSH (TERM-EVAL V ENVRN)
                                  (PUSH (TERM-EVAL D ENVRN)
                                        (EXEC (REVERSE INS) PDS ENVRN)))))
                 (CALL Z
                       (TERM-EVAL D ENVRN)
                       (TERM-EVAL V ENVRN)))),

    which further simplifies, applying POP-PUSH and TOP-PUSH, to:

          T.

  Case 5.1.
          (IMPLIES
              (AND (LISTP X)
                   (NOT (LISTP (CAR X)))
                   (LISTP (CDR X))
                   (LISTP (CDDR X))
                   (EXPRESSIONP (CADR X))
                   (EQUAL (EXEC (REVERSE (CODEGEN (CADR X) INS))
                                PDS ENVRN)
                          (PUSH (TERM-EVAL (CADR X) ENVRN)
                                (EXEC (REVERSE INS) PDS ENVRN)))
                   (EQUAL (EXEC (REVERSE (CODEGEN (CADDR X)
                                                  (CODEGEN (CADR X) INS)))
                                PDS ENVRN)
                          (PUSH (TERM-EVAL (CADDR X) ENVRN)
                                (EXEC (REVERSE (CODEGEN (CADR X) INS))
                                      PDS ENVRN)))
                   (EXPRESSIONP (CADDR X)))
              (EQUAL (POP (POP (EXEC (REVERSE (CODEGEN (CADDR X)
                                                       (CODEGEN (CADR X) INS)))
                                     PDS ENVRN)))
                     (EXEC (REVERSE INS) PDS ENVRN))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS Z V) to
    eliminate (CAR X) and (CDR X), V by (CONS D W) to eliminate (CDR V) and
    (CAR V), and W by (CONS V C) to eliminate (CAR W) and (CDR W).  The result
    is:

          (IMPLIES (AND (NOT (LISTP Z))
                        (EXPRESSIONP D)
                        (EQUAL (EXEC (REVERSE (CODEGEN D INS))
                                     PDS ENVRN)
                               (PUSH (TERM-EVAL D ENVRN)
                                     (EXEC (REVERSE INS) PDS ENVRN)))
                        (EQUAL (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                     PDS ENVRN)
                               (PUSH (TERM-EVAL V ENVRN)
                                     (EXEC (REVERSE (CODEGEN D INS))
                                           PDS ENVRN)))
                        (EXPRESSIONP V))
                   (EQUAL (POP (POP (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                          PDS ENVRN)))
                          (EXEC (REVERSE INS) PDS ENVRN))).

    We use the first equality hypothesis by substituting:
          (PUSH (TERM-EVAL D ENVRN)
                (EXEC (REVERSE INS) PDS ENVRN))
    for (EXEC (REVERSE (CODEGEN D INS)) PDS ENVRN) and throwing away the
    equality.  This produces:

          (IMPLIES (AND (NOT (LISTP Z))
                        (EXPRESSIONP D)
                        (EQUAL (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                     PDS ENVRN)
                               (PUSH (TERM-EVAL V ENVRN)
                                     (PUSH (TERM-EVAL D ENVRN)
                                           (EXEC (REVERSE INS) PDS ENVRN))))
                        (EXPRESSIONP V))
                   (EQUAL (POP (POP (EXEC (REVERSE (CODEGEN V (CODEGEN D INS)))
                                          PDS ENVRN)))
                          (EXEC (REVERSE INS) PDS ENVRN))).

    We use the above equality hypothesis by substituting:
          (PUSH (TERM-EVAL V ENVRN)
                (PUSH (TERM-EVAL D ENVRN)
                      (EXEC (REVERSE INS) PDS ENVRN)))
    for (EXEC (REVERSE (CODEGEN V (CODEGEN D INS))) PDS ENVRN) and throwing
    away the equality.  This generates:

          (IMPLIES
                (AND (NOT (LISTP Z))
                     (EXPRESSIONP D)
                     (EXPRESSIONP V))
                (EQUAL (POP (POP (PUSH (TERM-EVAL V ENVRN)
                                       (PUSH (TERM-EVAL D ENVRN)
                                             (EXEC (REVERSE INS) PDS ENVRN)))))
                       (EXEC (REVERSE INS) PDS ENVRN))).

    This further simplifies, applying POP-PUSH, to:

          T.

Case 4. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (LISTP (CDDR X))
                      (NOT (EXPRESSIONP (CADR X)))
                      (EXPRESSIONP X))
                 (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                              PDS ENVRN)
                        (PUSH (TERM-EVAL X ENVRN)
                              (EXEC (REVERSE INS) PDS ENVRN)))).

  This simplifies, expanding EXPRESSIONP, to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (LISTP (CDR X))
                      (NOT (LISTP (CDDR X)))
                      (EXPRESSIONP X))
                 (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                              PDS ENVRN)
                        (PUSH (TERM-EVAL X ENVRN)
                              (EXEC (REVERSE INS) PDS ENVRN)))).

  This simplifies, expanding EXPRESSIONP, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (CAR X)))
                      (NOT (LISTP (CDR X)))
                      (EXPRESSIONP X))
                 (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                              PDS ENVRN)
                        (PUSH (TERM-EVAL X ENVRN)
                              (EXEC (REVERSE INS) PDS ENVRN)))).

  This simplifies, opening up the definition of EXPRESSIONP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (EXPRESSIONP X))
                 (EQUAL (EXEC (REVERSE (CODEGEN X INS))
                              PDS ENVRN)
                        (PUSH (TERM-EVAL X ENVRN)
                              (EXEC (REVERSE INS) PDS ENVRN)))).

  This simplifies, applying CDR-NLISTP, and expanding the functions
  EXPRESSIONP, CODEGEN, CDR, LISTP, and TERM-EVAL, to two new goals:

  Case 1.2.
          (IMPLIES (AND (NOT (LISTP X))
                        (NOT (NUMBERP X)))
                   (EQUAL (EXEC (REVERSE (CONS (LIST 'PUSHV X) INS))
                                PDS ENVRN)
                          (PUSH (GETVALUE X ENVRN)
                                (EXEC (REVERSE INS) PDS ENVRN)))),

    which again simplifies, rewriting with CAR-CONS, CDR-CONS, and
    SEQUENTIAL-EXECUTION, and unfolding the functions REVERSE, EQUAL, EXEC,
    and LISTP, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (LISTP X)) (NUMBERP X))
                   (EQUAL (EXEC (REVERSE (CONS (LIST 'PUSHI X) INS))
                                PDS ENVRN)
                          (PUSH X
                                (EXEC (REVERSE INS) PDS ENVRN)))).

    However this again simplifies, appealing to the lemmas CAR-CONS, CDR-CONS,
    and SEQUENTIAL-EXECUTION, and opening up the definitions of REVERSE, EQUAL,
    EXEC, and LISTP, to:

          T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.2 0.0 ]

CORRECTNESS-OF-CODEGEN


(PROVE-LEMMA CORRECTNESS-OF-OPTIMIZING-COMPILER NIL
             (IMPLIES (EXPRESSIONP X)
                      (EQUAL (EXEC (COMPILE X) PDS ENVRN)
                             (PUSH (TERM-EVAL X ENVRN) PDS))))

This conjecture can be simplified, using the abbreviations IMPLIES and COMPILE,
to:

      (IMPLIES (EXPRESSIONP X)
               (EQUAL (EXEC (REVERSE (CODEGEN (OPTIMIZE X) NIL))
                            PDS ENVRN)
                      (PUSH (TERM-EVAL X ENVRN) PDS))).

This simplifies, applying FORMP-OPTIMIZE, CORRECTNESS-OF-OPTIMIZE, and
CORRECTNESS-OF-CODEGEN, and expanding REVERSE, LISTP, and EXEC, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

CORRECTNESS-OF-OPTIMIZING-COMPILER


(PROVE-LEMMA TRANSITIVITY-OF-LESSP NIL
             (IMPLIES (AND (LESSP X Y) (LESSP Y Z))
                      (LESSP X Z)))

This simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TRANSITIVITY-OF-LESSP


(PROVE-LEMMA LESSP-NOT-REFLEXIVE NIL
             (NOT (LESSP X X)))

This conjecture simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

LESSP-NOT-REFLEXIVE


(DEFN EQP
      (X Y)
      (EQUAL (FIX X) (FIX Y)))

     Note that (OR (FALSEP (EQP X Y)) (TRUEP (EQP X Y))) is a theorem.




[ 0.0 0.0 0.0 ]

EQP


(PROVE-LEMMA TRICHOTOMY-OF-LESSP NIL
             (IMPLIES (AND (NOT (EQP X Y))
                           (NOT (LESSP Y X)))
                      (LESSP X Y)))

This conjecture simplifies, using linear arithmetic, to the following three
new conjectures:

Case 3. (IMPLIES (AND (NOT (NUMBERP Y))
                      (NOT (EQP X Y))
                      (NOT (LESSP Y X)))
                 (LESSP X Y)).

  However this again simplifies, expanding the definitions of EQP and LESSP,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (NUMBERP X))
                      (NOT (EQP X Y))
                      (NOT (LESSP Y X)))
                 (LESSP X Y)),

  which again simplifies, unfolding the functions EQP and LESSP, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X)
                      (NUMBERP Y)
                      (NOT (EQP X X))
                      (NOT (LESSP X X)))
                 (LESSP X X)),

  which again simplifies, expanding the function EQP, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TRICHOTOMY-OF-LESSP


(PROVE-LEMMA REVERSE-REVERSE
             (REWRITE)
             (IMPLIES (PLISTP X)
                      (EQUAL (REVERSE (REVERSE X)) X)))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  Two 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 X) (p X))
           (IMPLIES (AND (NOT (NLISTP X)) (p (CDR X)))
                    (p X))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish 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 three new conjectures:

Case 3. (IMPLIES (AND (NLISTP X) (PLISTP X))
                 (EQUAL (REVERSE (REVERSE X)) X)),

  which simplifies, expanding the functions NLISTP, PLISTP, REVERSE, and EQUAL,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP X))
                      (NOT (PLISTP (CDR X)))
                      (PLISTP X))
                 (EQUAL (REVERSE (REVERSE X)) X)),

  which simplifies, opening up the functions NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP X))
                      (EQUAL (REVERSE (REVERSE (CDR X)))
                             (CDR X))
                      (PLISTP X))
                 (EQUAL (REVERSE (REVERSE X)) X)),

  which simplifies, applying the lemmas CAR-CONS, CDR-CONS, CONS-CAR-CDR, and
  APPEND-REVERSE, and opening up NLISTP, PLISTP, REVERSE, APPEND, and LISTP,
  to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

REVERSE-REVERSE


(DEFN FLATTEN
      (X)
      (IF (LISTP X)
          (APPEND (FLATTEN (CAR X))
                  (FLATTEN (CDR X)))
          (CONS X NIL)))

     Linear arithmetic and the lemmas CDR-LESSP and CAR-LESSP inform us that
the measure (COUNT X) decreases according to the well-founded relation LESSP
in each recursive call.  Hence, FLATTEN is accepted under the principle of
definition.  Note that (LISTP (FLATTEN X)) is a theorem.




[ 0.0 0.0 0.0 ]

FLATTEN


(DEFN MC-FLATTEN
      (X Y)
      (IF (LISTP X)
          (MC-FLATTEN (CAR X)
                      (MC-FLATTEN (CDR X) Y))
          (CONS X Y)))

     Linear arithmetic and the lemmas CAR-LESSP and CDR-LESSP can be used to
show that the measure (COUNT X) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, MC-FLATTEN is accepted under
the definitional principle.  From the definition we can conclude that
(LISTP (MC-FLATTEN X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

MC-FLATTEN


(PROVE-LEMMA FLATTEN-MC-FLATTEN
             (REWRITE)
             (EQUAL (MC-FLATTEN X Y)
                    (APPEND (FLATTEN X) Y)))


     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 (AND (LISTP X)
                         (p (CAR X) (MC-FLATTEN (CDR X) Y))
                         (p (CDR X) Y))
                    (p X Y))
           (IMPLIES (NOT (LISTP X)) (p X Y))).
Linear arithmetic and the lemmas CAR-LESSP and CDR-LESSP establish that the
measure (COUNT X) decreases according to the well-founded relation LESSP in
each induction step of the scheme.  Note, however, the inductive instances
chosen for Y.  The above induction scheme produces the following two new goals:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (MC-FLATTEN (CAR X)
                                         (MC-FLATTEN (CDR X) Y))
                             (APPEND (FLATTEN (CAR X))
                                     (MC-FLATTEN (CDR X) Y)))
                      (EQUAL (MC-FLATTEN (CDR X) Y)
                             (APPEND (FLATTEN (CDR X)) Y)))
                 (EQUAL (MC-FLATTEN X Y)
                        (APPEND (FLATTEN X) Y))).

  This simplifies, applying ASSOCIATIVITY-OF-APPEND, and unfolding the
  definitions of MC-FLATTEN and FLATTEN, to:

        T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (EQUAL (MC-FLATTEN X Y)
                        (APPEND (FLATTEN X) Y))),

  which simplifies, rewriting with CDR-CONS and CAR-CONS, and expanding the
  definitions of MC-FLATTEN, FLATTEN, APPEND, and LISTP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

FLATTEN-MC-FLATTEN


(PROVE-LEMMA MEMBER-APPEND
             (REWRITE)
             (EQUAL (MEMBER X (APPEND A B))
                    (OR (MEMBER X A) (MEMBER X B))))

This simplifies, opening up the function OR, to two new conjectures:

Case 2. (IMPLIES (NOT (MEMBER X A))
                 (EQUAL (MEMBER X (APPEND A B))
                        (MEMBER X B))),

  which we will name *1.

Case 1. (IMPLIES (MEMBER X A)
                 (EQUAL (MEMBER X (APPEND A B)) T)).

  This again simplifies, trivially, to the new formula:

        (IMPLIES (MEMBER X A)
                 (MEMBER X (APPEND A B))),

  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 (MEMBER X (APPEND A B))
       (OR (MEMBER X A) (MEMBER X B))).

We named this *1.  We will try to prove it by induction.  There are three
plausible inductions.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP A) (p X (CDR A) B))
                    (p X A B))
           (IMPLIES (NOT (LISTP A)) (p X A B))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT A)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates two new conjectures:

Case 2. (IMPLIES (AND (LISTP A)
                      (EQUAL (MEMBER X (APPEND (CDR A) B))
                             (OR (MEMBER X (CDR A)) (MEMBER X B))))
                 (EQUAL (MEMBER X (APPEND A B))
                        (OR (MEMBER X A) (MEMBER X B)))),

  which simplifies, applying CDR-CONS and CAR-CONS, and unfolding OR, APPEND,
  MEMBER, and EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP A))
                 (EQUAL (MEMBER X (APPEND A B))
                        (OR (MEMBER X A) (MEMBER X B)))).

  This simplifies, expanding the functions APPEND, MEMBER, and OR, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

MEMBER-APPEND


(PROVE-LEMMA MEMBER-REVERSE
             (REWRITE)
             (EQUAL (MEMBER X (REVERSE Y))
                    (MEMBER X Y)))


     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 (AND (LISTP Y) (p X (CDR Y)))
                    (p X Y))
           (IMPLIES (NOT (LISTP Y)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces the following two new
goals:

Case 2. (IMPLIES (AND (LISTP Y)
                      (EQUAL (MEMBER X (REVERSE (CDR Y)))
                             (MEMBER X (CDR Y))))
                 (EQUAL (MEMBER X (REVERSE Y))
                        (MEMBER X Y))).

  This simplifies, applying CDR-CONS, CAR-CONS, and MEMBER-APPEND, and
  unfolding the definitions of REVERSE, MEMBER, and LISTP, to three new
  formulas:

  Case 2.3.
          (IMPLIES (AND (LISTP Y)
                        (EQUAL (MEMBER X (REVERSE (CDR Y)))
                               (MEMBER X (CDR Y)))
                        (NOT (EQUAL X (CAR Y)))
                        (NOT (MEMBER X (CDR Y))))
                   (EQUAL (EQUAL X (CAR Y))
                          (MEMBER X (CDR Y)))),

    which again simplifies, clearly, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP Y)
                        (EQUAL (MEMBER X (REVERSE (CDR Y)))
                               (MEMBER X (CDR Y)))
                        (NOT (EQUAL X (CAR Y)))
                        (MEMBER X (CDR Y)))
                   (EQUAL T (MEMBER X (CDR Y)))).

    This again simplifies, clearly, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP Y)
                        (EQUAL (MEMBER X (REVERSE (CDR Y)))
                               (MEMBER X (CDR Y)))
                        (EQUAL X (CAR Y))
                        (NOT (MEMBER X (CDR Y))))
                   (EQUAL (EQUAL X (CAR Y)) T)).

    But this again simplifies, unfolding EQUAL, to:

          T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (EQUAL (MEMBER X (REVERSE Y))
                        (MEMBER X Y))),

  which simplifies, opening up the functions REVERSE, LISTP, MEMBER, and EQUAL,
  to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

MEMBER-REVERSE


(DEFN LENGTH
      (X)
      (IF (LISTP X)
          (ADD1 (LENGTH (CDR X)))
          0))

     Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, LENGTH is accepted under the principle of definition.
From the definition we can conclude that (NUMBERP (LENGTH X)) is a theorem.




[ 0.0 0.0 0.0 ]

LENGTH


(PROVE-LEMMA LENGTH-REVERSE
             (REWRITE)
             (EQUAL (LENGTH (REVERSE X))
                    (LENGTH X)))


     Give the conjecture the name *1.


     We will appeal to induction.  Two 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 (AND (LISTP X) (p (CDR X)))
                    (p X))
           (IMPLIES (NOT (LISTP X)) (p X))).
Linear arithmetic and the lemma CDR-LESSP 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 produces the following two new
conjectures:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (LENGTH (REVERSE (CDR X)))
                             (LENGTH (CDR X))))
                 (EQUAL (LENGTH (REVERSE X))
                        (LENGTH X))).

  This simplifies, expanding the functions REVERSE and LENGTH, to the new goal:

        (IMPLIES (AND (LISTP X)
                      (EQUAL (LENGTH (REVERSE (CDR X)))
                             (LENGTH (CDR X))))
                 (EQUAL (LENGTH (APPEND (REVERSE (CDR X))
                                        (LIST (CAR X))))
                        (ADD1 (LENGTH (CDR X))))).

  Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate
  (CDR X) and (CAR X).  This produces:

        (IMPLIES (EQUAL (LENGTH (REVERSE Z))
                        (LENGTH Z))
                 (EQUAL (LENGTH (APPEND (REVERSE Z) (LIST V)))
                        (ADD1 (LENGTH Z)))).

  We use the above equality hypothesis by substituting (LENGTH (REVERSE Z))
  for (LENGTH Z) and throwing away the equality.  We must thus prove:

        (EQUAL (LENGTH (APPEND (REVERSE Z) (LIST V)))
               (ADD1 (LENGTH (REVERSE Z)))).

  We will try to prove the above formula by generalizing it, replacing
  (REVERSE Z) by Y.  We restrict the new variable by recalling PLISTP-REVERSE.
  This produces the new conjecture:

        (IMPLIES (PLISTP Y)
                 (EQUAL (LENGTH (APPEND Y (LIST V)))
                        (ADD1 (LENGTH Y)))),

  which we will name *1.1.

Case 1. (IMPLIES (NOT (LISTP X))
                 (EQUAL (LENGTH (REVERSE X))
                        (LENGTH X))).

  This simplifies, opening up REVERSE, LENGTH, and EQUAL, to:

        T.


     So next consider:

      (IMPLIES (PLISTP Y)
               (EQUAL (LENGTH (APPEND Y (LIST V)))
                      (ADD1 (LENGTH Y)))),

which we named *1.1 above.  Perhaps we can prove it by induction.  There are
three plausible inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP Y) (p Y V))
           (IMPLIES (AND (NOT (NLISTP Y)) (p (CDR Y) V))
                    (p Y V))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT Y) 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 (NLISTP Y) (PLISTP Y))
                 (EQUAL (LENGTH (APPEND Y (LIST V)))
                        (ADD1 (LENGTH Y)))).

  This simplifies, applying the lemma CDR-CONS, and expanding the functions
  NLISTP, PLISTP, LISTP, APPEND, ADD1, LENGTH, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (PLISTP (CDR Y)))
                      (PLISTP Y))
                 (EQUAL (LENGTH (APPEND Y (LIST V)))
                        (ADD1 (LENGTH Y)))).

  This simplifies, unfolding NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (EQUAL (LENGTH (APPEND (CDR Y) (LIST V)))
                             (ADD1 (LENGTH (CDR Y))))
                      (PLISTP Y))
                 (EQUAL (LENGTH (APPEND Y (LIST V)))
                        (ADD1 (LENGTH Y)))).

  This simplifies, applying CDR-CONS, and opening up NLISTP, PLISTP, APPEND,
  and LENGTH, to:

        T.


     That finishes the proof of *1.1, which, in turn, finishes the proof of *1.
Q.E.D.


[ 0.0 0.0 0.0 ]

LENGTH-REVERSE


(DEFN INTERSECT
      (X Y)
      (FOR X1 IN X WHEN
           (MEMBER X1 Y)
           COLLECT X1))

   




[ 0.0 0.0 0.0 ]

INTERSECT


(PROVE-LEMMA MEMBER-INTERSECT
             (REWRITE)
             (IMPLIES (LITATOM V)
                      (EQUAL (MEMBER A
                                     (FOR V LST P 'COLLECT V ALIST))
                             (AND (MEMBER A LST)
                                  (EVAL$ T P (CONS (CONS V A) ALIST)))))
             ((ENABLE EVAL$)))

This conjecture simplifies, opening up the function AND, to three new formulas:

Case 3. (IMPLIES (AND (LITATOM V)
                      (NOT (EVAL$ T P (CONS (CONS V A) ALIST))))
                 (EQUAL (MEMBER A
                                (FOR V LST P 'COLLECT V ALIST))
                        F)),

  which again simplifies, trivially, to the new goal:

        (IMPLIES (AND (LITATOM V)
                      (NOT (EVAL$ T P (CONS (CONS V A) ALIST))))
                 (NOT (MEMBER A
                              (FOR V LST P 'COLLECT V ALIST)))),

  which we will name *1.

Case 2. (IMPLIES (AND (LITATOM V) (NOT (MEMBER A LST)))
                 (EQUAL (MEMBER A
                                (FOR V LST P 'COLLECT V ALIST))
                        F)).

  This again simplifies, trivially, to:

        (IMPLIES (AND (LITATOM V) (NOT (MEMBER A LST)))
                 (NOT (MEMBER A
                              (FOR V LST P 'COLLECT V ALIST)))),

  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 (LITATOM V)
         (EQUAL (MEMBER A
                        (FOR V LST P 'COLLECT V ALIST))
                (AND (MEMBER A LST)
                     (EVAL$ T P
                            (CONS (CONS V A) ALIST))))).

We named this *1.  We will try to prove it by induction.  The recursive terms
in the conjecture suggest three inductions.  They merge into two likely
candidate inductions.  However, only one is unflawed.  We will induct
according to the following scheme:
      (AND (IMPLIES (NLISTP LST)
                    (p A V LST P ALIST))
           (IMPLIES (AND (NOT (NLISTP LST))
                         (EVAL$ T P
                                (CONS (CONS V (CAR LST)) ALIST))
                         (p A V (CDR LST) P ALIST))
                    (p A V LST P ALIST))
           (IMPLIES (AND (NOT (NLISTP LST))
                         (NOT (EVAL$ T P
                                     (CONS (CONS V (CAR LST)) ALIST)))
                         (p A V (CDR LST) P ALIST))
                    (p A V LST P ALIST))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT LST) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme leads to three new goals:

Case 3. (IMPLIES (AND (NLISTP LST) (LITATOM V))
                 (EQUAL (MEMBER A
                                (FOR V LST P 'COLLECT V ALIST))
                        (AND (MEMBER A LST)
                             (EVAL$ T P
                                    (CONS (CONS V A) ALIST))))),

  which simplifies, opening up the functions NLISTP, FOR,
  QUANTIFIER-INITIAL-VALUE, LISTP, MEMBER, AND, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP LST))
                      (EVAL$ T P
                             (CONS (CONS V (CAR LST)) ALIST))
                      (EQUAL (MEMBER A
                                     (FOR V (CDR LST) P 'COLLECT V ALIST))
                             (AND (MEMBER A (CDR LST))
                                  (EVAL$ T P (CONS (CONS V A) ALIST))))
                      (LITATOM V))
                 (EQUAL (MEMBER A
                                (FOR V LST P 'COLLECT V ALIST))
                        (AND (MEMBER A LST)
                             (EVAL$ T P
                                    (CONS (CONS V A) ALIST))))),

  which simplifies, applying CDR-CONS and CAR-CONS, and opening up NLISTP, AND,
  FOR, ASSOC, EQUAL, EVAL$, QUANTIFIER-OPERATION, and MEMBER, to the following
  two new goals:

  Case 2.2.
          (IMPLIES (AND (LISTP LST)
                        (EVAL$ T P
                               (CONS (CONS V (CAR LST)) ALIST))
                        (NOT (EVAL$ T P (CONS (CONS V A) ALIST)))
                        (EQUAL (MEMBER A
                                       (FOR V (CDR LST) P 'COLLECT V ALIST))
                               F)
                        (LITATOM V))
                   (NOT (EQUAL A (CAR LST)))).

    This again simplifies, trivially, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP LST)
                        (EVAL$ T P
                               (CONS (CONS V (CAR LST)) ALIST))
                        (NOT (MEMBER A (CDR LST)))
                        (EQUAL (MEMBER A
                                       (FOR V (CDR LST) P 'COLLECT V ALIST))
                               F)
                        (LITATOM V)
                        (EQUAL A (CAR LST)))
                   (EVAL$ T P (CONS (CONS V A) ALIST))).

    This again simplifies, trivially, to:

          T.

Case 1. (IMPLIES (AND (NOT (NLISTP LST))
                      (NOT (EVAL$ T P
                                  (CONS (CONS V (CAR LST)) ALIST)))
                      (EQUAL (MEMBER A
                                     (FOR V (CDR LST) P 'COLLECT V ALIST))
                             (AND (MEMBER A (CDR LST))
                                  (EVAL$ T P (CONS (CONS V A) ALIST))))
                      (LITATOM V))
                 (EQUAL (MEMBER A
                                (FOR V LST P 'COLLECT V ALIST))
                        (AND (MEMBER A LST)
                             (EVAL$ T P
                                    (CONS (CONS V A) ALIST))))).

  This simplifies, unfolding NLISTP, AND, FOR, MEMBER, and EQUAL, to the new
  conjecture:

        (IMPLIES (AND (LISTP LST)
                      (NOT (EVAL$ T P
                                  (CONS (CONS V (CAR LST)) ALIST)))
                      (NOT (MEMBER A (CDR LST)))
                      (EQUAL (MEMBER A
                                     (FOR V (CDR LST) P 'COLLECT V ALIST))
                             F)
                      (LITATOM V)
                      (EQUAL A (CAR LST)))
                 (NOT (EVAL$ T P (CONS (CONS V A) ALIST)))),

  which again simplifies, clearly, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.1 0.0 ]

MEMBER-INTERSECT


(PROVE-LEMMA MEMBER-UNION NIL
             (EQUAL (MEMBER A (UNION B C))
                    (OR (MEMBER A B) (MEMBER A C))))

This simplifies, opening up the function OR, to two new conjectures:

Case 2. (IMPLIES (NOT (MEMBER A B))
                 (EQUAL (MEMBER A (UNION B C))
                        (MEMBER A C))),

  which we will name *1.

Case 1. (IMPLIES (MEMBER A B)
                 (EQUAL (MEMBER A (UNION B C)) T)).

  This again simplifies, trivially, to the new formula:

        (IMPLIES (MEMBER A B)
                 (MEMBER A (UNION B C))),

  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 (MEMBER A (UNION B C))
       (OR (MEMBER A B) (MEMBER A C))).

We named this *1.  We will try to prove it by induction.  There are three
plausible inductions.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP B)
                         (MEMBER (CAR B) C)
                         (p A (CDR B) C))
                    (p A B C))
           (IMPLIES (AND (LISTP B)
                         (NOT (MEMBER (CAR B) C))
                         (p A (CDR B) C))
                    (p A B C))
           (IMPLIES (NOT (LISTP B)) (p A B C))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT B)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates three new conjectures:

Case 3. (IMPLIES (AND (LISTP B)
                      (MEMBER (CAR B) C)
                      (EQUAL (MEMBER A (UNION (CDR B) C))
                             (OR (MEMBER A (CDR B)) (MEMBER A C))))
                 (EQUAL (MEMBER A (UNION B C))
                        (OR (MEMBER A B) (MEMBER A C)))),

  which simplifies, expanding OR, UNION, MEMBER, and EQUAL, to:

        (IMPLIES (AND (LISTP B)
                      (MEMBER (CAR B) C)
                      (NOT (MEMBER A (CDR B)))
                      (EQUAL (MEMBER A (UNION (CDR B) C))
                             (MEMBER A C))
                      (EQUAL A (CAR B)))
                 (EQUAL (MEMBER A C) T)).

  This again simplifies, trivially, to:

        T.

Case 2. (IMPLIES (AND (LISTP B)
                      (NOT (MEMBER (CAR B) C))
                      (EQUAL (MEMBER A (UNION (CDR B) C))
                             (OR (MEMBER A (CDR B)) (MEMBER A C))))
                 (EQUAL (MEMBER A (UNION B C))
                        (OR (MEMBER A B) (MEMBER A C)))).

  This simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  expanding the functions OR, UNION, MEMBER, and EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP B))
                 (EQUAL (MEMBER A (UNION B C))
                        (OR (MEMBER A B) (MEMBER A C)))).

  This simplifies, opening up the functions UNION, MEMBER, and OR, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

MEMBER-UNION


(DEFN SUBSETP
      (X Y)
      (IF (LISTP X)
          (IF (MEMBER (CAR X) Y)
              (SUBSETP (CDR X) Y)
              F)
          T))

     Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, SUBSETP is accepted under the definitional principle.
Note that (OR (FALSEP (SUBSETP X Y)) (TRUEP (SUBSETP X Y))) is a theorem.




[ 0.0 0.0 0.0 ]

SUBSETP


(PROVE-LEMMA SUBSETP-UNION NIL
             (IMPLIES (SUBSETP A B)
                      (EQUAL (UNION A B) B)))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  Two 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 (AND (LISTP A)
                         (MEMBER (CAR A) B)
                         (p (CDR A) B))
                    (p A B))
           (IMPLIES (AND (LISTP A)
                         (NOT (MEMBER (CAR A) B))
                         (p (CDR A) B))
                    (p A B))
           (IMPLIES (NOT (LISTP A)) (p A B))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT A)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates five new conjectures:

Case 5. (IMPLIES (AND (LISTP A)
                      (MEMBER (CAR A) B)
                      (NOT (SUBSETP (CDR A) B))
                      (SUBSETP A B))
                 (EQUAL (UNION A B) B)),

  which simplifies, expanding the function SUBSETP, to:

        T.

Case 4. (IMPLIES (AND (LISTP A)
                      (MEMBER (CAR A) B)
                      (EQUAL (UNION (CDR A) B) B)
                      (SUBSETP A B))
                 (EQUAL (UNION A B) B)),

  which simplifies, opening up the functions SUBSETP and UNION, to:

        T.

Case 3. (IMPLIES (AND (LISTP A)
                      (NOT (MEMBER (CAR A) B))
                      (NOT (SUBSETP (CDR A) B))
                      (SUBSETP A B))
                 (EQUAL (UNION A B) B)),

  which simplifies, opening up the definition of SUBSETP, to:

        T.

Case 2. (IMPLIES (AND (LISTP A)
                      (NOT (MEMBER (CAR A) B))
                      (EQUAL (UNION (CDR A) B) B)
                      (SUBSETP A B))
                 (EQUAL (UNION A B) B)),

  which simplifies, opening up the function SUBSETP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP A)) (SUBSETP A B))
                 (EQUAL (UNION A B) B)),

  which simplifies, expanding SUBSETP and UNION, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBSETP-UNION


(PROVE-LEMMA SUBSETP-INTERSECT NIL
             (IMPLIES (AND (PLISTP A) (SUBSETP A B))
                      (EQUAL (INTERSECT A B) A)))

This formula can be simplified, using the abbreviations AND, IMPLIES, and
INTERSECT, to the new conjecture:

      (IMPLIES (AND (PLISTP A) (SUBSETP A B))
               (EQUAL (FOR 'X1
                           A
                           '(MEMBER X1 Y)
                           'COLLECT
                           'X1
                           (LIST (CONS 'Y B)))
                      A)),

which simplifies, unfolding the function EVAL$, to:

      (IMPLIES (AND (PLISTP A) (SUBSETP A B))
               (EQUAL (FOR X1 IN A WHEN
                           (MEMBER X1 B)
                           COLLECT X1)
                      A)).

Call the above conjecture *1.


     Perhaps we can prove it by 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 (NLISTP A) (p A B))
           (IMPLIES (AND (NOT (NLISTP A)) (p (CDR A) B))
                    (p A B))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP inform us that the measure (COUNT A) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates the following four new conjectures:

Case 4. (IMPLIES (AND (NLISTP A)
                      (PLISTP A)
                      (SUBSETP A B))
                 (EQUAL (FOR X1 IN A WHEN
                             (MEMBER X1 B)
                             COLLECT X1)
                        A)).

  This simplifies, opening up NLISTP, PLISTP, LISTP, SUBSETP, MEMBER, FOR, CDR,
  ASSOC, QUANTIFIER-INITIAL-VALUE, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP A))
                      (NOT (PLISTP (CDR A)))
                      (PLISTP A)
                      (SUBSETP A B))
                 (EQUAL (FOR X1 IN A WHEN
                             (MEMBER X1 B)
                             COLLECT X1)
                        A)).

  This simplifies, unfolding the functions NLISTP and PLISTP, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP A))
                      (NOT (SUBSETP (CDR A) B))
                      (PLISTP A)
                      (SUBSETP A B))
                 (EQUAL (FOR X1 IN A WHEN
                             (MEMBER X1 B)
                             COLLECT X1)
                        A)).

  This simplifies, opening up NLISTP, PLISTP, and SUBSETP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP A))
                      (EQUAL (FOR X1 IN
                                  (CDR A)
                                  WHEN
                                  (MEMBER X1 B)
                                  COLLECT X1)
                             (CDR A))
                      (PLISTP A)
                      (SUBSETP A B))
                 (EQUAL (FOR X1 IN A WHEN
                             (MEMBER X1 B)
                             COLLECT X1)
                        A)).

  This simplifies, appealing to the lemmas REWRITE-EVAL$ and CONS-CAR-CDR, and
  unfolding the functions NLISTP, PLISTP, SUBSETP, EVAL$, FOR, EQUAL, and
  QUANTIFIER-OPERATION, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBSETP-INTERSECT


(DEFN NTH
      (X N)
      (IF (ZEROP N)
          X
          (NTH (CDR X) (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, NTH is accepted under the
principle of definition.




[ 0.0 0.0 0.0 ]

NTH


(DEFN GREATEREQP
      (X Y)
      (NOT (LESSP X Y)))

     Note that (OR (FALSEP (GREATEREQP X Y)) (TRUEP (GREATEREQP X Y))) is a
theorem.




[ 0.0 0.0 0.0 ]

GREATEREQP


(PROVE-LEMMA TRANSITIVITY-OF-LEQ NIL
             (IMPLIES (AND (LEQ X Y) (LEQ Y Z))
                      (LEQ X Z)))

This formula simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TRANSITIVITY-OF-LEQ


(DEFN ORDERED
      (L)
      (IF (LISTP L)
          (IF (LISTP (CDR L))
              (IF (LESSP (CADR L) (CAR L))
                  F
                  (ORDERED (CDR L)))
              T)
          T))

     Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT L) decreases according to the well-founded relation LESSP in
each recursive call.  Hence, ORDERED is accepted under the principle of
definition.  Observe that (OR (FALSEP (ORDERED L)) (TRUEP (ORDERED L))) is a
theorem.




[ 0.0 0.0 0.0 ]

ORDERED


(DEFN ADDTOLIST
      (X L)
      (IF (LISTP L)
          (IF (LESSP X (CAR L))
              (CONS X L)
              (CONS (CAR L) (ADDTOLIST X (CDR L))))
          (CONS X NIL)))

     Linear arithmetic and the lemma CDR-LESSP can be used to show that the
measure (COUNT L) decreases according to the well-founded relation LESSP in
each recursive call.  Hence, ADDTOLIST is accepted under the definitional
principle.  Note that (LISTP (ADDTOLIST X L)) is a theorem.




[ 0.0 0.0 0.0 ]

ADDTOLIST


(DEFN SORT
      (L)
      (IF (LISTP L)
          (ADDTOLIST (CAR L) (SORT (CDR L)))
          NIL))

     Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT L) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, SORT is accepted under the definitional principle.
From the definition we can conclude that:
      (OR (LITATOM (SORT L))
          (LISTP (SORT L)))
is a theorem.




[ 0.0 0.0 0.0 ]

SORT


(DEFN BOOLEAN
      (X)
      (OR (EQUAL X T) (EQUAL X F)))

     Observe that (OR (FALSEP (BOOLEAN X)) (TRUEP (BOOLEAN X))) is a theorem.




[ 0.0 0.0 0.0 ]

BOOLEAN


(PROVE-LEMMA IFF-EQUAL-EQUAL NIL
             (IMPLIES (AND (BOOLEAN P) (BOOLEAN Q))
                      (EQUAL (IFF P Q) (EQUAL P Q))))

This conjecture simplifies, expanding the definitions of BOOLEAN, IFF, and
EQUAL, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

IFF-EQUAL-EQUAL


(PROVE-LEMMA NTH-0
             (REWRITE)
             (EQUAL (NTH 0 I) 0))


     Call the conjecture *1.


     We will try to prove it by induction.  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 can be
used to establish that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates the following two new formulas:

Case 2. (IMPLIES (ZEROP I)
                 (EQUAL (NTH 0 I) 0)).

  This simplifies, expanding the definitions of ZEROP, NTH, and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (EQUAL (NTH 0 (SUB1 I)) 0))
                 (EQUAL (NTH 0 I) 0)).

  This simplifies, opening up the functions ZEROP, NTH, CDR, and EQUAL, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

NTH-0


(PROVE-LEMMA NTH-NIL
             (REWRITE)
             (EQUAL (NTH NIL I)
                    (IF (ZEROP I) NIL 0)))

This simplifies, appealing to the lemma NTH-0, and opening up the definitions
of CDR, NTH, and ZEROP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NTH-NIL


(PROVE-LEMMA NTH-APPEND1
             (REWRITE)
             (EQUAL (NTH A (PLUS I J))
                    (NTH (NTH A I) J)))


     Call the conjecture *1.


     Perhaps we can prove it by induction.  Three inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (ZEROP I) (p A I J))
           (IMPLIES (AND (NOT (ZEROP I))
                         (p (CDR A) (SUB1 I) J))
                    (p A I J))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definition
of ZEROP 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 two new goals:

Case 2. (IMPLIES (ZEROP I)
                 (EQUAL (NTH A (PLUS I J))
                        (NTH (NTH A I) J))),

  which simplifies, opening up the definitions of ZEROP, EQUAL, PLUS, and NTH,
  to two new conjectures:

  Case 2.2.
          (IMPLIES (AND (EQUAL I 0) (NOT (NUMBERP J)))
                   (EQUAL (NTH A 0) (NTH A J))),

    which again simplifies, unfolding the functions EQUAL and NTH, to:

          T.

  Case 2.1.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (NUMBERP J)))
                   (EQUAL (NTH A 0) (NTH A J))),

    which again simplifies, opening up the functions EQUAL and NTH, to:

          T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (EQUAL (NTH (CDR A) (PLUS (SUB1 I) J))
                             (NTH (NTH (CDR A) (SUB1 I)) J)))
                 (EQUAL (NTH A (PLUS I J))
                        (NTH (NTH A I) J))),

  which simplifies, applying the lemma SUB1-ADD1, and opening up ZEROP, PLUS,
  and NTH, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

NTH-APPEND1


(PROVE-LEMMA ASSOCIATIVITY-OF-EQUAL NIL
             (IMPLIES (AND (BOOLEAN A)
                           (AND (BOOLEAN B) (BOOLEAN C)))
                      (EQUAL (EQUAL (EQUAL A B) C)
                             (EQUAL A (EQUAL B C)))))

This conjecture simplifies, opening up BOOLEAN and EQUAL, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ASSOCIATIVITY-OF-EQUAL


(DEFN ODD
      (X)
      (IF (ZEROP X)
          F
          (IF (ZEROP (SUB1 X))
              T
              (ODD (SUB1 (SUB1 X))))))

     Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP
establish that the measure (COUNT X) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, ODD is accepted under the
principle of definition.  From the definition we can conclude that:
      (OR (FALSEP (ODD X)) (TRUEP (ODD X)))
is a theorem.




[ 0.0 0.0 0.0 ]

ODD


(DEFN EVEN1
      (X)
      (IF (ZEROP X) T (ODD (SUB1 X))))

     From the definition we can conclude that:
      (OR (FALSEP (EVEN1 X))
          (TRUEP (EVEN1 X)))
is a theorem.




[ 0.0 0.0 0.0 ]

EVEN1


(DEFN EVEN2
      (X)
      (IF (ZEROP X)
          T
          (IF (ZEROP (SUB1 X))
              F
              (EVEN2 (SUB1 (SUB1 X))))))

     Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP
establish that the measure (COUNT X) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, EVEN2 is accepted under the
principle of definition.  From the definition we can conclude that:
      (OR (FALSEP (EVEN2 X))
          (TRUEP (EVEN2 X)))
is a theorem.




[ 0.0 0.0 0.0 ]

EVEN2


(DEFN DOUBLE
      (I)
      (IF (ZEROP I)
          0
          (ADD1 (ADD1 (DOUBLE (SUB1 I))))))

     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 recursive call.  Hence, DOUBLE is accepted under the
principle of definition.  Observe that (NUMBERP (DOUBLE I)) is a theorem.




[ 0.0 0.0 0.0 ]

DOUBLE


(PROVE-LEMMA EVEN1-DOUBLE
             (REWRITE)
             (EVEN1 (DOUBLE I)))

WARNING:  Note that the rewrite rule EVEN1-DOUBLE will be stored so as to
apply only to terms with the nonrecursive function symbol EVEN1.


This conjecture can be simplified, using the abbreviation EVEN1, to the goal:

      (IMPLIES (AND (NOT (EQUAL (DOUBLE I) 0))
                    (NUMBERP (DOUBLE I)))
               (ODD (SUB1 (DOUBLE I)))).

This simplifies, trivially, to:

      (IMPLIES (NOT (EQUAL (DOUBLE I) 0))
               (ODD (SUB1 (DOUBLE I)))),

which we will name *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))
           (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
generates the following three new formulas:

Case 3. (IMPLIES (AND (ZEROP I)
                      (NOT (EQUAL (DOUBLE I) 0)))
                 (ODD (SUB1 (DOUBLE I)))).

  This simplifies, expanding the definitions of ZEROP, DOUBLE, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP I))
                      (EQUAL (DOUBLE (SUB1 I)) 0)
                      (NOT (EQUAL (DOUBLE I) 0)))
                 (ODD (SUB1 (DOUBLE I)))).

  This simplifies, opening up the functions ZEROP, DOUBLE, ADD1, EQUAL, SUB1,
  and ODD, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (ODD (SUB1 (DOUBLE (SUB1 I))))
                      (NOT (EQUAL (DOUBLE I) 0)))
                 (ODD (SUB1 (DOUBLE I)))).

  This simplifies, applying SUB1-ADD1, and unfolding the definitions of ZEROP,
  DOUBLE, and ODD, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

EVEN1-DOUBLE


(DEFN HALF
      (I)
      (IF (ZEROP I)
          0
          (IF (ZEROP (SUB1 I))
              0
              (ADD1 (HALF (SUB1 (SUB1 I)))))))

     Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP
can be used to show that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, HALF is accepted
under the definitional principle.  Observe that (NUMBERP (HALF I)) is a
theorem.




[ 0.0 0.0 0.0 ]

HALF


(PROVE-LEMMA HALF-DOUBLE
             (REWRITE)
             (IMPLIES (NUMBERP I)
                      (EQUAL (HALF (DOUBLE I)) I)))


     Give the conjecture the name *1.


     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
establish that the measure (COUNT I) decreases according to the well-founded
relation LESSP in each induction step of the scheme.  The above induction
scheme generates two new conjectures:

Case 2. (IMPLIES (AND (ZEROP I) (NUMBERP I))
                 (EQUAL (HALF (DOUBLE I)) I)),

  which simplifies, expanding the functions ZEROP, NUMBERP, DOUBLE, HALF, and
  EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (EQUAL (HALF (DOUBLE (SUB1 I)))
                             (SUB1 I))
                      (NUMBERP I))
                 (EQUAL (HALF (DOUBLE I)) I)),

  which simplifies, appealing to the lemmas ADD1-SUB1 and SUB1-ADD1, and
  expanding ZEROP, DOUBLE, and HALF, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

HALF-DOUBLE


(PROVE-LEMMA DOUBLE-HALF
             (REWRITE)
             (IMPLIES (AND (NUMBERP I) (EVEN1 I))
                      (EQUAL (DOUBLE (HALF I)) I)))

This formula simplifies, opening up the functions EVEN1, HALF, DOUBLE, and
EQUAL, to:

      (IMPLIES (AND (NUMBERP I) (ODD (SUB1 I)))
               (EQUAL (DOUBLE (HALF I)) I)).

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.  This produces the following two new formulas:

Case 2. (IMPLIES (AND (EQUAL I 0)
                      (NUMBERP I)
                      (ODD (SUB1 I)))
                 (EQUAL (DOUBLE (HALF I)) I)).

  However this further simplifies, expanding NUMBERP, SUB1, and ODD, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X)
                      (NOT (EQUAL (ADD1 X) 0))
                      (ODD X))
                 (EQUAL (DOUBLE (HALF (ADD1 X)))
                        (ADD1 X))),

  which further simplifies, clearly, to the new goal:

        (IMPLIES (AND (NUMBERP X) (ODD X))
                 (EQUAL (DOUBLE (HALF (ADD1 X)))
                        (ADD1 X))),

  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) (EVEN1 I))
         (EQUAL (DOUBLE (HALF I)) I)),

named *1.  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)) (ZEROP (SUB1 I)))
                    (p I))
           (IMPLIES (AND (NOT (ZEROP I))
                         (NOT (ZEROP (SUB1 I)))
                         (p (SUB1 (SUB1 I))))
                    (p I))).
Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP 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.  The above
induction scheme produces the following four new goals:

Case 4. (IMPLIES (AND (ZEROP I) (NUMBERP I) (EVEN1 I))
                 (EQUAL (DOUBLE (HALF I)) I)).

  This simplifies, opening up the functions ZEROP, NUMBERP, EVEN1, HALF,
  DOUBLE, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP I))
                      (ZEROP (SUB1 I))
                      (NUMBERP I)
                      (EVEN1 I))
                 (EQUAL (DOUBLE (HALF I)) I)).

  This simplifies, unfolding the functions ZEROP, ODD, and EVEN1, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (ZEROP (SUB1 I)))
                      (NOT (EVEN1 (SUB1 (SUB1 I))))
                      (NUMBERP I)
                      (EVEN1 I))
                 (EQUAL (DOUBLE (HALF I)) I)).

  This simplifies, unfolding the functions ZEROP, EVEN1, and ODD, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (ZEROP (SUB1 I)))
                      (EQUAL (DOUBLE (HALF (SUB1 (SUB1 I))))
                             (SUB1 (SUB1 I)))
                      (NUMBERP I)
                      (EVEN1 I))
                 (EQUAL (DOUBLE (HALF I)) I)).

  This simplifies, applying ADD1-SUB1 and SUB1-ADD1, and unfolding the
  definitions of ZEROP, EVEN1, HALF, and DOUBLE, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

DOUBLE-HALF


(PROVE-LEMMA DOUBLE-TIMES-2 NIL
             (EQUAL (DOUBLE I) (TIMES 2 I)))


     Call the conjecture *1.


     We will try to prove it by induction.  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 can be
used to establish that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates the following two new formulas:

Case 2. (IMPLIES (ZEROP I)
                 (EQUAL (DOUBLE I) (TIMES 2 I))).

  This simplifies, applying TIMES-ZERO2, and expanding the functions ZEROP,
  DOUBLE, TIMES, and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (EQUAL (DOUBLE (SUB1 I))
                             (TIMES 2 (SUB1 I))))
                 (EQUAL (DOUBLE I) (TIMES 2 I))),

  which simplifies, opening up the functions ZEROP and DOUBLE, to:

        (IMPLIES (AND (NOT (EQUAL I 0))
                      (NUMBERP I)
                      (EQUAL (DOUBLE (SUB1 I))
                             (TIMES 2 (SUB1 I))))
                 (EQUAL (ADD1 (ADD1 (DOUBLE (SUB1 I))))
                        (TIMES 2 I))).

  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.  The result is:

        (IMPLIES (AND (NUMBERP X)
                      (NOT (EQUAL (ADD1 X) 0))
                      (EQUAL (DOUBLE X) (TIMES 2 X)))
                 (EQUAL (ADD1 (ADD1 (DOUBLE X)))
                        (TIMES 2 (ADD1 X)))).

  This further simplifies, appealing to the lemma TIMES-ADD1, to the goal:

        (IMPLIES (AND (NUMBERP X)
                      (EQUAL (DOUBLE X) (TIMES 2 X)))
                 (EQUAL (ADD1 (ADD1 (DOUBLE X)))
                        (PLUS 2 (DOUBLE X)))).

  But this again simplifies, using linear arithmetic, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

DOUBLE-TIMES-2


(PROVE-LEMMA SUBSETP-CONS
             (REWRITE)
             (IMPLIES (SUBSETP X Y)
                      (SUBSETP X (CONS Z Y))))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  Two 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 (AND (LISTP X)
                         (MEMBER (CAR X) Y)
                         (p (CDR X) Z Y))
                    (p X Z Y))
           (IMPLIES (AND (LISTP X)
                         (NOT (MEMBER (CAR X) Y)))
                    (p X Z Y))
           (IMPLIES (NOT (LISTP X)) (p X Z Y))).
Linear arithmetic and the lemma CDR-LESSP establish 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 four new conjectures:

Case 4. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) Y)
                      (NOT (SUBSETP (CDR X) Y))
                      (SUBSETP X Y))
                 (SUBSETP X (CONS Z Y))),

  which simplifies, expanding the function SUBSETP, to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (MEMBER (CAR X) Y)
                      (SUBSETP (CDR X) (CONS Z Y))
                      (SUBSETP X Y))
                 (SUBSETP X (CONS Z Y))),

  which simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  expanding SUBSETP and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (MEMBER (CAR X) Y))
                      (SUBSETP X Y))
                 (SUBSETP X (CONS Z Y))),

  which simplifies, opening up SUBSETP, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (SUBSETP X Y))
                 (SUBSETP X (CONS Z Y))),

  which simplifies, opening up SUBSETP, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBSETP-CONS


(DEFN LAST
      (X)
      (IF (LISTP X)
          (IF (LISTP (CDR X)) (LAST (CDR X)) X)
          X))

     Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT X) decreases according to the well-founded relation LESSP in
each recursive call.  Hence, LAST is accepted under the definitional principle.
Note that (OR (LISTP (LAST X)) (EQUAL (LAST X) X)) is a theorem.




[ 0.0 0.0 0.0 ]

LAST


(PROVE-LEMMA LAST-APPEND
             (REWRITE)
             (EQUAL (LAST (APPEND A B))
                    (IF (LISTP B)
                        (LAST B)
                        (IF (LISTP A)
                            (CONS (CAR (LAST A)) B)
                            B))))

This simplifies, obviously, to three new goals:

Case 3. (IMPLIES (AND (NOT (LISTP B)) (LISTP A))
                 (EQUAL (LAST (APPEND A B))
                        (CONS (CAR (LAST A)) B))),

  which we will name *1.

Case 2. (IMPLIES (AND (NOT (LISTP B)) (NOT (LISTP A)))
                 (EQUAL (LAST (APPEND A B)) B)).

  This again simplifies, opening up APPEND and LAST, to:

        T.

Case 1. (IMPLIES (LISTP B)
                 (EQUAL (LAST (APPEND A B)) (LAST B))),

  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 (LAST (APPEND A B))
       (COND ((LISTP B) (LAST B))
             ((LISTP A) (CONS (CAR (LAST A)) B))
             (T B))),

named *1.  Let us appeal to the induction principle.  There are three
plausible inductions.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP A) (p (CDR A) B))
                    (p A B))
           (IMPLIES (NOT (LISTP A)) (p A B))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT A)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme leads to two new goals:

Case 2. (IMPLIES (AND (LISTP A)
                      (EQUAL (LAST (APPEND (CDR A) B))
                             (COND ((LISTP B) (LAST B))
                                   ((LISTP (CDR A))
                                    (CONS (CAR (LAST (CDR A))) B))
                                   (T B))))
                 (EQUAL (LAST (APPEND A B))
                        (COND ((LISTP B) (LAST B))
                              ((LISTP A) (CONS (CAR (LAST A)) B))
                              (T B)))),

  which simplifies, rewriting with CDR-CONS, and opening up the functions
  APPEND and LAST, to the following three new conjectures:

  Case 2.3.
          (IMPLIES (AND (LISTP A)
                        (NOT (LISTP B))
                        (LISTP (CDR A))
                        (EQUAL (LAST (APPEND (CDR A) B))
                               (CONS (CAR (LAST (CDR A))) B))
                        (NOT (LISTP (APPEND (CDR A) B))))
                   (EQUAL (CONS (CAR A) (APPEND (CDR A) B))
                          (LAST (APPEND (CDR A) B)))).

    But this again simplifies, expanding the definition of LAST, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP A)
                        (NOT (LISTP B))
                        (NOT (LISTP (CDR A)))
                        (EQUAL (LAST (APPEND (CDR A) B)) B))
                   (EQUAL (CONS (CAR A) (APPEND (CDR A) B))
                          (CONS (CAR A) B))),

    which again simplifies, rewriting with CAR-CONS, CDR-CONS, and CONS-EQUAL,
    to:

          (IMPLIES (AND (LISTP A)
                        (NOT (LISTP B))
                        (NOT (LISTP (CDR A)))
                        (EQUAL (LAST (APPEND (CDR A) B)) B))
                   (EQUAL (APPEND (CDR A) B) B)),

    which further simplifies, expanding the functions APPEND and LAST, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP A)
                        (NOT (LISTP B))
                        (NOT (LISTP (CDR A)))
                        (EQUAL (LAST (APPEND (CDR A) B)) B))
                   (NOT (LISTP (APPEND (CDR A) B)))),

    which again simplifies, clearly, to:

          T.

Case 1. (IMPLIES (NOT (LISTP A))
                 (EQUAL (LAST (APPEND A B))
                        (COND ((LISTP B) (LAST B))
                              ((LISTP A) (CONS (CAR (LAST A)) B))
                              (T B)))).

  This simplifies, expanding the function APPEND, to the new conjecture:

        (IMPLIES (AND (NOT (LISTP A)) (NOT (LISTP B)))
                 (EQUAL (LAST B) B)),

  which again simplifies, expanding the function LAST, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

LAST-APPEND


(PROVE-LEMMA LAST-REVERSE NIL
             (IMPLIES (LISTP A)
                      (EQUAL (LAST (REVERSE A))
                             (CONS (CAR A) NIL))))

.

Applying the lemma CAR-CDR-ELIM, replace A by (CONS X Z) to eliminate (CAR A)
and (CDR A).  We would thus like to prove the new conjecture:

      (EQUAL (LAST (REVERSE (CONS X Z)))
             (LIST X)),

which simplifies, applying CAR-CONS, CDR-CONS, and LAST-APPEND, and opening up
REVERSE, LISTP, and LAST, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

LAST-REVERSE


(DEFN EXP
      (I J)
      (IF (ZEROP J)
          1
          (TIMES I (EXP I (SUB1 J)))))

     Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP
inform us that the measure (COUNT J) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, EXP is accepted under the
definitional principle.  From the definition we can conclude that
(NUMBERP (EXP I J)) is a theorem.




[ 0.0 0.0 0.0 ]

EXP


(PROVE-LEMMA EXP-PLUS
             (REWRITE)
             (EQUAL (EXP I (PLUS J K))
                    (TIMES (EXP I J) (EXP I K))))


     Call the conjecture *1.


     We will try to prove it by induction.  There are three plausible
inductions.  They merge into two likely candidate inductions.  However, only
one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP J) (p I J K))
           (IMPLIES (AND (NOT (ZEROP J)) (p I (SUB1 J) K))
                    (p I J K))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definition
of ZEROP inform us that the measure (COUNT J) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates two new goals:

Case 2. (IMPLIES (ZEROP J)
                 (EQUAL (EXP I (PLUS J K))
                        (TIMES (EXP I J) (EXP I K)))),

  which simplifies, opening up the functions ZEROP, EQUAL, PLUS, and EXP, to
  four new formulas:

  Case 2.4.
          (IMPLIES (AND (EQUAL J 0) (NOT (NUMBERP K)))
                   (EQUAL (EXP I 0)
                          (TIMES 1 (EXP I K)))),

    which again simplifies, opening up EQUAL, EXP, and TIMES, to:

          T.

  Case 2.3.
          (IMPLIES (AND (EQUAL J 0) (NUMBERP K))
                   (EQUAL (EXP I K)
                          (TIMES 1 (EXP I K)))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.2.
          (IMPLIES (AND (NOT (NUMBERP J))
                        (NOT (NUMBERP K)))
                   (EQUAL (EXP I 0)
                          (TIMES 1 (EXP I K)))),

    which again simplifies, opening up the definitions of EQUAL, EXP, and
    TIMES, to:

          T.

  Case 2.1.
          (IMPLIES (AND (NOT (NUMBERP J)) (NUMBERP K))
                   (EQUAL (EXP I K)
                          (TIMES 1 (EXP I K)))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES (AND (NOT (ZEROP J))
                      (EQUAL (EXP I (PLUS (SUB1 J) K))
                             (TIMES (EXP I (SUB1 J)) (EXP I K))))
                 (EQUAL (EXP I (PLUS J K))
                        (TIMES (EXP I J) (EXP I K)))),

  which simplifies, rewriting with COMMUTATIVITY-OF-TIMES, SUB1-ADD1, and
  ASSOCIATIVITY-OF-TIMES, and opening up the functions ZEROP, PLUS, and EXP,
  to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

EXP-PLUS


(PROVE-LEMMA EVEN1-EVEN2 NIL
             (EQUAL (EVEN1 X) (EVEN2 X)))

This simplifies, expanding the function EVEN1, to the following three new
goals:

Case 3. (IMPLIES (AND (NOT (EQUAL X 0)) (NUMBERP X))
                 (EQUAL (ODD (SUB1 X)) (EVEN2 X))).

  Appealing to the lemma SUB1-ELIM, we now replace X by (ADD1 Z) to eliminate
  (SUB1 X).  We rely upon the type restriction lemma noted when SUB1 was
  introduced to constrain the new variable.  The result is:

        (IMPLIES (AND (NUMBERP Z)
                      (NOT (EQUAL (ADD1 Z) 0)))
                 (EQUAL (ODD Z) (EVEN2 (ADD1 Z)))).

  This further simplifies, obviously, to:

        (IMPLIES (NUMBERP Z)
                 (EQUAL (ODD Z) (EVEN2 (ADD1 Z)))),

  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 (EVEN1 X) (EVEN2 X)),

named *1.  Let us appeal to the induction principle.  There is only one
suggested induction.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP X) (p X))
           (IMPLIES (AND (NOT (ZEROP X)) (ZEROP (SUB1 X)))
                    (p X))
           (IMPLIES (AND (NOT (ZEROP X))
                         (NOT (ZEROP (SUB1 X)))
                         (p (SUB1 (SUB1 X))))
                    (p X))).
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 generates the following three new formulas:

Case 3. (IMPLIES (ZEROP X)
                 (EQUAL (EVEN1 X) (EVEN2 X))).

  This simplifies, opening up ZEROP, EVEN1, EVEN2, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP X)) (ZEROP (SUB1 X)))
                 (EQUAL (EVEN1 X) (EVEN2 X))).

  This simplifies, expanding ZEROP, ODD, EVEN1, EVEN2, and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (NOT (ZEROP (SUB1 X)))
                      (EQUAL (EVEN1 (SUB1 (SUB1 X)))
                             (EVEN2 (SUB1 (SUB1 X)))))
                 (EQUAL (EVEN1 X) (EVEN2 X))).

  This simplifies, opening up ZEROP, EVEN1, ODD, EVEN2, and EQUAL, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

EVEN1-EVEN2


(PROVE-LEMMA LEQ-NTH NIL
             (LEQ (LENGTH (NTH L I)) (LENGTH L)))


     Call the conjecture *1.


     We will try to 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 (AND (LISTP L) (p (CDR L) (SUB1 I)))
                    (p L I))
           (IMPLIES (NOT (LISTP L)) (p L I))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT L)
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 generates two new goals:

Case 2. (IMPLIES (AND (LISTP L)
                      (NOT (LESSP (LENGTH (CDR L))
                                  (LENGTH (NTH (CDR L) (SUB1 I))))))
                 (NOT (LESSP (LENGTH L)
                             (LENGTH (NTH L I))))),

  which simplifies, appealing to the lemma SUB1-ADD1, and unfolding LENGTH,
  NTH, and LESSP, to three new formulas:

  Case 2.3.
          (IMPLIES (AND (LISTP L)
                        (NOT (LESSP (LENGTH (CDR L))
                                    (LENGTH (NTH (CDR L) (SUB1 I)))))
                        (NOT (NUMBERP I))
                        (NOT (EQUAL (LENGTH L) 0)))
                   (NOT (LESSP (LENGTH (CDR L))
                               (SUB1 (LENGTH L))))),

    which again simplifies, applying SUB1-ADD1, and opening up the function
    LENGTH, to:

          (IMPLIES (AND (LISTP L)
                        (NOT (LESSP (LENGTH (CDR L))
                                    (LENGTH (NTH (CDR L) (SUB1 I)))))
                        (NOT (NUMBERP I)))
                   (NOT (LESSP (LENGTH (CDR L))
                               (LENGTH (CDR L))))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP L)
                        (NOT (LESSP (LENGTH (CDR L))
                                    (LENGTH (NTH (CDR L) (SUB1 I)))))
                        (EQUAL I 0)
                        (NOT (EQUAL (LENGTH L) 0)))
                   (NOT (LESSP (LENGTH (CDR L))
                               (SUB1 (LENGTH L))))),

    which again simplifies, applying SUB1-ADD1, and unfolding SUB1, EQUAL, NTH,
    and LENGTH, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP L)
                        (NOT (LESSP (LENGTH (CDR L))
                                    (LENGTH (NTH (CDR L) (SUB1 I)))))
                        (NOT (EQUAL I 0))
                        (NUMBERP I)
                        (NOT (EQUAL (LENGTH (NTH (CDR L) (SUB1 I)))
                                    0)))
                   (NOT (LESSP (LENGTH (CDR L))
                               (SUB1 (LENGTH (NTH (CDR L) (SUB1 I))))))).

    But this again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES (NOT (LISTP L))
                 (NOT (LESSP (LENGTH L)
                             (LENGTH (NTH L I))))),

  which simplifies, unfolding the functions LENGTH, NTH, EQUAL, and LESSP, to
  three new conjectures:

  Case 1.3.
          (IMPLIES (AND (NOT (LISTP L))
                        (NOT (EQUAL I 0))
                        (NUMBERP I))
                   (EQUAL (LENGTH (NTH (CDR L) (SUB1 I)))
                          0)),

    which further simplifies, applying CDR-NLISTP and NTH-0, and opening up
    the functions LENGTH and EQUAL, to:

          T.

  Case 1.2.
          (IMPLIES (AND (NOT (LISTP L)) (EQUAL I 0))
                   (EQUAL (LENGTH L) 0)).

    But this again simplifies, expanding the definitions of LENGTH and EQUAL,
    to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (LISTP L))
                        (NOT (NUMBERP I)))
                   (EQUAL (LENGTH L) 0)),

    which again simplifies, expanding the definitions of LENGTH and EQUAL, to:

          T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

LEQ-NTH


(PROVE-LEMMA MEMBER-SORT NIL
             (EQUAL (MEMBER A (SORT B))
                    (MEMBER A B)))


     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 (AND (LISTP B) (p A (CDR B)))
                    (p A B))
           (IMPLIES (NOT (LISTP B)) (p A B))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT B)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces the following two new
goals:

Case 2. (IMPLIES (AND (LISTP B)
                      (EQUAL (MEMBER A (SORT (CDR B)))
                             (MEMBER A (CDR B))))
                 (EQUAL (MEMBER A (SORT B))
                        (MEMBER A B))).

  This simplifies, expanding SORT and MEMBER, to the following two new
  formulas:

  Case 2.2.
          (IMPLIES (AND (LISTP B)
                        (EQUAL (MEMBER A (SORT (CDR B)))
                               (MEMBER A (CDR B)))
                        (NOT (EQUAL A (CAR B))))
                   (EQUAL (MEMBER A
                                  (ADDTOLIST (CAR B) (SORT (CDR B))))
                          (MEMBER A (CDR B)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace B by (CONS Z X) to
    eliminate (CDR B) and (CAR B).  The result is:

          (IMPLIES (AND (EQUAL (MEMBER A (SORT X))
                               (MEMBER A X))
                        (NOT (EQUAL A Z)))
                   (EQUAL (MEMBER A (ADDTOLIST Z (SORT X)))
                          (MEMBER A X))).

    We use the above equality hypothesis by substituting (MEMBER A (SORT X))
    for (MEMBER A X) and throwing away the equality.  This produces:

          (IMPLIES (NOT (EQUAL A Z))
                   (EQUAL (MEMBER A (ADDTOLIST Z (SORT X)))
                          (MEMBER A (SORT X)))),

    which we generalize by replacing (SORT X) by Y.  We must thus prove the
    formula:

          (IMPLIES (NOT (EQUAL A Z))
                   (EQUAL (MEMBER A (ADDTOLIST Z Y))
                          (MEMBER A Y))).

    Name the above subgoal *1.1.

  Case 2.1.
          (IMPLIES (AND (LISTP B)
                        (EQUAL (MEMBER A (SORT (CDR B)))
                               (MEMBER A (CDR B)))
                        (EQUAL A (CAR B)))
                   (EQUAL (MEMBER A
                                  (ADDTOLIST (CAR B) (SORT (CDR B))))
                          T)).

    This again simplifies, obviously, to the new goal:

          (IMPLIES (AND (LISTP B)
                        (EQUAL (MEMBER (CAR B) (SORT (CDR B)))
                               (MEMBER (CAR B) (CDR B))))
                   (MEMBER (CAR B)
                           (ADDTOLIST (CAR B) (SORT (CDR B))))).

    Applying the lemma CAR-CDR-ELIM, replace B by (CONS X Z) to eliminate
    (CAR B) and (CDR B).  This produces:

          (IMPLIES (EQUAL (MEMBER X (SORT Z))
                          (MEMBER X Z))
                   (MEMBER X (ADDTOLIST X (SORT Z)))),

    which we generalize by replacing (SORT Z) by Y.  This generates:

          (IMPLIES (EQUAL (MEMBER X Y) (MEMBER X Z))
                   (MEMBER X (ADDTOLIST X Y))).

    Name the above subgoal *1.2.

Case 1. (IMPLIES (NOT (LISTP B))
                 (EQUAL (MEMBER A (SORT B))
                        (MEMBER A B))).

  This simplifies, unfolding the definitions of SORT, LISTP, MEMBER, and EQUAL,
  to:

        T.


     So we now return to:

      (IMPLIES (EQUAL (MEMBER X Y) (MEMBER X Z))
               (MEMBER X (ADDTOLIST X Y))),

which we named *1.2 above.  Perhaps we can prove it by induction.  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 (NLISTP Y) (p X Y Z))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (EQUAL X (CAR Y)))
                    (p X Y Z))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (NOT (EQUAL X (CAR Y)))
                         (p X (CDR Y) Z))
                    (p X Y Z))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT Y) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates the following four new goals:

Case 4. (IMPLIES (AND (NLISTP Y)
                      (EQUAL (MEMBER X Y) (MEMBER X Z)))
                 (MEMBER X (ADDTOLIST X Y))).

  This simplifies, rewriting with CAR-CONS, and expanding the functions NLISTP,
  MEMBER, and ADDTOLIST, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Y))
                      (EQUAL X (CAR Y))
                      (EQUAL (MEMBER X Y) (MEMBER X Z)))
                 (MEMBER X (ADDTOLIST X Y))),

  which simplifies, opening up the functions NLISTP and MEMBER, to the formula:

        (IMPLIES (AND (LISTP Y) (MEMBER (CAR Y) Z))
                 (MEMBER (CAR Y)
                         (ADDTOLIST (CAR Y) Y))).

  Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS V W) to
  eliminate (CAR Y) and (CDR Y).  The result is the goal:

        (IMPLIES (MEMBER V Z)
                 (MEMBER V (ADDTOLIST V (CONS V W)))).

  But this further simplifies, rewriting with CDR-CONS and CAR-CONS, and
  unfolding the function ADDTOLIST, to the following two new conjectures:

  Case 3.2.
          (IMPLIES (AND (MEMBER V Z) (NOT (LESSP V V)))
                   (MEMBER V (CONS V (ADDTOLIST V W)))).

    This again simplifies, applying CAR-CONS, and expanding the function
    MEMBER, to:

          T.

  Case 3.1.
          (IMPLIES (AND (MEMBER V Z) (LESSP V V))
                   (MEMBER V (CONS V (CONS V W)))).

    But this again simplifies, using linear arithmetic, to:

          T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (NOT (EQUAL (MEMBER X (CDR Y))
                                  (MEMBER X Z)))
                      (EQUAL (MEMBER X Y) (MEMBER X Z)))
                 (MEMBER X (ADDTOLIST X Y))),

  which simplifies, unfolding the functions NLISTP and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL X (CAR Y)))
                      (MEMBER X (ADDTOLIST X (CDR Y)))
                      (EQUAL (MEMBER X Y) (MEMBER X Z)))
                 (MEMBER X (ADDTOLIST X Y))),

  which simplifies, unfolding the definitions of NLISTP, MEMBER, and ADDTOLIST,
  to two new conjectures:

  Case 1.2.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (MEMBER X (ADDTOLIST X (CDR Y)))
                        (EQUAL (MEMBER X (CDR Y))
                               (MEMBER X Z))
                        (NOT (LESSP X (CAR Y))))
                   (MEMBER X
                           (CONS (CAR Y)
                                 (ADDTOLIST X (CDR Y))))),

    which again simplifies, applying CDR-CONS and CAR-CONS, and expanding
    MEMBER, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP Y)
                        (NOT (EQUAL X (CAR Y)))
                        (MEMBER X (ADDTOLIST X (CDR Y)))
                        (EQUAL (MEMBER X (CDR Y))
                               (MEMBER X Z))
                        (LESSP X (CAR Y)))
                   (MEMBER X (CONS X Y))).

    This again simplifies, applying CAR-CONS, and unfolding MEMBER, to:

          T.


     That finishes the proof of *1.2.


     So we now return to:

      (IMPLIES (NOT (EQUAL A Z))
               (EQUAL (MEMBER A (ADDTOLIST Z Y))
                      (MEMBER A Y))),

which we named *1.1 above.  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 (AND (LISTP Y) (LESSP Z (CAR Y)))
                    (p A Z Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (LESSP Z (CAR Y)))
                         (p A Z (CDR Y)))
                    (p A Z Y))
           (IMPLIES (NOT (LISTP Y)) (p A Z Y))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT Y) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates three new
goals:

Case 3. (IMPLIES (AND (LISTP Y)
                      (LESSP Z (CAR Y))
                      (NOT (EQUAL A Z)))
                 (EQUAL (MEMBER A (ADDTOLIST Z Y))
                        (MEMBER A Y))),

  which simplifies, unfolding the functions ADDTOLIST and MEMBER, to two new
  conjectures:

  Case 3.2.
          (IMPLIES (AND (LISTP Y)
                        (LESSP Z (CAR Y))
                        (NOT (EQUAL A Z))
                        (NOT (EQUAL A (CAR Y))))
                   (EQUAL (MEMBER A (CONS Z Y))
                          (MEMBER A (CDR Y)))),

    which again simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
    expanding the function MEMBER, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Y)
                        (LESSP Z (CAR Y))
                        (NOT (EQUAL A Z))
                        (EQUAL A (CAR Y)))
                   (EQUAL (MEMBER A (CONS Z Y)) T)),

    which again simplifies, rewriting with CDR-CONS and CAR-CONS, and
    unfolding the definitions of MEMBER and EQUAL, to:

          T.

Case 2. (IMPLIES (AND (LISTP Y)
                      (NOT (LESSP Z (CAR Y)))
                      (EQUAL (MEMBER A (ADDTOLIST Z (CDR Y)))
                             (MEMBER A (CDR Y)))
                      (NOT (EQUAL A Z)))
                 (EQUAL (MEMBER A (ADDTOLIST Z Y))
                        (MEMBER A Y))).

  This simplifies, applying the lemmas CDR-CONS and CAR-CONS, and unfolding
  the definitions of ADDTOLIST and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Y))
                      (NOT (EQUAL A Z)))
                 (EQUAL (MEMBER A (ADDTOLIST Z Y))
                        (MEMBER A Y))).

  This simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS, and
  unfolding ADDTOLIST, MEMBER, LISTP, and EQUAL, to:

        T.


     That finishes the proof of *1.1, which also finishes the proof of *1.
Q.E.D.


[ 0.0 0.1 0.0 ]

MEMBER-SORT


(PROVE-LEMMA LENGTH-SORT NIL
             (EQUAL (LENGTH (SORT A)) (LENGTH A)))


     Give the conjecture the name *1.


     We will appeal to induction.  Two 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 (AND (LISTP A) (p (CDR A)))
                    (p A))
           (IMPLIES (NOT (LISTP A)) (p A))).
Linear arithmetic and the lemma CDR-LESSP inform us 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 (LENGTH (SORT (CDR A)))
                             (LENGTH (CDR A))))
                 (EQUAL (LENGTH (SORT A)) (LENGTH A))).

  This simplifies, expanding the functions SORT and LENGTH, to the new goal:

        (IMPLIES (AND (LISTP A)
                      (EQUAL (LENGTH (SORT (CDR A)))
                             (LENGTH (CDR A))))
                 (EQUAL (LENGTH (ADDTOLIST (CAR A) (SORT (CDR A))))
                        (ADD1 (LENGTH (CDR A))))).

  Applying the lemma CAR-CDR-ELIM, replace A by (CONS Z X) to eliminate
  (CDR A) and (CAR A).  This produces:

        (IMPLIES (EQUAL (LENGTH (SORT X)) (LENGTH X))
                 (EQUAL (LENGTH (ADDTOLIST Z (SORT X)))
                        (ADD1 (LENGTH X)))).

  We use the above equality hypothesis by substituting (LENGTH (SORT X)) for
  (LENGTH X) and throwing away the equality.  We must thus prove:

        (EQUAL (LENGTH (ADDTOLIST Z (SORT X)))
               (ADD1 (LENGTH (SORT X)))).

  We will try to prove the above formula by generalizing it, replacing
  (SORT X) by Y.  This generates:

        (EQUAL (LENGTH (ADDTOLIST Z Y))
               (ADD1 (LENGTH Y))).

  Give the above formula the name *1.1.

Case 1. (IMPLIES (NOT (LISTP A))
                 (EQUAL (LENGTH (SORT A)) (LENGTH A))).

  This simplifies, opening up SORT, LENGTH, and EQUAL, to:

        T.


     So next consider:

      (EQUAL (LENGTH (ADDTOLIST Z Y))
             (ADD1 (LENGTH Y))),

which is formula *1.1 above.  We will appeal to induction.  Two 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 (AND (LISTP Y) (LESSP Z (CAR Y)))
                    (p Z Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (LESSP Z (CAR Y)))
                         (p Z (CDR Y)))
                    (p Z Y))
           (IMPLIES (NOT (LISTP Y)) (p Z Y))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces the following three new
formulas:

Case 3. (IMPLIES (AND (LISTP Y) (LESSP Z (CAR Y)))
                 (EQUAL (LENGTH (ADDTOLIST Z Y))
                        (ADD1 (LENGTH Y)))).

  This simplifies, opening up the definitions of ADDTOLIST and LENGTH, to the
  new conjecture:

        (IMPLIES (AND (LISTP Y) (LESSP Z (CAR Y)))
                 (EQUAL (LENGTH (CONS Z Y))
                        (ADD1 (ADD1 (LENGTH (CDR Y)))))),

  which again simplifies, rewriting with CDR-CONS, and unfolding LENGTH, to:

        T.

Case 2. (IMPLIES (AND (LISTP Y)
                      (NOT (LESSP Z (CAR Y)))
                      (EQUAL (LENGTH (ADDTOLIST Z (CDR Y)))
                             (ADD1 (LENGTH (CDR Y)))))
                 (EQUAL (LENGTH (ADDTOLIST Z Y))
                        (ADD1 (LENGTH Y)))).

  This simplifies, applying CDR-CONS, and opening up ADDTOLIST and LENGTH, to:

        T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (EQUAL (LENGTH (ADDTOLIST Z Y))
                        (ADD1 (LENGTH Y)))),

  which simplifies, rewriting with the lemma CDR-CONS, and opening up the
  functions ADDTOLIST, ADD1, LENGTH, and EQUAL, to:

        T.


     That finishes the proof of *1.1, which finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

LENGTH-SORT


(DEFN COUNT-LIST
      (A L)
      (FOR X IN L COUNT (EQUAL A X)))

   




[ 0.0 0.0 0.0 ]

COUNT-LIST


(PROVE-LEMMA COUNT-LIST-SORT NIL
             (EQUAL (COUNT-LIST A (SORT L))
                    (COUNT-LIST A L)))

This formula can be simplified, using the abbreviation COUNT-LIST, to the new
conjecture:

      (EQUAL (FOR X IN (SORT L) COUNT (EQUAL A X))
             (FOR X IN L COUNT (EQUAL A X))),

which we will name *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 (AND (LISTP L) (p (CDR L) A))
                    (p L A))
           (IMPLIES (NOT (LISTP L)) (p L A))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT L) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates two new
conjectures:

Case 2. (IMPLIES (AND (LISTP L)
                      (EQUAL (FOR X IN
                                  (SORT (CDR L))
                                  COUNT
                                  (EQUAL A X))
                             (FOR X IN (CDR L) COUNT (EQUAL A X))))
                 (EQUAL (FOR X IN (SORT L) COUNT (EQUAL A X))
                        (FOR X IN L COUNT (EQUAL A X)))),

  which simplifies, rewriting with REWRITE-EVAL$, and expanding the
  definitions of EVAL$, SORT, FOR, EQUAL, and QUANTIFIER-OPERATION, to the
  following two new formulas:

  Case 2.2.
          (IMPLIES (AND (LISTP L)
                        (EQUAL (FOR X IN
                                    (SORT (CDR L))
                                    COUNT
                                    (EQUAL A X))
                               (FOR X IN (CDR L) COUNT (EQUAL A X)))
                        (NOT (EQUAL A (CAR L))))
                   (EQUAL (FOR X IN
                               (ADDTOLIST (CAR L) (SORT (CDR L)))
                               COUNT
                               (EQUAL A X))
                          (FOR X IN
                               (CDR L)
                               COUNT
                               (EQUAL A X)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace L by (CONS Z X) to
    eliminate (CDR L) and (CAR L).  We must thus prove the formula:

          (IMPLIES (AND (EQUAL (FOR X IN (SORT X) COUNT (EQUAL A X))
                               (FOR X IN X COUNT (EQUAL A X)))
                        (NOT (EQUAL A Z)))
                   (EQUAL (FOR X IN
                               (ADDTOLIST Z (SORT X))
                               COUNT
                               (EQUAL A X))
                          (FOR X IN X COUNT (EQUAL A X)))).

    This further simplifies, opening up the function EVAL$, to:

          (IMPLIES (AND (EQUAL (FOR Y IN (SORT X) COUNT (EQUAL A Y))
                               (FOR Y IN X COUNT (EQUAL A Y)))
                        (NOT (EQUAL A Z)))
                   (EQUAL (FOR Y IN
                               (ADDTOLIST Z (SORT X))
                               COUNT
                               (EQUAL A Y))
                          (FOR Y IN X COUNT (EQUAL A Y)))).

    We use the above equality hypothesis by substituting:
          (FOR Y IN (SORT X) COUNT (EQUAL A Y))
    for (FOR Y IN X COUNT (EQUAL A Y)) and throwing away the equality.  This
    produces the new goal:

          (IMPLIES (NOT (EQUAL A Z))
                   (EQUAL (FOR Y IN
                               (ADDTOLIST Z (SORT X))
                               COUNT
                               (EQUAL A Y))
                          (FOR Y IN
                               (SORT X)
                               COUNT
                               (EQUAL A Y)))),

    which we generalize by replacing (SORT X) by Y.  We must thus prove:

          (IMPLIES (NOT (EQUAL A Z))
                   (EQUAL (FOR Y IN
                               (ADDTOLIST Z Y)
                               COUNT
                               (EQUAL A Y))
                          (FOR Y IN Y COUNT (EQUAL A Y)))).

    This further simplifies, expanding the definition of EVAL$, to:

          (IMPLIES (NOT (EQUAL A Z))
                   (EQUAL (FOR X IN
                               (ADDTOLIST Z Y)
                               COUNT
                               (EQUAL A X))
                          (FOR X IN Y COUNT (EQUAL A X)))).

    Finally name the above subgoal *1.1.

  Case 2.1.
          (IMPLIES (AND (LISTP L)
                        (EQUAL (FOR X IN
                                    (SORT (CDR L))
                                    COUNT
                                    (EQUAL A X))
                               (FOR X IN (CDR L) COUNT (EQUAL A X)))
                        (EQUAL A (CAR L)))
                   (EQUAL (FOR X IN
                               (ADDTOLIST (CAR L) (SORT (CDR L)))
                               COUNT
                               (EQUAL A X))
                          (ADD1 (FOR X IN
                                     (CDR L)
                                     COUNT
                                     (EQUAL A X))))).

    This again simplifies, expanding the definition of EVAL$, to:

          (IMPLIES (AND (LISTP L)
                        (EQUAL (FOR X IN
                                    (SORT (CDR L))
                                    COUNT
                                    (EQUAL (CAR L) X))
                               (FOR X IN
                                    (CDR L)
                                    COUNT
                                    (EQUAL (CAR L) X))))
                   (EQUAL (FOR X IN
                               (ADDTOLIST (CAR L) (SORT (CDR L)))
                               COUNT
                               (EQUAL (CAR L) X))
                          (ADD1 (FOR X IN
                                     (CDR L)
                                     COUNT
                                     (EQUAL (CAR L) X))))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace L by (CONS Z X) to
    eliminate (CDR L) and (CAR L).  The result is the conjecture:

          (IMPLIES (EQUAL (FOR 'X
                               (SORT X)
                               (LIST 'QUOTE T)
                               'COUNT
                               '(EQUAL (CAR L) X)
                               (LIST (CONS 'L (CONS Z X))))
                          (FOR 'X
                               X
                               (LIST 'QUOTE T)
                               'COUNT
                               '(EQUAL (CAR L) X)
                               (LIST (CONS 'L (CONS Z X)))))
                   (EQUAL (FOR 'X
                               (ADDTOLIST Z (SORT X))
                               (LIST 'QUOTE T)
                               'COUNT
                               '(EQUAL (CAR L) X)
                               (LIST (CONS 'L (CONS Z X))))
                          (ADD1 (FOR 'X
                                     X
                                     (LIST 'QUOTE T)
                                     'COUNT
                                     '(EQUAL (CAR L) X)
                                     (LIST (CONS 'L (CONS Z X))))))).

    This further simplifies, appealing to the lemma CAR-CONS, and opening up
    the function EVAL$, to:

          (IMPLIES (EQUAL (FOR Y IN (SORT X) COUNT (EQUAL Z Y))
                          (FOR Y IN X COUNT (EQUAL Z Y)))
                   (EQUAL (FOR Y IN
                               (ADDTOLIST Z (SORT X))
                               COUNT
                               (EQUAL Z Y))
                          (ADD1 (FOR Y IN X COUNT (EQUAL Z Y))))).

    We now use the above equality hypothesis by substituting:
          (FOR Y IN (SORT X) COUNT (EQUAL Z Y))
    for (FOR Y IN X COUNT (EQUAL Z Y)) and throwing away the equality.  We
    would thus like to prove:

          (EQUAL (FOR Y IN
                      (ADDTOLIST Z (SORT X))
                      COUNT
                      (EQUAL Z Y))
                 (ADD1 (FOR Y IN
                            (SORT X)
                            COUNT
                            (EQUAL Z Y)))),

    which we generalize by replacing (SORT X) by Y.  This generates the goal:

          (EQUAL (FOR Y IN
                      (ADDTOLIST Z Y)
                      COUNT
                      (EQUAL Z Y))
                 (ADD1 (FOR Y IN Y COUNT (EQUAL Z Y)))).

    However this further simplifies, opening up the definition of EVAL$, to:

          (EQUAL (FOR X IN
                      (ADDTOLIST Z Y)
                      COUNT
                      (EQUAL Z X))
                 (ADD1 (FOR X IN Y COUNT (EQUAL Z X)))).

    Finally name the above subgoal *1.2.

Case 1. (IMPLIES (NOT (LISTP L))
                 (EQUAL (FOR X IN (SORT L) COUNT (EQUAL A X))
                        (FOR X IN L COUNT (EQUAL A X)))).

  This simplifies, expanding the functions SORT, MEMBER, LISTP, FOR, CDR,
  ASSOC, QUANTIFIER-INITIAL-VALUE, and EQUAL, to:

        T.


     So next consider:

      (EQUAL (FOR X IN
                  (ADDTOLIST Z Y)
                  COUNT
                  (EQUAL Z X))
             (ADD1 (FOR X IN Y COUNT (EQUAL Z X)))),

named *1.2 above.  Perhaps we can prove it by induction.  The recursive terms
in the conjecture suggest two inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP Y) (LESSP Z (CAR Y)))
                    (p Z Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (LESSP Z (CAR Y)))
                         (p Z (CDR Y)))
                    (p Z Y))
           (IMPLIES (NOT (LISTP Y)) (p Z Y))).
Linear arithmetic and the lemma CDR-LESSP can be used to establish that the
measure (COUNT Y) decreases according to the well-founded relation LESSP in
each induction step of the scheme.  The above induction scheme produces three
new goals:

Case 3. (IMPLIES (AND (LISTP Y) (LESSP Z (CAR Y)))
                 (EQUAL (FOR X IN
                             (ADDTOLIST Z Y)
                             COUNT
                             (EQUAL Z X))
                        (ADD1 (FOR X IN Y COUNT (EQUAL Z X))))),

  which simplifies, applying the lemmas CAR-CONS, CDR-CONS, and REWRITE-EVAL$,
  and unfolding the functions ADDTOLIST, MEMBER, EVAL$, FOR, EQUAL, and
  QUANTIFIER-OPERATION, to two new conjectures:

  Case 3.2.
          (IMPLIES (AND (LISTP Y)
                        (LESSP Z (CAR Y))
                        (NOT (EQUAL Z (CAR Y))))
                   (EQUAL (FOR X IN
                               (CONS Z Y)
                               COUNT
                               (EQUAL Z X))
                          (ADD1 (FOR X IN
                                     (CDR Y)
                                     COUNT
                                     (EQUAL Z X))))),

    which again simplifies, applying CAR-CONS, CDR-CONS, and REWRITE-EVAL$,
    and opening up the definitions of MEMBER, EVAL$, QUANTIFIER-OPERATION,
    EQUAL, and FOR, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Y)
                        (LESSP Z (CAR Y))
                        (EQUAL Z (CAR Y)))
                   (EQUAL (FOR X IN
                               (CONS Z Y)
                               COUNT
                               (EQUAL Z X))
                          (ADD1 (ADD1 (FOR X IN
                                           (CDR Y)
                                           COUNT
                                           (EQUAL Z X)))))).

    However this again simplifies, using linear arithmetic, to:

          T.

Case 2. (IMPLIES (AND (LISTP Y)
                      (NOT (LESSP Z (CAR Y)))
                      (EQUAL (FOR X IN
                                  (ADDTOLIST Z (CDR Y))
                                  COUNT
                                  (EQUAL Z X))
                             (ADD1 (FOR X IN
                                        (CDR Y)
                                        COUNT
                                        (EQUAL Z X)))))
                 (EQUAL (FOR X IN
                             (ADDTOLIST Z Y)
                             COUNT
                             (EQUAL Z X))
                        (ADD1 (FOR X IN Y COUNT (EQUAL Z X))))),

  which simplifies, rewriting with the lemmas CAR-CONS, CDR-CONS, and
  REWRITE-EVAL$, and expanding the definitions of EVAL$, ADDTOLIST, MEMBER,
  QUANTIFIER-OPERATION, EQUAL, and FOR, to:

        T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (EQUAL (FOR X IN
                             (ADDTOLIST Z Y)
                             COUNT
                             (EQUAL Z X))
                        (ADD1 (FOR X IN Y COUNT (EQUAL Z X))))),

  which simplifies, applying CAR-CONS, CDR-CONS, and REWRITE-EVAL$, and
  expanding ADDTOLIST, LISTP, MEMBER, EVAL$, QUANTIFIER-OPERATION, FOR, CDR,
  ASSOC, QUANTIFIER-INITIAL-VALUE, ADD1, and EQUAL, to:

        T.


     That finishes the proof of *1.2.


     So next consider:

      (IMPLIES (NOT (EQUAL A Z))
               (EQUAL (FOR X IN
                           (ADDTOLIST Z Y)
                           COUNT
                           (EQUAL A X))
                      (FOR X IN Y COUNT (EQUAL A X)))),

which we named *1.1 above.  Perhaps we can prove it by induction.  Two
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 (AND (LISTP Y) (LESSP Z (CAR Y)))
                    (p Z Y A))
           (IMPLIES (AND (LISTP Y)
                         (NOT (LESSP Z (CAR Y)))
                         (p Z (CDR Y) A))
                    (p Z Y A))
           (IMPLIES (NOT (LISTP Y)) (p Z Y A))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces the following three new
conjectures:

Case 3. (IMPLIES (AND (LISTP Y)
                      (LESSP Z (CAR Y))
                      (NOT (EQUAL A Z)))
                 (EQUAL (FOR X IN
                             (ADDTOLIST Z Y)
                             COUNT
                             (EQUAL A X))
                        (FOR X IN Y COUNT (EQUAL A X)))).

  This simplifies, rewriting with the lemmas CAR-CONS, CDR-CONS, and
  REWRITE-EVAL$, and unfolding the definitions of ADDTOLIST, MEMBER, EVAL$,
  FOR, EQUAL, and QUANTIFIER-OPERATION, to the following two new goals:

  Case 3.2.
          (IMPLIES (AND (LISTP Y)
                        (LESSP Z (CAR Y))
                        (NOT (EQUAL A Z))
                        (NOT (EQUAL A (CAR Y))))
                   (EQUAL (FOR X IN
                               (CONS Z Y)
                               COUNT
                               (EQUAL A X))
                          (FOR X IN
                               (CDR Y)
                               COUNT
                               (EQUAL A X)))).

    This again simplifies, applying CAR-CONS, CDR-CONS, and REWRITE-EVAL$, and
    expanding the definitions of MEMBER, EVAL$, QUANTIFIER-OPERATION, EQUAL,
    and FOR, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Y)
                        (LESSP Z (CAR Y))
                        (NOT (EQUAL A Z))
                        (EQUAL A (CAR Y)))
                   (EQUAL (FOR X IN
                               (CONS Z Y)
                               COUNT
                               (EQUAL A X))
                          (ADD1 (FOR X IN
                                     (CDR Y)
                                     COUNT
                                     (EQUAL A X))))).

    However this again simplifies, rewriting with CAR-CONS, CDR-CONS, and
    REWRITE-EVAL$, and unfolding MEMBER, EVAL$, QUANTIFIER-OPERATION, EQUAL,
    and FOR, to:

          (IMPLIES (AND (LISTP Y)
                        (LESSP Z (CAR Y))
                        (NOT (EQUAL (CAR Y) Z)))
                   (EQUAL (FOR X IN Y COUNT (EQUAL (CAR Y) X))
                          (ADD1 (FOR X IN
                                     (CDR Y)
                                     COUNT
                                     (EQUAL (CAR Y) X))))),

    which again simplifies, rewriting with REWRITE-EVAL$, and expanding EVAL$,
    QUANTIFIER-OPERATION, EQ