(BOOT-STRAP NQTHM)

[ 0.1 0.1 0.0 ]

GROUND-ZERO


(SETQ REDUCE-TERM-CLOCK 2000)

2000


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

     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, DELETE is accepted under the principle of definition.




[ 0.0 0.0 0.0 ]

DELETE


(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


(DEFN OCCURRENCES
      (X L)
      (IF (LISTP L)
          (IF (EQUAL X (CAR L))
              (ADD1 (OCCURRENCES X (CDR L)))
              (OCCURRENCES X (CDR L)))
          0))

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




[ 0.0 0.0 0.0 ]

OCCURRENCES


(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


(PROVE-LEMMA LISTP-DELETE
             (REWRITE)
             (EQUAL (LISTP (DELETE X L))
                    (IF (LISTP L)
                        (OR (NOT (EQUAL X (CAR L)))
                            (LISTP (CDR L)))
                        F))
             ((ENABLE DELETE)
              (INDUCT (DELETE X L))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This conjecture can be simplified, using the abbreviations NOT, OR, and AND,
to three new conjectures:

Case 3. (IMPLIES (AND (LISTP L) (EQUAL X (CAR L)))
                 (EQUAL (LISTP (DELETE X L))
                        (IF (LISTP L)
                            (OR (NOT (EQUAL X (CAR L)))
                                (LISTP (CDR L)))
                            F))),

  which simplifies, opening up the definitions of DELETE, NOT, and OR, to:

        T.

Case 2. (IMPLIES (AND (LISTP L)
                      (NOT (EQUAL X (CAR L)))
                      (EQUAL (LISTP (DELETE X (CDR L)))
                             (IF (LISTP (CDR L))
                                 (OR (NOT (EQUAL X (CADR L)))
                                     (LISTP (CDDR L)))
                                 F)))
                 (EQUAL (LISTP (DELETE X L))
                        (IF (LISTP L)
                            (OR (NOT (EQUAL X (CAR L)))
                                (LISTP (CDR L)))
                            F))),

  which simplifies, applying CONS-CAR-CDR, and unfolding DELETE, NOT, OR, and
  EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP L))
                 (EQUAL (LISTP (DELETE X L))
                        (IF (LISTP L)
                            (OR (NOT (EQUAL X (CAR L)))
                                (LISTP (CDR L)))
                            F))).

  This simplifies, opening up DELETE and EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

LISTP-DELETE


(TOGGLE LISTP-DELETE-OFF LISTP-DELETE T)

[ 0.0 0.0 0.0 ]

LISTP-DELETE-OFF


(PROVE-LEMMA DELETE-NON-MEMBER
             (REWRITE)
             (IMPLIES (NOT (MEMBER X Y))
                      (EQUAL (DELETE X Y) Y))
             ((ENABLE DELETE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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 DELETE-DELETE
             (REWRITE)
             (EQUAL (DELETE Y (DELETE X Z))
                    (DELETE X (DELETE Y Z)))
             ((ENABLE DELETE DELETE-NON-MEMBER)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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 X (CAR Z)))
                    (p Y X Z))
           (IMPLIES (AND (LISTP Z)
                         (NOT (EQUAL X (CAR Z)))
                         (p Y X (CDR Z)))
                    (p Y X Z))
           (IMPLIES (NOT (LISTP Z)) (p Y X 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 X (CAR Z)))
                 (EQUAL (DELETE Y (DELETE X Z))
                        (DELETE X (DELETE Y Z)))),

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

  Case 3.2.
          (IMPLIES (AND (LISTP Z)
                        (NOT (EQUAL Y (CAR Z))))
                   (EQUAL (DELETE Y (CDR Z))
                          (DELETE (CAR Z)
                                  (CONS (CAR Z) (DELETE Y (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 Y (CAR Z)))
                   (EQUAL (DELETE Y (CDR Z))
                          (DELETE (CAR Z) (CDR Z)))).

    This again simplifies, obviously, to:

          T.

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

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

        (IMPLIES (AND (LISTP Z)
                      (NOT (EQUAL X (CAR Z)))
                      (EQUAL (DELETE Y (DELETE X (CDR Z)))
                             (DELETE X (DELETE Y (CDR Z))))
                      (NOT (EQUAL Y (CAR Z))))
                 (EQUAL (CONS (CAR Z)
                              (DELETE X (DELETE Y (CDR Z))))
                        (DELETE X
                                (CONS (CAR Z) (DELETE Y (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 Y (DELETE X Z))
                        (DELETE X (DELETE Y 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 ]

DELETE-DELETE


(PROVE-LEMMA EQUAL-OCCURRENCES-ZERO
             (REWRITE)
             (EQUAL (EQUAL (OCCURRENCES X L) 0)
                    (NOT (MEMBER X L)))
             ((ENABLE OCCURRENCES)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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

Case 2. (IMPLIES (NOT (EQUAL (OCCURRENCES X L) 0))
                 (MEMBER X L)),

  which we will name *1.

Case 1. (IMPLIES (EQUAL (OCCURRENCES X L) 0)
                 (NOT (MEMBER X L))),

  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 (EQUAL (OCCURRENCES X L) 0)
       (NOT (MEMBER X L))).

We gave this the name *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 L)
                         (EQUAL X (CAR L))
                         (p X (CDR L)))
                    (p X L))
           (IMPLIES (AND (LISTP L)
                         (NOT (EQUAL X (CAR L)))
                         (p X (CDR L)))
                    (p X L))
           (IMPLIES (NOT (LISTP L)) (p X L))).
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.  The above induction scheme leads to the following three new
formulas:

Case 3. (IMPLIES (AND (LISTP L)
                      (EQUAL X (CAR L))
                      (EQUAL (EQUAL (OCCURRENCES X (CDR L)) 0)
                             (NOT (MEMBER X (CDR L)))))
                 (EQUAL (EQUAL (OCCURRENCES X L) 0)
                        (NOT (MEMBER X L)))).

  This simplifies, unfolding the definitions of NOT, OCCURRENCES, MEMBER,
  EQUAL, and ADD1, to:

        T.

Case 2. (IMPLIES (AND (LISTP L)
                      (NOT (EQUAL X (CAR L)))
                      (EQUAL (EQUAL (OCCURRENCES X (CDR L)) 0)
                             (NOT (MEMBER X (CDR L)))))
                 (EQUAL (EQUAL (OCCURRENCES X L) 0)
                        (NOT (MEMBER X L)))).

  This simplifies, expanding the definitions of NOT, OCCURRENCES, MEMBER, and
  EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP L))
                 (EQUAL (EQUAL (OCCURRENCES X L) 0)
                        (NOT (MEMBER X L)))).

  This simplifies, expanding the definitions of OCCURRENCES, EQUAL, MEMBER,
  and NOT, to:

        T.


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


[ 0.0 0.0 0.0 ]

EQUAL-OCCURRENCES-ZERO


(PROVE-LEMMA MEMBER-NON-LIST
             (REWRITE)
             (IMPLIES (NOT (LISTP L))
                      (NOT (MEMBER X L)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This formula simplifies, opening up the definition of MEMBER, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

MEMBER-NON-LIST


(PROVE-LEMMA MEMBER-DELETE
             (REWRITE)
             (EQUAL (MEMBER X (DELETE Y L))
                    (IF (MEMBER X L)
                        (IF (EQUAL X Y)
                            (LESSP 1 (OCCURRENCES X L))
                            T)
                        F))
             ((ENABLE DELETE OCCURRENCES)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This simplifies, obviously, to three new goals:

Case 3. (IMPLIES (NOT (MEMBER X L))
                 (EQUAL (MEMBER X (DELETE Y L)) F)),

  which again simplifies, trivially, to:

        (IMPLIES (NOT (MEMBER X L))
                 (NOT (MEMBER X (DELETE Y L)))),

  which we will name *1.

Case 2. (IMPLIES (AND (MEMBER X L) (EQUAL X Y))
                 (EQUAL (MEMBER X (DELETE Y L))
                        (LESSP 1 (OCCURRENCES X L)))).

  This again simplifies, obviously, to:

        (IMPLIES (MEMBER Y L)
                 (EQUAL (MEMBER Y (DELETE Y L))
                        (LESSP 1 (OCCURRENCES Y L)))),

  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 (DELETE Y L))
       (IF (MEMBER X L)
           (IF (EQUAL X Y)
               (LESSP 1 (OCCURRENCES X L))
               T)
           F)).

We named this *1.  We will try to 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 (AND (LISTP L) (EQUAL Y (CAR L)))
                    (p X Y L))
           (IMPLIES (AND (LISTP L)
                         (NOT (EQUAL Y (CAR L)))
                         (p X Y (CDR L)))
                    (p X Y L))
           (IMPLIES (NOT (LISTP L)) (p X Y L))).
Linear arithmetic and the lemma CDR-LESSP 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 produces three new conjectures:

Case 3. (IMPLIES (AND (LISTP L) (EQUAL Y (CAR L)))
                 (EQUAL (MEMBER X (DELETE Y L))
                        (IF (MEMBER X L)
                            (IF (EQUAL X Y)
                                (LESSP 1 (OCCURRENCES X L))
                                T)
                            F))),

  which simplifies, applying SUB1-ADD1, and unfolding DELETE, MEMBER,
  OCCURRENCES, SUB1, NUMBERP, EQUAL, and LESSP, to the following four new
  conjectures:

  Case 3.4.
          (IMPLIES (AND (LISTP L)
                        (EQUAL X (CAR L))
                        (NOT (EQUAL (OCCURRENCES X (CDR L)) 0)))
                   (EQUAL (MEMBER X (CDR L)) T)).

    This again simplifies, clearly, to:

          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL (OCCURRENCES (CAR L) (CDR L))
                                    0)))
                   (MEMBER (CAR L) (CDR L))).

    Applying the lemma CAR-CDR-ELIM, replace L by (CONS Z V) to eliminate
    (CAR L) and (CDR L).  We thus obtain:

          (IMPLIES (NOT (EQUAL (OCCURRENCES Z V) 0))
                   (MEMBER Z V)),

    which we will name *1.1.

  Case 3.3.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL X (CAR L)))
                        (MEMBER X (CDR L)))
                   (EQUAL (MEMBER X (CDR L)) T)).

    This again simplifies, clearly, to:

          T.

  Case 3.2.
          (IMPLIES (AND (LISTP L)
                        (EQUAL X (CAR L))
                        (EQUAL (OCCURRENCES X (CDR L)) 0))
                   (EQUAL (MEMBER X (CDR L)) F)).

    This again simplifies, clearly, to:

          (IMPLIES (AND (LISTP L)
                        (EQUAL (OCCURRENCES (CAR L) (CDR L))
                               0))
                   (NOT (MEMBER (CAR L) (CDR L)))).

    Applying the lemma CAR-CDR-ELIM, replace L by (CONS Z V) to eliminate
    (CAR L) and (CDR L).  We would thus like to prove the new formula:

          (IMPLIES (EQUAL (OCCURRENCES Z V) 0)
                   (NOT (MEMBER Z V))),

    which we will name *1.2.

  Case 3.1.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL X (CAR L)))
                        (NOT (MEMBER X (CDR L))))
                   (EQUAL (MEMBER X (CDR L)) F)).

    This again simplifies, trivially, to:

          T.

Case 2. (IMPLIES (AND (LISTP L)
                      (NOT (EQUAL Y (CAR L)))
                      (EQUAL (MEMBER X (DELETE Y (CDR L)))
                             (IF (MEMBER X (CDR L))
                                 (IF (EQUAL X Y)
                                     (LESSP 1 (OCCURRENCES X (CDR L)))
                                     T)
                                 F)))
                 (EQUAL (MEMBER X (DELETE Y L))
                        (IF (MEMBER X L)
                            (IF (EQUAL X Y)
                                (LESSP 1 (OCCURRENCES X L))
                                T)
                            F))).

  This simplifies, applying CDR-CONS, CAR-CONS, and SUB1-ADD1, and opening up
  the definitions of DELETE, MEMBER, OCCURRENCES, SUB1, NUMBERP, EQUAL, and
  LESSP, to three new formulas:

  Case 2.3.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL Y (CAR L)))
                        (NOT (MEMBER X (CDR L)))
                        (EQUAL (MEMBER X (DELETE Y (CDR L)))
                               F)
                        (EQUAL X (CAR L))
                        (EQUAL X Y))
                   (NOT (EQUAL (OCCURRENCES X (CDR L)) 0))),

    which again simplifies, clearly, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL Y (CAR L)))
                        (MEMBER X (CDR L))
                        (EQUAL X Y)
                        (EQUAL (MEMBER X (DELETE Y (CDR L)))
                               (LESSP 1 (OCCURRENCES X (CDR L))))
                        (NOT (EQUAL X (CAR L))))
                   (EQUAL (MEMBER X
                                  (CONS (CAR L) (DELETE X (CDR L))))
                          (LESSP 1 (OCCURRENCES X (CDR L))))).

    This again simplifies, applying CDR-CONS and CAR-CONS, and expanding
    MEMBER, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL Y (CAR L)))
                        (MEMBER X (CDR L))
                        (EQUAL X Y)
                        (EQUAL (MEMBER X (DELETE Y (CDR L)))
                               (LESSP 1 (OCCURRENCES X (CDR L))))
                        (EQUAL X (CAR L)))
                   (EQUAL (MEMBER X (CDR L))
                          (LESSP 1
                                 (ADD1 (OCCURRENCES X (CDR L)))))).

    This again simplifies, trivially, to:

          T.

Case 1. (IMPLIES (NOT (LISTP L))
                 (EQUAL (MEMBER X (DELETE Y L))
                        (IF (MEMBER X L)
                            (IF (EQUAL X Y)
                                (LESSP 1 (OCCURRENCES X L))
                                T)
                            F))).

  This simplifies, unfolding the functions DELETE, MEMBER, and EQUAL, to:

        T.


     So next consider:

      (IMPLIES (EQUAL (OCCURRENCES Z V) 0)
               (NOT (MEMBER Z V))),

which we named *1.2 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 V)
                         (EQUAL Z (CAR V))
                         (p Z (CDR V)))
                    (p Z V))
           (IMPLIES (AND (LISTP V)
                         (NOT (EQUAL Z (CAR V)))
                         (p Z (CDR V)))
                    (p Z V))
           (IMPLIES (NOT (LISTP V)) (p Z V))).
Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT V) 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 (LISTP V)
                      (EQUAL Z (CAR V))
                      (NOT (EQUAL (OCCURRENCES Z (CDR V)) 0))
                      (EQUAL (OCCURRENCES Z V) 0))
                 (NOT (MEMBER Z V))),

  which simplifies, expanding the function OCCURRENCES, to:

        T.

Case 4. (IMPLIES (AND (LISTP V)
                      (EQUAL Z (CAR V))
                      (NOT (MEMBER Z (CDR V)))
                      (EQUAL (OCCURRENCES Z V) 0))
                 (NOT (MEMBER Z V))),

  which simplifies, expanding the definition of OCCURRENCES, to:

        T.

Case 3. (IMPLIES (AND (LISTP V)
                      (NOT (EQUAL Z (CAR V)))
                      (NOT (EQUAL (OCCURRENCES Z (CDR V)) 0))
                      (EQUAL (OCCURRENCES Z V) 0))
                 (NOT (MEMBER Z V))),

  which simplifies, unfolding the function OCCURRENCES, to:

        T.

Case 2. (IMPLIES (AND (LISTP V)
                      (NOT (EQUAL Z (CAR V)))
                      (NOT (MEMBER Z (CDR V)))
                      (EQUAL (OCCURRENCES Z V) 0))
                 (NOT (MEMBER Z V))),

  which simplifies, expanding the definitions of OCCURRENCES and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP V))
                      (EQUAL (OCCURRENCES Z V) 0))
                 (NOT (MEMBER Z V))),

  which simplifies, unfolding the functions OCCURRENCES, EQUAL, and MEMBER, to:

        T.


     That finishes the proof of *1.2.


     So let us turn our attention to:

      (IMPLIES (NOT (EQUAL (OCCURRENCES Z V) 0))
               (MEMBER Z V)),

which is formula *1.1 above.  Let us appeal to the induction principle.  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 V)
                         (EQUAL Z (CAR V))
                         (p Z (CDR V)))
                    (p Z V))
           (IMPLIES (AND (LISTP V)
                         (NOT (EQUAL Z (CAR V)))
                         (p Z (CDR V)))
                    (p Z V))
           (IMPLIES (NOT (LISTP V)) (p Z V))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT V)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme leads to five new conjectures:

Case 5. (IMPLIES (AND (LISTP V)
                      (EQUAL Z (CAR V))
                      (EQUAL (OCCURRENCES Z (CDR V)) 0)
                      (NOT (EQUAL (OCCURRENCES Z V) 0)))
                 (MEMBER Z V)),

  which simplifies, opening up ADD1, OCCURRENCES, EQUAL, and MEMBER, to:

        T.

Case 4. (IMPLIES (AND (LISTP V)
                      (EQUAL Z (CAR V))
                      (MEMBER Z (CDR V))
                      (NOT (EQUAL (OCCURRENCES Z V) 0)))
                 (MEMBER Z V)),

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

        T.

Case 3. (IMPLIES (AND (LISTP V)
                      (NOT (EQUAL Z (CAR V)))
                      (EQUAL (OCCURRENCES Z (CDR V)) 0)
                      (NOT (EQUAL (OCCURRENCES Z V) 0)))
                 (MEMBER Z V)),

  which simplifies, unfolding OCCURRENCES and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (LISTP V)
                      (NOT (EQUAL Z (CAR V)))
                      (MEMBER Z (CDR V))
                      (NOT (EQUAL (OCCURRENCES Z V) 0)))
                 (MEMBER Z V)),

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

        T.

Case 1. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (EQUAL (OCCURRENCES Z V) 0)))
                 (MEMBER Z V)),

  which simplifies, opening up the functions OCCURRENCES 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 ]

MEMBER-DELETE


(PROVE-LEMMA MEMBER-DELETE-IMPLIES-MEMBERSHIP
             (REWRITE)
             (IMPLIES (MEMBER X (DELETE Y L))
                      (MEMBER X L))
             ((ENABLE DELETE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

WARNING:  Note that MEMBER-DELETE-IMPLIES-MEMBERSHIP contains the free
variable Y which will be chosen by instantiating the hypothesis
(MEMBER X (DELETE Y L)).



     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 L) (EQUAL Y (CAR L)))
                    (p X L Y))
           (IMPLIES (AND (LISTP L)
                         (NOT (EQUAL Y (CAR L)))
                         (p X (CDR L) Y))
                    (p X L Y))
           (IMPLIES (NOT (LISTP L)) (p X L Y))).
Linear arithmetic and the lemma CDR-LESSP 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 four new conjectures:

Case 4. (IMPLIES (AND (LISTP L)
                      (EQUAL Y (CAR L))
                      (MEMBER X (DELETE Y L)))
                 (MEMBER X L)),

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

        T.

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

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

        T.

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

  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 L))
                      (MEMBER X (DELETE Y L)))
                 (MEMBER X L)),

  which simplifies, expanding DELETE and MEMBER, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMBER-DELETE-IMPLIES-MEMBERSHIP


(PROVE-LEMMA OCCURRENCES-DELETE
             (REWRITE)
             (EQUAL (OCCURRENCES X (DELETE Y L))
                    (IF (EQUAL X Y)
                        (IF (MEMBER X L)
                            (SUB1 (OCCURRENCES X L))
                            0)
                        (OCCURRENCES X L)))
             ((ENABLE OCCURRENCES DELETE EQUAL-OCCURRENCES-ZERO)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This conjecture simplifies, clearly, to three new conjectures:

Case 3. (IMPLIES (NOT (EQUAL X Y))
                 (EQUAL (OCCURRENCES X (DELETE Y L))
                        (OCCURRENCES X L))),

  which we will name *1.

Case 2. (IMPLIES (AND (EQUAL X Y) (MEMBER X L))
                 (EQUAL (OCCURRENCES X (DELETE Y L))
                        (SUB1 (OCCURRENCES X L)))).

  This again simplifies, obviously, to:

        (IMPLIES (MEMBER Y L)
                 (EQUAL (OCCURRENCES Y (DELETE Y L))
                        (SUB1 (OCCURRENCES Y L)))),

  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 (OCCURRENCES X (DELETE Y L))
       (IF (EQUAL X Y)
           (IF (MEMBER X L)
               (SUB1 (OCCURRENCES X L))
               0)
           (OCCURRENCES X L))),

named *1.  Let us appeal to the induction principle.  Four 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 L) (EQUAL Y (CAR L)))
                    (p X Y L))
           (IMPLIES (AND (LISTP L)
                         (NOT (EQUAL Y (CAR L)))
                         (p X Y (CDR L)))
                    (p X Y L))
           (IMPLIES (NOT (LISTP L)) (p X Y L))).
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.  The above induction scheme produces three new conjectures:

Case 3. (IMPLIES (AND (LISTP L) (EQUAL Y (CAR L)))
                 (EQUAL (OCCURRENCES X (DELETE Y L))
                        (IF (EQUAL X Y)
                            (IF (MEMBER X L)
                                (SUB1 (OCCURRENCES X L))
                                0)
                            (OCCURRENCES X L)))),

  which simplifies, applying SUB1-ADD1, and expanding the definitions of
  DELETE, MEMBER, and OCCURRENCES, to:

        T.

Case 2. (IMPLIES (AND (LISTP L)
                      (NOT (EQUAL Y (CAR L)))
                      (EQUAL (OCCURRENCES X (DELETE Y (CDR L)))
                             (IF (EQUAL X Y)
                                 (IF (MEMBER X (CDR L))
                                     (SUB1 (OCCURRENCES X (CDR L)))
                                     0)
                                 (OCCURRENCES X (CDR L)))))
                 (EQUAL (OCCURRENCES X (DELETE Y L))
                        (IF (EQUAL X Y)
                            (IF (MEMBER X L)
                                (SUB1 (OCCURRENCES X L))
                                0)
                            (OCCURRENCES X L)))).

  This simplifies, applying CDR-CONS, CAR-CONS, and SUB1-ADD1, and expanding
  the functions DELETE, OCCURRENCES, and MEMBER, to three new goals:

  Case 2.3.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL Y (CAR L)))
                        (EQUAL X Y)
                        (MEMBER X (CDR L))
                        (EQUAL (OCCURRENCES X (DELETE Y (CDR L)))
                               (SUB1 (OCCURRENCES X (CDR L))))
                        (NOT (EQUAL X (CAR L))))
                   (EQUAL (OCCURRENCES X
                                       (CONS (CAR L) (DELETE X (CDR L))))
                          (SUB1 (OCCURRENCES X (CDR L))))),

    which again simplifies, applying CDR-CONS and CAR-CONS, and unfolding the
    function OCCURRENCES, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL Y (CAR L)))
                        (EQUAL X Y)
                        (MEMBER X (CDR L))
                        (EQUAL (OCCURRENCES X (DELETE Y (CDR L)))
                               (SUB1 (OCCURRENCES X (CDR L))))
                        (EQUAL X (CAR L)))
                   (EQUAL (OCCURRENCES X (CDR L))
                          (SUB1 (ADD1 (OCCURRENCES X (CDR L)))))).

    This again simplifies, clearly, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP L)
                        (NOT (EQUAL Y (CAR L)))
                        (EQUAL X Y)
                        (NOT (MEMBER X (CDR L)))
                        (EQUAL (OCCURRENCES X (DELETE Y (CDR L)))
                               0)
                        (NOT (EQUAL X (CAR L))))
                   (EQUAL (OCCURRENCES X
                                       (CONS (CAR L) (DELETE X (CDR L))))
                          0)).

    This again simplifies, rewriting with EQUAL-OCCURRENCES-ZERO, CDR-CONS,
    and CAR-CONS, and unfolding OCCURRENCES, to:

          T.

Case 1. (IMPLIES (NOT (LISTP L))
                 (EQUAL (OCCURRENCES X (DELETE Y L))
                        (IF (EQUAL X Y)
                            (IF (MEMBER X L)
                                (SUB1 (OCCURRENCES X L))
                                0)
                            (OCCURRENCES X L)))).

  This simplifies, unfolding DELETE, OCCURRENCES, MEMBER, and EQUAL, to:

        T.


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


[ 0.0 0.0 0.0 ]

OCCURRENCES-DELETE


(PROVE-LEMMA MEMBER-BAGDIFF
             (REWRITE)
             (EQUAL (MEMBER X (BAGDIFF A B))
                    (LESSP (OCCURRENCES X B)
                           (OCCURRENCES X A)))
             ((ENABLE BAGDIFF OCCURRENCES EQUAL-OCCURRENCES-ZERO
                      OCCURRENCES-DELETE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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 B)
                         (MEMBER (CAR B) A)
                         (p X (DELETE (CAR B) A) (CDR B)))
                    (p X A B))
           (IMPLIES (AND (LISTP B)
                         (NOT (MEMBER (CAR B) A))
                         (p X A (CDR B)))
                    (p X A B))
           (IMPLIES (NOT (LISTP B)) (p X A B))).
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.  Note, however, the inductive instances chosen for A.  The
above induction scheme generates three new goals:

Case 3. (IMPLIES (AND (LISTP B)
                      (MEMBER (CAR B) A)
                      (EQUAL (MEMBER X
                                     (BAGDIFF (DELETE (CAR B) A) (CDR B)))
                             (LESSP (OCCURRENCES X (CDR B))
                                    (OCCURRENCES X (DELETE (CAR B) A)))))
                 (EQUAL (MEMBER X (BAGDIFF A B))
                        (LESSP (OCCURRENCES X B)
                               (OCCURRENCES X A)))),

  which simplifies, appealing to the lemmas OCCURRENCES-DELETE, SUB1-ADD1, and
  EQUAL-OCCURRENCES-ZERO, and unfolding BAGDIFF, OCCURRENCES, and LESSP, to:

        (IMPLIES (AND (LISTP B)
                      (MEMBER (CAR B) A)
                      (EQUAL X (CAR B))
                      (NOT (MEMBER X A))
                      (EQUAL (MEMBER X
                                     (BAGDIFF (DELETE (CAR B) A) (CDR B)))
                             (LESSP (OCCURRENCES X (CDR B)) 0)))
                 (NOT (MEMBER X (BAGDIFF A (CDR B))))).

  This again simplifies, clearly, to:

        T.

Case 2. (IMPLIES (AND (LISTP B)
                      (NOT (MEMBER (CAR B) A))
                      (EQUAL (MEMBER X (BAGDIFF A (CDR B)))
                             (LESSP (OCCURRENCES X (CDR B))
                                    (OCCURRENCES X A))))
                 (EQUAL (MEMBER X (BAGDIFF A B))
                        (LESSP (OCCURRENCES X B)
                               (OCCURRENCES X A)))).

  This simplifies, expanding the functions BAGDIFF and OCCURRENCES, to the
  following two new goals:

  Case 2.2.
          (IMPLIES (AND (LISTP B)
                        (NOT (MEMBER (CAR B) A))
                        (EQUAL (MEMBER X (BAGDIFF A (CDR B)))
                               (LESSP (OCCURRENCES X (CDR B))
                                      (OCCURRENCES X A)))
                        (NOT (EQUAL X (CAR B))))
                   (EQUAL (MEMBER X (BAGDIFF A (CDR B)))
                          (LESSP (OCCURRENCES X (CDR B))
                                 (OCCURRENCES X A)))).

    This again simplifies, obviously, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP B)
                        (NOT (MEMBER (CAR B) A))
                        (EQUAL (MEMBER X (BAGDIFF A (CDR B)))
                               (LESSP (OCCURRENCES X (CDR B))
                                      (OCCURRENCES X A)))
                        (EQUAL X (CAR B)))
                   (EQUAL (MEMBER X (BAGDIFF A (CDR B)))
                          (LESSP (ADD1 (OCCURRENCES X (CDR B)))
                                 (OCCURRENCES X A)))).

    But this again simplifies, appealing to the lemma EQUAL-OCCURRENCES-ZERO,
    and unfolding the functions LESSP and EQUAL, to:

          T.

Case 1. (IMPLIES (NOT (LISTP B))
                 (EQUAL (MEMBER X (BAGDIFF A B))
                        (LESSP (OCCURRENCES X B)
                               (OCCURRENCES X A)))),

  which simplifies, rewriting with the lemma EQUAL-OCCURRENCES-ZERO, and
  expanding the functions BAGDIFF, OCCURRENCES, EQUAL, and LESSP, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMBER-BAGDIFF


(PROVE-LEMMA BAGDIFF-DELETE
             (REWRITE)
             (EQUAL (BAGDIFF (DELETE E X) Y)
                    (DELETE E (BAGDIFF X Y)))
             ((ENABLE BAGDIFF DELETE DELETE-DELETE DELETE-NON-MEMBER
                      MEMBER-BAGDIFF MEMBER-DELETE OCCURRENCES-DELETE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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 Y)
                         (MEMBER (CAR Y) (DELETE E X))
                         (p E X (CDR Y))
                         (p E (DELETE (CAR Y) X) (CDR Y)))
                    (p E X Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (MEMBER (CAR Y) (DELETE E X)))
                         (p E X (CDR Y))
                         (p E (DELETE (CAR Y) X) (CDR Y)))
                    (p E X Y))
           (IMPLIES (NOT (LISTP Y)) (p E X Y))).
Linear arithmetic and the lemma CDR-LESSP 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.  Note, however, the inductive instances
chosen for X.  The above induction scheme leads to three new goals:

Case 3. (IMPLIES (AND (LISTP Y)
                      (MEMBER (CAR Y) (DELETE E X))
                      (EQUAL (BAGDIFF (DELETE E X) (CDR Y))
                             (DELETE E (BAGDIFF X (CDR Y))))
                      (EQUAL (BAGDIFF (DELETE E (DELETE (CAR Y) X))
                                      (CDR Y))
                             (DELETE E
                                     (BAGDIFF (DELETE (CAR Y) X)
                                              (CDR Y)))))
                 (EQUAL (BAGDIFF (DELETE E X) Y)
                        (DELETE E (BAGDIFF X Y)))),

  which simplifies, applying the lemmas MEMBER-DELETE and DELETE-DELETE, and
  opening up the definition of BAGDIFF, to:

        T.

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

  which simplifies, rewriting with MEMBER-DELETE, and opening up the function
  BAGDIFF, to the following two new goals:

  Case 2.2.
          (IMPLIES (AND (LISTP Y)
                        (EQUAL (CAR Y) E)
                        (NOT (LESSP 1 (OCCURRENCES E X)))
                        (EQUAL (BAGDIFF (DELETE E X) (CDR Y))
                               (DELETE E (BAGDIFF X (CDR Y))))
                        (EQUAL (BAGDIFF (DELETE E (DELETE (CAR Y) X))
                                        (CDR Y))
                               (DELETE E
                                       (BAGDIFF (DELETE (CAR Y) X) (CDR Y))))
                        (NOT (MEMBER E X)))
                   (EQUAL (BAGDIFF (DELETE E X) (CDR Y))
                          (DELETE E (BAGDIFF X (CDR Y))))).

    This again simplifies, trivially, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP Y)
                        (EQUAL (CAR Y) E)
                        (NOT (LESSP 1 (OCCURRENCES E X)))
                        (EQUAL (BAGDIFF (DELETE E X) (CDR Y))
                               (DELETE E (BAGDIFF X (CDR Y))))
                        (EQUAL (BAGDIFF (DELETE E (DELETE (CAR Y) X))
                                        (CDR Y))
                               (DELETE E
                                       (BAGDIFF (DELETE (CAR Y) X) (CDR Y))))
                        (MEMBER E X))
                   (EQUAL (BAGDIFF (DELETE E X) (CDR Y))
                          (DELETE E
                                  (BAGDIFF (DELETE (CAR Y) X)
                                           (CDR Y))))).

    But this again simplifies, using linear arithmetic, applying MEMBER-DELETE,
    DELETE-NON-MEMBER, MEMBER-BAGDIFF, and OCCURRENCES-DELETE, and opening up
    the function SUB1, to:

          T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (EQUAL (BAGDIFF (DELETE E X) Y)
                        (DELETE E (BAGDIFF X Y)))).

  This simplifies, unfolding the definition of BAGDIFF, to:

        T.


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


[ 0.0 0.1 0.0 ]

BAGDIFF-DELETE


(PROVE-LEMMA SUBBAGP-DELETE
             (REWRITE)
             (IMPLIES (SUBBAGP X (DELETE U Y))
                      (SUBBAGP X Y))
             ((ENABLE DELETE SUBBAGP DELETE-DELETE
                      MEMBER-DELETE-IMPLIES-MEMBERSHIP)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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 DELETE-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 DELETE-DELETE and
  MEMBER-DELETE-IMPLIES-MEMBERSHIP, 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))
             ((ENABLE SUBBAGP SUBBAGP-DELETE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

.

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))
             ((ENABLE DELETE SUBBAGP DELETE-NON-MEMBER SUBBAGP-CDR1)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

.

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.0 0.0 ]

SUBBAGP-CDR2


(PROVE-LEMMA SUBBAGP-BAGINT1
             (REWRITE)
             (SUBBAGP (BAGINT X Y) X)
             ((ENABLE DELETE SUBBAGP BAGINT SUBBAGP-CDR2)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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 SUBBAGP-CDR2 and CDR-NLISTP, and
  unfolding BAGINT, CDR, LISTP, 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)
             ((ENABLE SUBBAGP BAGINT SUBBAGP-CDR2)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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


(PROVE-LEMMA OCCURRENCES-BAGINT
             (REWRITE)
             (EQUAL (OCCURRENCES X (BAGINT A B))
                    (IF (LESSP (OCCURRENCES X A)
                               (OCCURRENCES X B))
                        (OCCURRENCES X A)
                        (OCCURRENCES X B)))
             ((ENABLE OCCURRENCES BAGINT EQUAL-OCCURRENCES-ZERO
                      OCCURRENCES-DELETE)))

This formula simplifies, obviously, to the following two new conjectures:

Case 2. (IMPLIES (NOT (LESSP (OCCURRENCES X A)
                             (OCCURRENCES X B)))
                 (EQUAL (OCCURRENCES X (BAGINT A B))
                        (OCCURRENCES X B))).

  Call the above conjecture *1.

Case 1. (IMPLIES (LESSP (OCCURRENCES X A)
                        (OCCURRENCES X B))
                 (EQUAL (OCCURRENCES X (BAGINT A B))
                        (OCCURRENCES X A))),

  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 (OCCURRENCES X (BAGINT A B))
       (IF (LESSP (OCCURRENCES X A)
                  (OCCURRENCES X B))
           (OCCURRENCES X A)
           (OCCURRENCES X B))).

We gave this the name *1 above.  Perhaps we can prove it by induction.  The
recursive terms in the conjecture suggest five 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)
                         (MEMBER (CAR A) B)
                         (p X (CDR A) (DELETE (CAR A) B)))
                    (p X A B))
           (IMPLIES (AND (LISTP A)
                         (NOT (MEMBER (CAR A) B))
                         (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.  Note, however, the inductive instances chosen for B.  The
above induction scheme leads to the following three new goals:

Case 3. (IMPLIES (AND (LISTP A)
                      (MEMBER (CAR A) B)
                      (EQUAL (OCCURRENCES X
                                          (BAGINT (CDR A) (DELETE (CAR A) B)))
                             (IF (LESSP (OCCURRENCES X (CDR A))
                                        (OCCURRENCES X (DELETE (CAR A) B)))
                                 (OCCURRENCES X (CDR A))
                                 (OCCURRENCES X (DELETE (CAR A) B)))))
                 (EQUAL (OCCURRENCES X (BAGINT A B))
                        (IF (LESSP (OCCURRENCES X A)
                                   (OCCURRENCES X B))
                            (OCCURRENCES X A)
                            (OCCURRENCES X B)))).

  This simplifies, applying OCCURRENCES-DELETE, EQUAL-OCCURRENCES-ZERO,
  CDR-CONS, CAR-CONS, SUB1-ADD1, and ADD1-SUB1, and opening up the definitions
  of BAGINT, OCCURRENCES, and LESSP, to two new goals:

  Case 3.2.
          (IMPLIES
                  (AND (LISTP A)
                       (MEMBER (CAR A) B)
                       (EQUAL X (CAR A))
                       (NOT (MEMBER X B))
                       (NOT (LESSP (OCCURRENCES X (CDR A)) 0))
                       (EQUAL (OCCURRENCES X
                                           (BAGINT (CDR A) (DELETE (CAR A) B)))
                              0))
                  (EQUAL (OCCURRENCES X (BAGINT (CDR A) B))
                         (OCCURRENCES X B))),

    which again simplifies, trivially, to:

          T.

  Case 3.1.
          (IMPLIES
                  (AND (LISTP A)
                       (MEMBER (CAR A) B)
                       (EQUAL X (CAR A))
                       (NOT (MEMBER X B))
                       (LESSP (OCCURRENCES X (CDR A)) 0)
                       (EQUAL (OCCURRENCES X
                                           (BAGINT (CDR A) (DELETE (CAR A) B)))
                              (OCCURRENCES X (CDR A))))
                  (EQUAL (OCCURRENCES X (BAGINT (CDR A) B))
                         (OCCURRENCES X B))).

    This again simplifies, trivially, to:

          T.

Case 2. (IMPLIES (AND (LISTP A)
                      (NOT (MEMBER (CAR A) B))
                      (EQUAL (OCCURRENCES X (BAGINT (CDR A) B))
                             (IF (LESSP (OCCURRENCES X (CDR A))
                                        (OCCURRENCES X B))
                                 (OCCURRENCES X (CDR A))
                                 (OCCURRENCES X B))))
                 (EQUAL (OCCURRENCES X (BAGINT A B))
                        (IF (LESSP (OCCURRENCES X A)
                                   (OCCURRENCES X B))
                            (OCCURRENCES X A)
                            (OCCURRENCES X B)))).

  This simplifies, expanding the functions BAGINT and OCCURRENCES, to the
  following three new conjectures:

  Case 2.3.
          (IMPLIES (AND (LISTP A)
                        (NOT (MEMBER (CAR A) B))
                        (NOT (LESSP (OCCURRENCES X (CDR A))
                                    (OCCURRENCES X B)))
                        (EQUAL (OCCURRENCES X (BAGINT (CDR A) B))
                               (OCCURRENCES X B))
                        (EQUAL X (CAR A))
                        (LESSP (ADD1 (OCCURRENCES X (CDR A)))
                               (OCCURRENCES X B)))
                   (EQUAL (OCCURRENCES X B)
                          (ADD1 (OCCURRENCES X (CDR A))))).

    But this again simplifies, using linear arithmetic, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP A)
                        (NOT (MEMBER (CAR A) B))
                        (LESSP (OCCURRENCES X (CDR A))
                               (OCCURRENCES X B))
                        (EQUAL (OCCURRENCES X (BAGINT (CDR A) B))
                               (OCCURRENCES X (CDR A)))
                        (EQUAL X (CAR A))
                        (NOT (LESSP (ADD1 (OCCURRENCES X (CDR A)))
                                    (OCCURRENCES X B))))
                   (EQUAL (OCCURRENCES X (CDR A))
                          (OCCURRENCES X B))),

    which again simplifies, using linear arithmetic, to:

          (IMPLIES (AND (EQUAL (OCCURRENCES (CAR A) B)
                               (PLUS 1
                                     (OCCURRENCES (CAR A) (CDR A))))
                        (LISTP A)
                        (NOT (MEMBER (CAR A) B))
                        (LESSP (OCCURRENCES (CAR A) (CDR A))
                               (PLUS 1
                                     (OCCURRENCES (CAR A) (CDR A))))
                        (EQUAL (OCCURRENCES (CAR A)
                                            (BAGINT (CDR A) B))
                               (OCCURRENCES (CAR A) (CDR A)))
                        (NOT (LESSP (ADD1 (OCCURRENCES (CAR A) (CDR A)))
                                    (PLUS 1
                                          (OCCURRENCES (CAR A) (CDR A))))))
                   (EQUAL (OCCURRENCES (CAR A) (CDR A))
                          (PLUS 1
                                (OCCURRENCES (CAR A) (CDR A))))).

    But this again simplifies, rewriting with EQUAL-OCCURRENCES-ZERO, and
    unfolding the definition of LESSP, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP A)
                        (NOT (MEMBER (CAR A) B))
                        (LESSP (OCCURRENCES X (CDR A))
                               (OCCURRENCES X B))
                        (EQUAL (OCCURRENCES X (BAGINT (CDR A) B))
                               (OCCURRENCES X (CDR A)))
                        (EQUAL X (CAR A))
                        (LESSP (ADD1 (OCCURRENCES X (CDR A)))
                               (OCCURRENCES X B)))
                   (EQUAL (OCCURRENCES X (CDR A))
                          (ADD1 (OCCURRENCES X (CDR A))))).

    However this again simplifies, rewriting with EQUAL-OCCURRENCES-ZERO, and
    opening up LESSP, to:

          T.

Case 1. (IMPLIES (NOT (LISTP A))
                 (EQUAL (OCCURRENCES X (BAGINT A B))
                        (IF (LESSP (OCCURRENCES X A)
                                   (OCCURRENCES X B))
                            (OCCURRENCES X A)
                            (OCCURRENCES X B)))).

  This simplifies, appealing to the lemma EQUAL-OCCURRENCES-ZERO, and
  expanding BAGINT, LISTP, OCCURRENCES, EQUAL, and LESSP, to:

        (IMPLIES (AND (NOT (LISTP A))
                      (NOT (MEMBER X B)))
                 (EQUAL 0 (OCCURRENCES X B))),

  which again simplifies, rewriting with EQUAL-OCCURRENCES-ZERO, to:

        T.


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


[ 0.0 0.1 0.0 ]

OCCURRENCES-BAGINT


(PROVE-LEMMA OCCURRENCES-BAGDIFF
             (REWRITE)
             (EQUAL (OCCURRENCES X (BAGDIFF A B))
                    (DIFFERENCE (OCCURRENCES X A)
                                (OCCURRENCES X B)))
             ((ENABLE OCCURRENCES BAGDIFF EQUAL-OCCURRENCES-ZERO
                      OCCURRENCES-DELETE)))


     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 B)
                         (MEMBER (CAR B) A)
                         (p X (DELETE (CAR B) A) (CDR B)))
                    (p X A B))
           (IMPLIES (AND (LISTP B)
                         (NOT (MEMBER (CAR B) A))
                         (p X A (CDR B)))
                    (p X A B))
           (IMPLIES (NOT (LISTP B)) (p X A B))).
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.  Note, however, the inductive instances chosen for A.  The
above induction scheme generates three new goals:

Case 3. (IMPLIES (AND (LISTP B)
                      (MEMBER (CAR B) A)
                      (EQUAL (OCCURRENCES X
                                          (BAGDIFF (DELETE (CAR B) A) (CDR B)))
                             (DIFFERENCE (OCCURRENCES X (DELETE (CAR B) A))
                                         (OCCURRENCES X (CDR B)))))
                 (EQUAL (OCCURRENCES X (BAGDIFF A B))
                        (DIFFERENCE (OCCURRENCES X A)
                                    (OCCURRENCES X B)))),

  which simplifies, appealing to the lemmas OCCURRENCES-DELETE, SUB1-ADD1,
  EQUAL-OCCURRENCES-ZERO, and MEMBER-BAGDIFF, and unfolding BAGDIFF,
  OCCURRENCES, DIFFERENCE, and LESSP, to:

        T.

Case 2. (IMPLIES (AND (LISTP B)
                      (NOT (MEMBER (CAR B) A))
                      (EQUAL (OCCURRENCES X (BAGDIFF A (CDR B)))
                             (DIFFERENCE (OCCURRENCES X A)
                                         (OCCURRENCES X (CDR B)))))
                 (EQUAL (OCCURRENCES X (BAGDIFF A B))
                        (DIFFERENCE (OCCURRENCES X A)
                                    (OCCURRENCES X B)))),

  which simplifies, opening up BAGDIFF and OCCURRENCES, to two new goals:

  Case 2.2.
          (IMPLIES (AND (LISTP B)
                        (NOT (MEMBER (CAR B) A))
                        (EQUAL (OCCURRENCES X (BAGDIFF A (CDR B)))
                               (DIFFERENCE (OCCURRENCES X A)
                                           (OCCURRENCES X (CDR B))))
                        (NOT (EQUAL X (CAR B))))
                   (EQUAL (OCCURRENCES X (BAGDIFF A (CDR B)))
                          (DIFFERENCE (OCCURRENCES X A)
                                      (OCCURRENCES X (CDR B))))),

    which again simplifies, trivially, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP B)
                        (NOT (MEMBER (CAR B) A))
                        (EQUAL (OCCURRENCES X (BAGDIFF A (CDR B)))
                               (DIFFERENCE (OCCURRENCES X A)
                                           (OCCURRENCES X (CDR B))))
                        (EQUAL X (CAR B)))
                   (EQUAL (OCCURRENCES X (BAGDIFF A (CDR B)))
                          (DIFFERENCE (OCCURRENCES X A)
                                      (ADD1 (OCCURRENCES X (CDR B)))))).

    But this again simplifies, applying EQUAL-OCCURRENCES-ZERO and
    MEMBER-BAGDIFF, and unfolding DIFFERENCE and LESSP, to:

          T.

Case 1. (IMPLIES (NOT (LISTP B))
                 (EQUAL (OCCURRENCES X (BAGDIFF A B))
                        (DIFFERENCE (OCCURRENCES X A)
                                    (OCCURRENCES X B)))).

  This simplifies, applying EQUAL-OCCURRENCES-ZERO, and opening up the
  functions BAGDIFF, OCCURRENCES, EQUAL, and DIFFERENCE, to:

        (IMPLIES (AND (NOT (LISTP B))
                      (NOT (MEMBER X A)))
                 (EQUAL (OCCURRENCES X A) 0)).

  But this again simplifies, rewriting with the lemma EQUAL-OCCURRENCES-ZERO,
  to:

        T.


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


[ 0.0 0.0 0.0 ]

OCCURRENCES-BAGDIFF


(PROVE-LEMMA MEMBER-BAGINT
             (REWRITE)
             (EQUAL (MEMBER X (BAGINT A B))
                    (AND (MEMBER X A) (MEMBER X B)))
             ((ENABLE BAGINT MEMBER-DELETE)))

This simplifies, opening up the function AND, to two new conjectures:

Case 2. (IMPLIES (NOT (MEMBER X A))
                 (EQUAL (MEMBER X (BAGINT A B)) F)),

  which again simplifies, clearly, to:

        (IMPLIES (NOT (MEMBER X A))
                 (NOT (MEMBER X (BAGINT A B)))),

  which we will name *1.

Case 1. (IMPLIES (MEMBER X A)
                 (EQUAL (MEMBER X (BAGINT A B))
                        (MEMBER X B))),

  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 (MEMBER X (BAGINT A B))
       (AND (MEMBER X A) (MEMBER X B))),

which we named *1 above.  We will appeal to 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)
                         (MEMBER (CAR A) B)
                         (p X (CDR A) (DELETE (CAR A) B)))
                    (p X A B))
           (IMPLIES (AND (LISTP A)
                         (NOT (MEMBER (CAR A) B))
                         (p X (CDR A) B))
                    (p X A B))
           (IMPLIES (NOT (LISTP A)) (p X A B))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT A) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  Note, however, the inductive instances chosen
for B.  The above induction scheme produces three new conjectures:

Case 3. (IMPLIES (AND (LISTP A)
                      (MEMBER (CAR A) B)
                      (EQUAL (MEMBER X
                                     (BAGINT (CDR A) (DELETE (CAR A) B)))
                             (AND (MEMBER X (CDR A))
                                  (MEMBER X (DELETE (CAR A) B)))))
                 (EQUAL (MEMBER X (BAGINT A B))
                        (AND (MEMBER X A) (MEMBER X B)))),

  which simplifies, applying the lemmas MEMBER-DELETE, CDR-CONS, and CAR-CONS,
  and expanding AND, BAGINT, MEMBER, and EQUAL, to two new goals:

  Case 3.2.
          (IMPLIES (AND (LISTP A)
                        (MEMBER (CAR A) B)
                        (NOT (MEMBER X B))
                        (EQUAL (MEMBER X
                                       (BAGINT (CDR A) (DELETE (CAR A) B)))
                               F))
                   (NOT (EQUAL X (CAR A)))),

    which again simplifies, trivially, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP A)
                        (MEMBER (CAR A) B)
                        (NOT (MEMBER X (CDR A)))
                        (EQUAL (MEMBER X
                                       (BAGINT (CDR A) (DELETE (CAR A) B)))
                               F)
                        (EQUAL X (CAR A)))
                   (EQUAL (MEMBER X B) T)).

    This again simplifies, trivially, to:

          T.

Case 2. (IMPLIES (AND (LISTP A)
                      (NOT (MEMBER (CAR A) B))
                      (EQUAL (MEMBER X (BAGINT (CDR A) B))
                             (AND (MEMBER X (CDR A))
                                  (MEMBER X B))))
                 (EQUAL (MEMBER X (BAGINT A B))
                        (AND (MEMBER X A) (MEMBER X B)))).

  This simplifies, unfolding the definitions of AND, BAGINT, and MEMBER, to
  the new conjecture:

        (IMPLIES (AND (LISTP A)
                      (NOT (MEMBER (CAR A) B))
                      (NOT (MEMBER X (CDR A)))
                      (EQUAL (MEMBER X (BAGINT (CDR A) B))
                             F)
                      (EQUAL X (CAR A)))
                 (NOT (MEMBER X B))),

  which again simplifies, clearly, to:

        T.

Case 1. (IMPLIES (NOT (LISTP A))
                 (EQUAL (MEMBER X (BAGINT A B))
                        (AND (MEMBER X A) (MEMBER X B)))).

  This simplifies, rewriting with MEMBER-NON-LIST, and expanding the
  definitions of BAGINT, AND, and EQUAL, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMBER-BAGINT


(DEFTHEORY BAGS
           (OCCURRENCES-BAGINT BAGDIFF-DELETE OCCURRENCES-BAGDIFF
                               MEMBER-BAGINT MEMBER-BAGDIFF SUBBAGP-BAGINT2
                               SUBBAGP-BAGINT1 SUBBAGP-CDR2 SUBBAGP-CDR1
                               SUBBAGP-DELETE))

[ 0.0 0.0 0.0 ]

BAGS


(PROVE-LEMMA EQUAL-PLUS-0
             (REWRITE)
             (EQUAL (EQUAL (PLUS A B) 0)
                    (AND (ZEROP A) (ZEROP B)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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, expanding NUMBERP, PLUS, and EQUAL, to:

        T.

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

  which again simplifies, unfolding PLUS and EQUAL, to:

        T.

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

  which 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, expanding the functions EQUAL and PLUS, 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 ]

EQUAL-PLUS-0


(PROVE-LEMMA PLUS-CANCELLATION
             (REWRITE)
             (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                    (EQUAL (FIX B) (FIX C)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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 we will name *1.

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

  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 (EQUAL (PLUS A B) (PLUS A C))
       (EQUAL (FIX B) (FIX C))).

We gave this the name *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 (ZEROP A) (p A B C))
           (IMPLIES (AND (NOT (ZEROP A)) (p (SUB1 A) B C))
                    (p A B C))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definition
of ZEROP 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 formulas:

Case 2. (IMPLIES (ZEROP A)
                 (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                        (EQUAL (FIX B) (FIX C)))).

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

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP A))
                      (EQUAL (EQUAL (PLUS (SUB1 A) B)
                                    (PLUS (SUB1 A) C))
                             (EQUAL (FIX B) (FIX C))))
                 (EQUAL (EQUAL (PLUS A B) (PLUS A C))
                        (EQUAL (FIX B) (FIX C)))).

  This simplifies, rewriting with ADD1-EQUAL, and unfolding the definitions of
  ZEROP, FIX, PLUS, and EQUAL, to two new goals:

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

    which again simplifies, trivially, to:

          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (NUMBERP C))
                        (EQUAL (PLUS (SUB1 A) 0)
                               (PLUS (SUB1 A) C)))
                   (EQUAL (PLUS A 0)
                          (ADD1 (PLUS (SUB1 A) 0)))),

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, trivially, to the new formula:

          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (NUMBERP B))
                        (EQUAL (PLUS (SUB1 A) B)
                               (PLUS (SUB1 A) 0)))
                   (EQUAL (ADD1 (PLUS (SUB1 A) 0))
                          (PLUS A 0))),

    which again simplifies, using linear arithmetic, to:

          T.


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


[ 0.0 0.0 0.0 ]

PLUS-CANCELLATION


(TOGGLE PLUS-CANCELLATION-OFF PLUS-CANCELLATION T)

[ 0.0 0.0 0.0 ]

PLUS-CANCELLATION-OFF


(PROVE-LEMMA EQUAL-DIFFERENCE-0
             (REWRITE)
             (AND (EQUAL (EQUAL (DIFFERENCE X Y) 0)
                         (NOT (LESSP Y X)))
                  (EQUAL (EQUAL 0 (DIFFERENCE X Y))
                         (NOT (LESSP Y X))))
             ((INDUCT (DIFFERENCE X Y))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


This conjecture can be simplified, using the abbreviations ZEROP, NOT, OR, and
AND, to three new conjectures:

Case 3. (IMPLIES (ZEROP X)
                 (AND (EQUAL (EQUAL (DIFFERENCE X Y) 0)
                             (NOT (LESSP Y X)))
                      (EQUAL (EQUAL 0 (DIFFERENCE X Y))
                             (NOT (LESSP Y X))))),

  which simplifies, expanding the definitions of ZEROP, EQUAL, DIFFERENCE,
  LESSP, NOT, and AND, to:

        T.

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

  which simplifies, unfolding the definitions of ZEROP, EQUAL, DIFFERENCE,
  LESSP, NOT, and AND, to:

        T.

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

  which simplifies, expanding the functions NOT, EQUAL, DIFFERENCE, LESSP, and
  AND, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EQUAL-DIFFERENCE-0


(PROVE-LEMMA DIFFERENCE-CANCELLATION
             (REWRITE)
             (EQUAL (EQUAL (DIFFERENCE X Y)
                           (DIFFERENCE Z Y))
                    (COND ((LESSP X Y) (NOT (LESSP Y Z)))
                          ((LESSP Z Y) (NOT (LESSP Y X)))
                          (T (EQUAL (FIX X) (FIX Z)))))
             ((ENABLE EQUAL-DIFFERENCE-0)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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, applying EQUAL-DIFFERENCE-0, and expanding DIFFERENCE
  and 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, rewriting with EQUAL-DIFFERENCE-0, and opening up
  the functions DIFFERENCE, 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, opening up the functions EQUAL and DIFFERENCE, 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, expanding the functions DIFFERENCE and 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))),

  which again simplifies, trivially, to:

        T.

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

  Call the above conjecture *1.

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

  This again simplifies, unfolding DIFFERENCE and 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)),

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

  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, expanding 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, appealing to the lemma EQUAL-DIFFERENCE-0, and
    unfolding the functions DIFFERENCE, LESSP, and 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)),

    which again simplifies, trivially, to the new conjecture:

          (IMPLIES (AND (NUMBERP X)
                        (NUMBERP Y)
                        (NOT (EQUAL (DIFFERENCE X X)
                                    (DIFFERENCE Z X)))
                        (LESSP Z X))
                   (LESSP X 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:

(EQUAL (EQUAL (DIFFERENCE X Y)
              (DIFFERENCE Z Y))
       (COND ((LESSP X Y) (NOT (LESSP Y Z)))
             ((LESSP Z Y) (NOT (LESSP Y X)))
             (T (EQUAL (FIX X) (FIX Z))))),

named *1.  Let us appeal to the induction principle.  The recursive terms in
the conjecture suggest 12 inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP X) (p X Y Z))
           (IMPLIES (AND (NOT (ZEROP X)) (ZEROP Y))
                    (p X Y Z))
           (IMPLIES (AND (NOT (ZEROP X))
                         (NOT (ZEROP Y))
                         (p (SUB1 X) (SUB1 Y) (SUB1 Z)))
                    (p X Y Z))).
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.  Note,
however, the inductive instances chosen for Z and Y.  The above induction
scheme generates the following three new goals:

Case 3. (IMPLIES (ZEROP X)
                 (EQUAL (EQUAL (DIFFERENCE X Y)
                               (DIFFERENCE Z Y))
                        (COND ((LESSP X Y) (NOT (LESSP Y Z)))
                              ((LESSP Z Y) (NOT (LESSP Y X)))
                              (T (EQUAL (FIX X) (FIX Z)))))).

  This simplifies, opening up the functions ZEROP, EQUAL, DIFFERENCE, LESSP,
  NOT, and FIX, to the following 12 new goals:

  Case 3.12.
          (IMPLIES (AND (EQUAL X 0)
                        (NUMBERP Z)
                        (EQUAL Y 0)
                        (EQUAL 0 Z))
                   (EQUAL (EQUAL 0 Z) T)).

    However this again simplifies, opening up the definitions of NUMBERP and
    EQUAL, to:

          T.

  Case 3.11.
          (IMPLIES (AND (EQUAL X 0)
                        (NUMBERP Z)
                        (NOT (NUMBERP Y))
                        (EQUAL 0 Z))
                   (EQUAL (EQUAL 0 Z) T)),

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

          T.

  Case 3.10.
          (IMPLIES (AND (EQUAL X 0)
                        (EQUAL Z 0)
                        (NOT (NUMBERP Y))
                        (NUMBERP Z))
                   (EQUAL (EQUAL 0 Z) T)),

    which again simplifies, unfolding the functions NUMBERP and EQUAL, to:

          T.

  Case 3.9.
          (IMPLIES (AND (EQUAL X 0)
                        (EQUAL Z 0)
                        (EQUAL Y 0)
                        (NUMBERP Z))
                   (EQUAL (EQUAL 0 Z) T)),

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

          T.

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

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

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

  Case 3.6.
          (IMPLIES (AND (NOT (NUMBERP X))
                        (NUMBERP Z)
                        (EQUAL Y 0)
                        (EQUAL 0 Z))
                   (EQUAL (EQUAL 0 Z) T)),

    which again simplifies, opening up the definitions of NUMBERP and EQUAL,
    to:

          T.

  Case 3.5.
          (IMPLIES (AND (NOT (NUMBERP X))
                        (NUMBERP Z)
                        (NOT (NUMBERP Y))
                        (EQUAL 0 Z))
                   (EQUAL (EQUAL 0 Z) T)),

    which again simplifies, expanding NUMBERP and EQUAL, to:

          T.

  Case 3.4.
          (IMPLIES (AND (NOT (NUMBERP X))
                        (EQUAL Z 0)
                        (NOT (NUMBERP Y))
                        (NUMBERP Z))
                   (EQUAL (EQUAL 0 Z) T)),

    which again simplifies, unfolding NUMBERP and EQUAL, to:

          T.

  Case 3.3.
          (IMPLIES (AND (NOT (NUMBERP X))
                        (EQUAL Z 0)
                        (EQUAL Y 0)
                        (NUMBERP Z))
                   (EQUAL (EQUAL 0 Z) T)),

    which again simplifies, opening up NUMBERP and EQUAL, to:

          T.

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

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

          T.

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

    However this again simplifies, using linear arithmetic, to:

          T.

Case 2. (IMPLIES (AND (NOT (ZEROP X)) (ZEROP Y))
                 (EQUAL (EQUAL (DIFFERENCE X Y)
                               (DIFFERENCE Z Y))
                        (COND ((LESSP X Y) (NOT (LESSP Y Z)))
                              ((LESSP Z Y) (NOT (LESSP Y X)))
                              (T (EQUAL (FIX X) (FIX Z)))))),

  which simplifies, expanding ZEROP, EQUAL, DIFFERENCE, LESSP, and FIX, to
  four new goals:

  Case 2.4.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (EQUAL Y 0)
                        (NUMBERP Z)
                        (EQUAL X Z))
                   (EQUAL (EQUAL X Z) T)),

    which again simplifies, expanding the function EQUAL, to:

          T.

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

    which again simplifies, trivially, to:

          T.

  Case 2.2.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (NUMBERP Y))
                        (NUMBERP Z)
                        (EQUAL X Z))
                   (EQUAL (EQUAL X Z) T)).

    This again simplifies, expanding EQUAL, to:

          T.

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

    which again simplifies, trivially, to:

          T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (NOT (ZEROP Y))
                      (EQUAL (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                                    (DIFFERENCE (SUB1 Z) (SUB1 Y)))
                             (COND ((LESSP (SUB1 X) (SUB1 Y))
                                    (NOT (LESSP (SUB1 Y) (SUB1 Z))))
                                   ((LESSP (SUB1 Z) (SUB1 Y))
                                    (NOT (LESSP (SUB1 Y) (SUB1 X))))
                                   (T (EQUAL (FIX (SUB1 X))
                                             (FIX (SUB1 Z)))))))
                 (EQUAL (EQUAL (DIFFERENCE X Y)
                               (DIFFERENCE Z Y))
                        (COND ((LESSP X Y) (NOT (LESSP Y Z)))
                              ((LESSP Z Y) (NOT (LESSP Y X)))
                              (T (EQUAL (FIX X) (FIX Z)))))).

  This simplifies, unfolding the definitions of ZEROP, NOT, FIX, DIFFERENCE,
  and LESSP, to the following 18 new goals:

  Case 1.18.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (EQUAL Y 0))
                        (NUMBERP Y)
                        (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                               (DIFFERENCE (SUB1 Z) (SUB1 Y)))
                        (NOT (LESSP (SUB1 X) (SUB1 Y)))
                        (LESSP (SUB1 Z) (SUB1 Y))
                        (NOT (LESSP (SUB1 Y) (SUB1 X)))
                        (NOT (NUMBERP Z)))
                   (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                          0)).

    This again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, applying EQUAL-DIFFERENCE-0, to:

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, applying EQUAL-DIFFERENCE-0, and unfolding the
    functions SUB1, EQUAL, DIFFERENCE, and LESSP, to:

          T.

  Case 1.14.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (EQUAL Y 0))
                        (NUMBERP Y)
                        (NOT (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                                    (DIFFERENCE (SUB1 Z) (SUB1 Y))))
                        (NOT (LESSP (SUB1 X) (SUB1 Y)))
                        (LESSP (SUB1 Z) (SUB1 Y))
                        (LESSP (SUB1 Y) (SUB1 X))
                        (NOT (NUMBERP Z)))
                   (NOT (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                               0))).

    But this again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, rewriting with EQUAL-DIFFERENCE-0, and expanding
    the definitions of SUB1, EQUAL, DIFFERENCE, and LESSP, to:

          T.

  Case 1.11.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (EQUAL Y 0))
                        (NUMBERP Y)
                        (NOT (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                                    (DIFFERENCE (SUB1 Z) (SUB1 Y))))
                        (LESSP (SUB1 X) (SUB1 Y))
                        (LESSP (SUB1 Y) (SUB1 Z))
                        (NOT (NUMBERP Z)))
                   (EQUAL (DIFFERENCE (SUB1 X) (SUB1 Y))
                          0)).

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

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, clearly, to:

          T.

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

    This again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, obviously, to:

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

    which again simplifies, using linear arithmetic, to:

          T.


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


[ 0.0 0.0 0.1 ]

DIFFERENCE-CANCELLATION


(TOGGLE DIFFERENCE-CANCELLATION-OFF DIFFERENCE-CANCELLATION T)

[ 0.0 0.0 0.0 ]

DIFFERENCE-CANCELLATION-OFF


(PROVE-LEMMA COMMUTATIVITY-OF-PLUS
             (REWRITE)
             (EQUAL (PLUS X Y) (PLUS Y X))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This formula simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUTATIVITY-OF-PLUS


(PROVE-LEMMA COMMUTATIVITY2-OF-PLUS
             (REWRITE)
             (EQUAL (PLUS X Y Z) (PLUS Y X Z))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


This simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUTATIVITY2-OF-PLUS


(PROVE-LEMMA PLUS-ZERO-ARG2
             (REWRITE)
             (IMPLIES (ZEROP Y)
                      (EQUAL (PLUS X Y) (FIX X)))
             ((INDUCT (PLUS X Y))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


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

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

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

        T.

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

  This simplifies, applying the lemma ADD1-SUB1, and expanding ZEROP, FIX,
  IMPLIES, and PLUS, to:

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

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PLUS-ZERO-ARG2


(PROVE-LEMMA PLUS-ADD1-ARG1
             (REWRITE)
             (EQUAL (PLUS (ADD1 A) B)
                    (ADD1 (PLUS A B)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


This conjecture simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PLUS-ADD1-ARG1


(PROVE-LEMMA PLUS-ADD1-ARG2
             (REWRITE)
             (EQUAL (PLUS X (ADD1 Y))
                    (IF (NUMBERP Y)
                        (ADD1 (PLUS X Y))
                        (ADD1 X)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


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

(PROVE-LEMMA ASSOCIATIVITY-OF-PLUS
             (REWRITE)
             (EQUAL (PLUS (PLUS X Y) Z)
                    (PLUS X Y Z))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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-DIFFERENCE-ARG1
             (REWRITE)
             (EQUAL (PLUS (DIFFERENCE A B) C)
                    (IF (LESSP B A)
                        (DIFFERENCE (PLUS A C) B)
                        (PLUS 0 C)))
             ((INDUCT (DIFFERENCE A B))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


This conjecture can be simplified, using the abbreviations ZEROP, NOT, OR, and
AND, to three new formulas:

Case 3. (IMPLIES (ZEROP A)
                 (EQUAL (PLUS (DIFFERENCE A B) C)
                        (IF (LESSP B A)
                            (DIFFERENCE (PLUS A C) B)
                            (PLUS 0 C)))),

  which simplifies, unfolding the functions ZEROP, EQUAL, DIFFERENCE, PLUS,
  and LESSP, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL A 0))
                      (NUMBERP A)
                      (ZEROP B))
                 (EQUAL (PLUS (DIFFERENCE A B) C)
                        (IF (LESSP B A)
                            (DIFFERENCE (PLUS A C) B)
                            (PLUS 0 C)))),

  which simplifies, unfolding the definitions of ZEROP, EQUAL, DIFFERENCE, and
  LESSP, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL A 0))
                      (NUMBERP A)
                      (NOT (EQUAL B 0))
                      (NUMBERP B)
                      (EQUAL (PLUS (DIFFERENCE (SUB1 A) (SUB1 B))
                                   C)
                             (IF (LESSP (SUB1 B) (SUB1 A))
                                 (DIFFERENCE (PLUS (SUB1 A) C)
                                             (SUB1 B))
                                 (PLUS 0 C))))
                 (EQUAL (PLUS (DIFFERENCE A B) C)
                        (IF (LESSP B A)
                            (DIFFERENCE (PLUS A C) B)
                            (PLUS 0 C)))),

  which simplifies, rewriting with SUB1-ADD1, and unfolding the functions
  EQUAL, PLUS, DIFFERENCE, and LESSP, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PLUS-DIFFERENCE-ARG1


(PROVE-LEMMA PLUS-DIFFERENCE-ARG2
             (REWRITE)
             (EQUAL (PLUS A (DIFFERENCE B C))
                    (IF (LESSP C B)
                        (DIFFERENCE (PLUS A B) C)
                        (PLUS A 0)))
             ((INDUCT (PLUS A B))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


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

Case 2. (IMPLIES (ZEROP A)
                 (EQUAL (PLUS A (DIFFERENCE B C))
                        (IF (LESSP C B)
                            (DIFFERENCE (PLUS A B) C)
                            (PLUS A 0)))).

  This simplifies, expanding ZEROP, EQUAL, PLUS, and NUMBERP, to the following
  four new formulas:

  Case 2.4.
          (IMPLIES (AND (EQUAL A 0) (NOT (LESSP C B)))
                   (EQUAL (DIFFERENCE B C) 0)).

    This again simplifies, trivially, to the new formula:

          (IMPLIES (NOT (LESSP C B))
                   (EQUAL (DIFFERENCE B C) 0)),

    which we will name *1.

  Case 2.3.
          (IMPLIES (AND (EQUAL A 0)
                        (LESSP C B)
                        (NOT (NUMBERP B)))
                   (EQUAL (DIFFERENCE B C)
                          (DIFFERENCE 0 C))).

    However this again simplifies, opening up LESSP, to:

          T.

  Case 2.2.
          (IMPLIES (AND (NOT (NUMBERP A))
                        (NOT (LESSP C B)))
                   (EQUAL (DIFFERENCE B C) 0)),

    which we will name *2.

  Case 2.1.
          (IMPLIES (AND (NOT (NUMBERP A))
                        (LESSP C B)
                        (NOT (NUMBERP B)))
                   (EQUAL (DIFFERENCE B C)
                          (DIFFERENCE 0 C))).

    This again simplifies, expanding the definition of LESSP, to:

          T.

Case 1. (IMPLIES (AND (NOT (EQUAL A 0))
                      (NUMBERP A)
                      (EQUAL (PLUS (SUB1 A) (DIFFERENCE B C))
                             (IF (LESSP C B)
                                 (DIFFERENCE (PLUS (SUB1 A) B) C)
                                 (PLUS (SUB1 A) 0))))
                 (EQUAL (PLUS A (DIFFERENCE B C))
                        (IF (LESSP C B)
                            (DIFFERENCE (PLUS A B) C)
                            (PLUS A 0)))),

  which simplifies, rewriting with SUB1-ADD1, and unfolding the definitions of
  PLUS and DIFFERENCE, to the following three new goals:

  Case 1.3.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (LESSP C B)
                        (EQUAL (PLUS (SUB1 A) (DIFFERENCE B C))
                               (DIFFERENCE (PLUS (SUB1 A) B) C))
                        (NOT (EQUAL C 0))
                        (NUMBERP C))
                   (EQUAL (ADD1 (DIFFERENCE (PLUS (SUB1 A) B) C))
                          (DIFFERENCE (PLUS (SUB1 A) B)
                                      (SUB1 C)))).

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

    Case 1.3.2.
            (IMPLIES (AND (LESSP (PLUS (SUB1 A) B) C)
                          (NOT (EQUAL A 0))
                          (NUMBERP A)
                          (LESSP C B)
                          (EQUAL (PLUS (SUB1 A) (DIFFERENCE B C))
                                 (DIFFERENCE (PLUS (SUB1 A) B) C))
                          (NOT (EQUAL C 0))
                          (NUMBERP C))
                     (EQUAL (ADD1 (DIFFERENCE (PLUS (SUB1 A) B) C))
                            (DIFFERENCE (PLUS (SUB1 A) B)
                                        (SUB1 C)))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 1.3.1.
            (IMPLIES (AND (LESSP (PLUS (SUB1 A) B) (SUB1 C))
                          (NOT (EQUAL A 0))
                          (NUMBERP A)
                          (LESSP C B)
                          (EQUAL (PLUS (SUB1 A) (DIFFERENCE B C))
                                 (DIFFERENCE (PLUS (SUB1 A) B) C))
                          (NOT (EQUAL C 0))
                          (NUMBERP C))
                     (EQUAL (ADD1 (DIFFERENCE (PLUS (SUB1 A) B) C))
                            (DIFFERENCE (PLUS (SUB1 A) B)
                                        (SUB1 C)))),

      which again simplifies, using linear arithmetic, to:

            T.

  Case 1.2.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (LESSP C B)
                        (EQUAL (PLUS (SUB1 A) (DIFFERENCE B C))
                               (DIFFERENCE (PLUS (SUB1 A) B) C))
                        (EQUAL C 0))
                   (EQUAL (ADD1 (DIFFERENCE (PLUS (SUB1 A) B) C))
                          (ADD1 (PLUS (SUB1 A) B)))),

    which again simplifies, using linear arithmetic, to:

          (IMPLIES (AND (LESSP (PLUS (SUB1 A) B) 0)
                        (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (LESSP 0 B)
                        (EQUAL (PLUS (SUB1 A) (DIFFERENCE B 0))
                               (DIFFERENCE (PLUS (SUB1 A) B) 0)))
                   (EQUAL (ADD1 (DIFFERENCE (PLUS (SUB1 A) B) 0))
                          (ADD1 (PLUS (SUB1 A) B)))).

    This again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (LESSP C B)
                        (EQUAL (PLUS (SUB1 A) (DIFFERENCE B C))
                               (DIFFERENCE (PLUS (SUB1 A) B) C))
                        (NOT (NUMBERP C)))
                   (EQUAL (ADD1 (DIFFERENCE (PLUS (SUB1 A) B) C))
                          (ADD1 (PLUS (SUB1 A) B)))),

    which again simplifies, applying ADD1-EQUAL, and unfolding the functions
    LESSP and DIFFERENCE, to:

          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (NOT (NUMBERP C))
                        (EQUAL (PLUS (SUB1 A) B) 0))
                   (EQUAL 0 (PLUS (SUB1 A) B))),

    which again simplifies, clearly, to:

          T.


     So we now return to:

      (IMPLIES (AND (NOT (NUMBERP A))
                    (NOT (LESSP C B)))
               (EQUAL (DIFFERENCE B C) 0)),

named *2 above.  What luck!  This conjecture is subsumed by formula *1 above.


     So next consider:

      (IMPLIES (NOT (LESSP C B))
               (EQUAL (DIFFERENCE B C) 0)),

which is formula *1 above.  Perhaps we can prove it by induction.  Four
inductions are suggested by terms in the conjecture.  However, they merge into
one likely candidate induction.  We will induct according to the following
scheme:
      (AND (IMPLIES (OR (EQUAL B 0) (NOT (NUMBERP B)))
                    (p B C))
           (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                         (OR (EQUAL C 0) (NOT (NUMBERP C))))
                    (p B C))
           (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                         (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                         (p (SUB1 B) (SUB1 C)))
                    (p B C))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT inform us that the measure (COUNT C) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  Note,
however, the inductive instance chosen for B.  The above induction scheme
leads to the following four new conjectures:

Case 4. (IMPLIES (AND (OR (EQUAL B 0) (NOT (NUMBERP B)))
                      (NOT (LESSP C B)))
                 (EQUAL (DIFFERENCE B C) 0)).

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

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (OR (EQUAL C 0) (NOT (NUMBERP C)))
                      (NOT (LESSP C B)))
                 (EQUAL (DIFFERENCE B C) 0)).

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

        T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (LESSP (SUB1 C) (SUB1 B))
                      (NOT (LESSP C B)))
                 (EQUAL (DIFFERENCE B C) 0)).

  This simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP B 1)
                      (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (LESSP (SUB1 C) (SUB1 B))
                      (NOT (LESSP C B)))
                 (EQUAL (DIFFERENCE B C) 0)),

  which again simplifies, expanding the functions SUB1, NUMBERP, EQUAL, LESSP,
  NOT, and OR, to:

        T.

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

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

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

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

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

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

            T.

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

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

            T.

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

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

          T.

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

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

          T.


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


[ 0.0 0.0 0.0 ]

PLUS-DIFFERENCE-ARG2


(PROVE-LEMMA DIFFERENCE-PLUS-CANCELLATION-PROOF NIL
             (EQUAL (DIFFERENCE (PLUS X Y) X)
                    (FIX Y))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This conjecture simplifies, opening up the function FIX, to the following two
new goals:

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

  Give the above formula the name *1.

Case 1. (IMPLIES (NUMBERP Y)
                 (EQUAL (DIFFERENCE (PLUS X Y) X) Y)).

  This again simplifies, using linear arithmetic, to:

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

  However this again simplifies, using linear arithmetic, to:

        T.


     So we now return to:

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

which we named *1 above.  Let us appeal to the induction principle.  There are
two plausible inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP (PLUS X Y)) (p X Y))
           (IMPLIES (AND (NOT (ZEROP (PLUS X Y)))
                         (ZEROP X))
                    (p X Y))
           (IMPLIES (AND (NOT (ZEROP (PLUS X Y)))
                         (NOT (ZEROP X))
                         (p (SUB1 X) Y))
                    (p X Y))).
Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP can be
used to show that the measure (COUNT X) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates the following three new goals:

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

  This simplifies, unfolding the definitions of PLUS, ZEROP, EQUAL, and
  DIFFERENCE, to:

        T.

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

  This simplifies, opening up PLUS and ZEROP, to:

        T.

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

  This simplifies, using linear arithmetic, to the following two new
  conjectures:

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

    However this again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, expanding SUB1, NUMBERP, EQUAL, LESSP, PLUS, and
    ZEROP, to:

          T.


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


[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-CANCELLATION-PROOF


(PROVE-LEMMA DIFFERENCE-PLUS-CANCELLATION
             (REWRITE)
             (AND (EQUAL (DIFFERENCE (PLUS X Y) X)
                         (FIX Y))
                  (EQUAL (DIFFERENCE (PLUS Y X) X)
                         (FIX Y)))
             ((USE (DIFFERENCE-PLUS-CANCELLATION-PROOF (X X)
                                                       (Y Y)))
              (ENABLE COMMUTATIVITY-OF-PLUS)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


This formula simplifies, rewriting with COMMUTATIVITY-OF-PLUS, and expanding
the definitions of FIX, EQUAL, and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-CANCELLATION


(TOGGLE DIFFERENCE-PLUS-CANCELLATION-OFF DIFFERENCE-PLUS-CANCELLATION T)

[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-CANCELLATION-OFF


(PROVE-LEMMA DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF NIL
             (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                    (DIFFERENCE Y Z))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This simplifies, using linear arithmetic, to the following two new conjectures:

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

  Give the above formula the name *1.

Case 1. (IMPLIES (LESSP Y Z)
                 (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                        (DIFFERENCE Y 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:

(EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
       (DIFFERENCE Y Z)).

We gave this the name *1 above.  Perhaps we can 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 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 produces the following two new conjectures:

Case 2. (IMPLIES (ZEROP X)
                 (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                        (DIFFERENCE Y Z))).

  This simplifies, using linear arithmetic, to the following two new goals:

  Case 2.2.
          (IMPLIES (AND (LESSP (PLUS X Y) (PLUS X Z))
                        (ZEROP X))
                   (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                          (DIFFERENCE Y Z))).

    But this again simplifies, unfolding the functions PLUS, ZEROP, EQUAL, and
    DIFFERENCE, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LESSP Y Z) (ZEROP X))
                   (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                          (DIFFERENCE Y Z))),

    which again simplifies, opening up ZEROP, EQUAL, and PLUS, to six new
    goals:

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

      which again simplifies, opening up LESSP, to:

            T.

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

      which again simplifies, opening up LESSP, to:

            T.

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

      which again simplifies, expanding LESSP, EQUAL, and DIFFERENCE, to:

            T.

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

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

            T.

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

      which again simplifies, expanding LESSP, to:

            T.

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

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

            T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (EQUAL (DIFFERENCE (PLUS (SUB1 X) Y)
                                         (PLUS (SUB1 X) Z))
                             (DIFFERENCE Y Z)))
                 (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                        (DIFFERENCE Y Z))),

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

  Case 1.2.
          (IMPLIES (AND (LESSP (PLUS X Y) (PLUS X Z))
                        (NOT (ZEROP X))
                        (EQUAL (DIFFERENCE (PLUS (SUB1 X) Y)
                                           (PLUS (SUB1 X) Z))
                               (DIFFERENCE Y Z)))
                   (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                          (DIFFERENCE Y Z))),

    which again simplifies, applying SUB1-ADD1, and unfolding PLUS, ZEROP, and
    DIFFERENCE, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LESSP Y Z)
                        (NOT (ZEROP X))
                        (EQUAL (DIFFERENCE (PLUS (SUB1 X) Y)
                                           (PLUS (SUB1 X) Z))
                               (DIFFERENCE Y Z)))
                   (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                          (DIFFERENCE Y Z))).

    But this again simplifies, applying the lemma SUB1-ADD1, and expanding the
    definitions of ZEROP, PLUS, and DIFFERENCE, to:

          T.


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


[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF


(PROVE-LEMMA DIFFERENCE-PLUS-PLUS-CANCELLATION
             (REWRITE)
             (AND (EQUAL (DIFFERENCE (PLUS X Y) (PLUS X Z))
                         (DIFFERENCE Y Z))
                  (EQUAL (DIFFERENCE (PLUS Y X) (PLUS X Z))
                         (DIFFERENCE Y Z))
                  (EQUAL (DIFFERENCE (PLUS X Y) (PLUS Z X))
                         (DIFFERENCE Y Z))
                  (EQUAL (DIFFERENCE (PLUS Y X) (PLUS Z X))
                         (DIFFERENCE Y Z)))
             ((USE (DIFFERENCE-PLUS-PLUS-CANCELLATION-PROOF (X X)
                                                            (Y Y)
                                                            (Z Z)))
              (ENABLE COMMUTATIVITY-OF-PLUS)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


This simplifies, applying COMMUTATIVITY-OF-PLUS, and unfolding the function
AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-PLUS-CANCELLATION


(TOGGLE DIFFERENCE-PLUS-PLUS-CANCELLATION-OFF DIFFERENCE-PLUS-PLUS-CANCELLATION
        T)

[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-PLUS-CANCELLATION-OFF


(PROVE-LEMMA DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK
             (REWRITE)
             (EQUAL (DIFFERENCE (PLUS W X A) (PLUS Y Z A))
                    (DIFFERENCE (PLUS W X) (PLUS Y Z)))
             ((ENABLE COMMUTATIVITY-OF-PLUS COMMUTATIVITY2-OF-PLUS
                      DIFFERENCE-PLUS-PLUS-CANCELLATION)
              (DO-NOT-INDUCT T)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This conjecture simplifies, using linear arithmetic, to the following two new
goals:

Case 2. (IMPLIES (LESSP (PLUS W X A) (PLUS Y Z A))
                 (EQUAL (DIFFERENCE (PLUS W X A) (PLUS Y Z A))
                        (DIFFERENCE (PLUS W X) (PLUS Y Z)))).

  However this again simplifies, rewriting with COMMUTATIVITY-OF-PLUS,
  COMMUTATIVITY2-OF-PLUS, and DIFFERENCE-PLUS-PLUS-CANCELLATION, to:

        T.

Case 1. (IMPLIES (LESSP (PLUS W X) (PLUS Y Z))
                 (EQUAL (DIFFERENCE (PLUS W X A) (PLUS Y Z A))
                        (DIFFERENCE (PLUS W X) (PLUS Y Z)))).

  This again simplifies, applying COMMUTATIVITY-OF-PLUS,
  COMMUTATIVITY2-OF-PLUS, and DIFFERENCE-PLUS-PLUS-CANCELLATION, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK


(TOGGLE DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK-OFF
        DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK T)

[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-PLUS-CANCELLATION-HACK-OFF


(PROVE-LEMMA DIFF-SUB1-ARG2
             (REWRITE)
             (EQUAL (DIFFERENCE A (SUB1 B))
                    (COND ((ZEROP B) (FIX A))
                          ((LESSP A B) 0)
                          (T (ADD1 (DIFFERENCE A B)))))
             ((INDUCT (DIFFERENCE A B))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This conjecture can be simplified, using the abbreviations ZEROP, NOT, OR, and
AND, to three new conjectures:

Case 3. (IMPLIES (ZEROP A)
                 (EQUAL (DIFFERENCE A (SUB1 B))
                        (COND ((ZEROP B) (FIX A))
                              ((LESSP A B) 0)
                              (T (ADD1 (DIFFERENCE A B)))))),

  which simplifies, opening up the definitions of ZEROP, EQUAL, DIFFERENCE,
  FIX, LESSP, and ADD1, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL A 0))
                      (NUMBERP A)
                      (ZEROP B))
                 (EQUAL (DIFFERENCE A (SUB1 B))
                        (COND ((ZEROP B) (FIX A))
                              ((LESSP A B) 0)
                              (T (ADD1 (DIFFERENCE A B)))))),

  which simplifies, applying SUB1-NNUMBERP, and unfolding ZEROP, SUB1, EQUAL,
  DIFFERENCE, and FIX, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL A 0))
                      (NUMBERP A)
                      (NOT (EQUAL B 0))
                      (NUMBERP B)
                      (EQUAL (DIFFERENCE (SUB1 A) (SUB1 (SUB1 B)))
                             (COND ((ZEROP (SUB1 B)) (FIX (SUB1 A)))
                                   ((LESSP (SUB1 A) (SUB1 B)) 0)
                                   (T (ADD1 (DIFFERENCE (SUB1 A) (SUB1 B)))))))
                 (EQUAL (DIFFERENCE A (SUB1 B))
                        (COND ((ZEROP B) (FIX A))
                              ((LESSP A B) 0)
                              (T (ADD1 (DIFFERENCE A B)))))).

  This simplifies, opening up ZEROP, FIX, DIFFERENCE, LESSP, and EQUAL, to the
  following two new conjectures:

  Case 1.2.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (EQUAL (SUB1 B) 0)
                        (EQUAL (DIFFERENCE (SUB1 A) (SUB1 (SUB1 B)))
                               (SUB1 A))
                        (NOT (EQUAL (SUB1 A) 0)))
                   (EQUAL A (ADD1 (SUB1 A)))).

    However this again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (EQUAL (SUB1 B) 0)
                        (EQUAL (DIFFERENCE (SUB1 A) (SUB1 (SUB1 B)))
                               (SUB1 A))
                        (EQUAL (SUB1 A) 0))
                   (EQUAL A 1)),

    which again simplifies, using linear arithmetic, to:

          T.

Q.E.D.


[ 0.0 0.0 0.1 ]

DIFF-SUB1-ARG2


(TOGGLE DIFF-SUB1-ARG2-OFF DIFF-SUB1-ARG2 T)

[ 0.0 0.0 0.0 ]

DIFF-SUB1-ARG2-OFF


(PROVE-LEMMA DIFF-DIFF-ARG1
             (REWRITE)
             (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                    (DIFFERENCE X (PLUS Y Z)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This simplifies, using linear arithmetic, to the following three new
conjectures:

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

  Give the above formula the name *1.

Case 2. (IMPLIES (LESSP X Y)
                 (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                        (DIFFERENCE X (PLUS Y 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:

(EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
       (DIFFERENCE X (PLUS Y Z))).

We gave this the name *1 above.  Perhaps we can prove it by induction.  There
are five 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)) (ZEROP Y))
                    (p X Y Z))
           (IMPLIES (AND (NOT (ZEROP X))
                         (NOT (ZEROP Y))
                         (p (SUB1 X) (SUB1 Y) Z))
                    (p X Y Z))).
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.  Note, however, the
inductive instance chosen for Y.  The above induction scheme produces the
following three new conjectures:

Case 3. (IMPLIES (ZEROP X)
                 (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                        (DIFFERENCE X (PLUS Y Z)))).

  This simplifies, using linear arithmetic, to the following three new goals:

  Case 3.3.
          (IMPLIES (AND (LESSP (DIFFERENCE X Y) Z)
                        (ZEROP X))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))).

    But this again simplifies, unfolding the functions DIFFERENCE, ZEROP,
    EQUAL, and PLUS, to:

          T.

  Case 3.2.
          (IMPLIES (AND (LESSP X Y) (ZEROP X))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))),

    which again simplifies, opening up ZEROP, EQUAL, DIFFERENCE, and PLUS, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LESSP X (PLUS Y Z)) (ZEROP X))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))),

    which again simplifies, opening up the definitions of PLUS, ZEROP, EQUAL,
    and DIFFERENCE, to:

          T.

Case 2. (IMPLIES (AND (NOT (ZEROP X)) (ZEROP Y))
                 (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                        (DIFFERENCE X (PLUS Y Z)))),

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

  Case 2.3.
          (IMPLIES (AND (LESSP (DIFFERENCE X Y) Z)
                        (NOT (ZEROP X))
                        (ZEROP Y))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))),

    which again simplifies, expanding the definitions of DIFFERENCE, ZEROP,
    EQUAL, and PLUS, to two new formulas:

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

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

            T.

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

      which again simplifies, expanding LESSP, to:

            T.

  Case 2.2.
          (IMPLIES (AND (LESSP X Y)
                        (NOT (ZEROP X))
                        (ZEROP Y))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))),

    which again simplifies, unfolding the definitions of ZEROP, EQUAL,
    DIFFERENCE, and PLUS, to two new goals:

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

      which again simplifies, using linear arithmetic, to:

            T.

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

      which again simplifies, expanding LESSP, to:

            T.

  Case 2.1.
          (IMPLIES (AND (LESSP X (PLUS Y Z))
                        (NOT (ZEROP X))
                        (ZEROP Y))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))),

    which again simplifies, opening up the functions PLUS, ZEROP, EQUAL, and
    DIFFERENCE, to:

          T.

Case 1. (IMPLIES (AND (NOT (ZEROP X))
                      (NOT (ZEROP Y))
                      (EQUAL (DIFFERENCE (DIFFERENCE (SUB1 X) (SUB1 Y))
                                         Z)
                             (DIFFERENCE (SUB1 X)
                                         (PLUS (SUB1 Y) Z))))
                 (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                        (DIFFERENCE X (PLUS Y Z)))),

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

  Case 1.3.
          (IMPLIES (AND (LESSP (DIFFERENCE X Y) Z)
                        (NOT (ZEROP X))
                        (NOT (ZEROP Y))
                        (EQUAL (DIFFERENCE (DIFFERENCE (SUB1 X) (SUB1 Y))
                                           Z)
                               (DIFFERENCE (SUB1 X)
                                           (PLUS (SUB1 Y) Z))))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))),

    which again simplifies, rewriting with SUB1-ADD1, and opening up the
    definitions of DIFFERENCE, ZEROP, and PLUS, to:

          T.

  Case 1.2.
          (IMPLIES (AND (LESSP X Y)
                        (NOT (ZEROP X))
                        (NOT (ZEROP Y))
                        (EQUAL (DIFFERENCE (DIFFERENCE (SUB1 X) (SUB1 Y))
                                           Z)
                               (DIFFERENCE (SUB1 X)
                                           (PLUS (SUB1 Y) Z))))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))).

    But this again simplifies, appealing to the lemma SUB1-ADD1, and opening
    up the definitions of LESSP, ZEROP, DIFFERENCE, and PLUS, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LESSP X (PLUS Y Z))
                        (NOT (ZEROP X))
                        (NOT (ZEROP Y))
                        (EQUAL (DIFFERENCE (DIFFERENCE (SUB1 X) (SUB1 Y))
                                           Z)
                               (DIFFERENCE (SUB1 X)
                                           (PLUS (SUB1 Y) Z))))
                   (EQUAL (DIFFERENCE (DIFFERENCE X Y) Z)
                          (DIFFERENCE X (PLUS Y Z)))),

    which again simplifies, applying SUB1-ADD1, and unfolding PLUS, ZEROP, and
    DIFFERENCE, to:

          T.


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


[ 0.0 0.0 0.0 ]

DIFF-DIFF-ARG1


(PROVE-LEMMA DIFF-DIFF-ARG2
             (REWRITE)
             (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                    (IF (LESSP B C)
                        (FIX A)
                        (DIFFERENCE (PLUS A C) B)))
             ((ENABLE DIFF-SUB1-ARG2 PLUS-ZERO-ARG2)
              (INDUCT (DIFFERENCE A B))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This conjecture can be simplified, using the abbreviations ZEROP, NOT, OR, and
AND, to three new goals:

Case 3. (IMPLIES (ZEROP A)
                 (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                        (IF (LESSP B C)
                            (FIX A)
                            (DIFFERENCE (PLUS A C) B)))),

  which simplifies, unfolding the definitions of ZEROP, EQUAL, DIFFERENCE, FIX,
  and PLUS, to four new conjectures:

  Case 3.4.
          (IMPLIES (AND (EQUAL A 0)
                        (NOT (LESSP B C))
                        (NUMBERP C))
                   (EQUAL 0 (DIFFERENCE C B))),

    which again simplifies, clearly, to:

          (IMPLIES (AND (NOT (LESSP B C)) (NUMBERP C))
                   (EQUAL 0 (DIFFERENCE C B))),

    which we will name *1.

  Case 3.3.
          (IMPLIES (AND (EQUAL A 0)
                        (NOT (LESSP B C))
                        (NOT (NUMBERP C)))
                   (EQUAL 0 (DIFFERENCE 0 B))).

    However this again simplifies, expanding LESSP, EQUAL, and DIFFERENCE, to:

          T.

  Case 3.2.
          (IMPLIES (AND (NOT (NUMBERP A))
                        (NOT (LESSP B C))
                        (NUMBERP C))
                   (EQUAL 0 (DIFFERENCE C B))),

    which we will name *2.

  Case 3.1.
          (IMPLIES (AND (NOT (NUMBERP A))
                        (NOT (LESSP B C))
                        (NOT (NUMBERP C)))
                   (EQUAL 0 (DIFFERENCE 0 B))).

    However this again simplifies, expanding the definitions of LESSP, EQUAL,
    and DIFFERENCE, to:

          T.

Case 2. (IMPLIES (AND (NOT (EQUAL A 0))
                      (NUMBERP A)
                      (ZEROP B))
                 (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                        (IF (LESSP B C)
                            (FIX A)
                            (DIFFERENCE (PLUS A C) B)))),

  which simplifies, expanding the functions ZEROP, EQUAL, DIFFERENCE, LESSP,
  and FIX, to eight new conjectures:

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, applying the lemma PLUS-ZERO-ARG2, and opening up
    ZEROP, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, using linear arithmetic, to:

          T.

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

    which again simplifies, rewriting with PLUS-ZERO-ARG2, and expanding the
    function ZEROP, to:

          T.

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

    This again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES (AND (NOT (EQUAL A 0))
                      (NUMBERP A)
                      (NOT (EQUAL B 0))
                      (NUMBERP B)
                      (EQUAL (DIFFERENCE (SUB1 A)
                                         (DIFFERENCE (SUB1 B) C))
                             (IF (LESSP (SUB1 B) C)
                                 (FIX (SUB1 A))
                                 (DIFFERENCE (PLUS (SUB1 A) C)
                                             (SUB1 B)))))
                 (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                        (IF (LESSP B C)
                            (FIX A)
                            (DIFFERENCE (PLUS A C) B)))),

  which simplifies, appealing to the lemmas DIFF-SUB1-ARG2 and SUB1-ADD1, and
  opening up FIX, PLUS, and DIFFERENCE, to seven new goals:

  Case 1.7.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (NOT (LESSP (SUB1 B) C))
                        (LESSP (PLUS (SUB1 A) C) B)
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               0)
                        (NOT (LESSP B C)))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          0)),

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

    Case 1.7.2.
            (IMPLIES (AND (LESSP A (DIFFERENCE B C))
                          (NOT (EQUAL A 0))
                          (NUMBERP A)
                          (NOT (EQUAL B 0))
                          (NUMBERP B)
                          (NOT (LESSP (SUB1 B) C))
                          (LESSP (PLUS (SUB1 A) C) B)
                          (EQUAL (DIFFERENCE (SUB1 A)
                                             (DIFFERENCE (SUB1 B) C))
                                 0)
                          (NOT (LESSP B C)))
                     (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                            0)),

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

            (IMPLIES (AND (LESSP (SUB1 A)
                                 (DIFFERENCE (SUB1 B) C))
                          (LESSP A (DIFFERENCE B C))
                          (NOT (EQUAL A 0))
                          (NUMBERP A)
                          (NOT (EQUAL B 0))
                          (NUMBERP B)
                          (NOT (LESSP (SUB1 B) C))
                          (LESSP (PLUS (SUB1 A) C) B)
                          (EQUAL (DIFFERENCE (SUB1 A)
                                             (DIFFERENCE (SUB1 B) C))
                                 0)
                          (NOT (LESSP B C)))
                     (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                            0)).

      Appealing to the lemma SUB1-ELIM, we now replace A by (ADD1 X) to
      eliminate (SUB1 A).  We use the type restriction lemma noted when SUB1
      was introduced to constrain the new variable.  We must thus prove:

            (IMPLIES (AND (NUMBERP X)
                          (LESSP X (DIFFERENCE (SUB1 B) C))
                          (LESSP (ADD1 X) (DIFFERENCE B C))
                          (NOT (EQUAL (ADD1 X) 0))
                          (NOT (EQUAL B 0))
                          (NUMBERP B)
                          (NOT (LESSP (SUB1 B) C))
                          (LESSP (PLUS X C) B)
                          (EQUAL (DIFFERENCE X (DIFFERENCE (SUB1 B) C))
                                 0)
                          (NOT (LESSP B C)))
                     (EQUAL (DIFFERENCE (ADD1 X) (DIFFERENCE B C))
                            0)).

      This further simplifies, applying SUB1-ADD1 and DIFF-SUB1-ARG2, and
      opening up LESSP and DIFFERENCE, to the new conjecture:

            (IMPLIES (AND (NUMBERP X)
                          (LESSP X (DIFFERENCE (SUB1 B) C))
                          (NOT (EQUAL (DIFFERENCE B C) 0))
                          (LESSP X (SUB1 (DIFFERENCE B C)))
                          (NOT (EQUAL B 0))
                          (NUMBERP B)
                          (NOT (LESSP (SUB1 B) C))
                          (LESSP (PLUS X C) B)
                          (EQUAL (DIFFERENCE X (DIFFERENCE (SUB1 B) C))
                                 0)
                          (NOT (LESSP B C))
                          (NOT (LESSP X (DIFFERENCE B C))))
                     (EQUAL (ADD1 (DIFFERENCE X (DIFFERENCE B C)))
                            0)),

      which finally simplifies, using linear arithmetic, to:

            T.

    Case 1.7.1.
            (IMPLIES (AND (LESSP (SUB1 A)
                                 (DIFFERENCE (SUB1 B) C))
                          (NOT (EQUAL A 0))
                          (NUMBERP A)
                          (NOT (EQUAL B 0))
                          (NUMBERP B)
                          (NOT (LESSP (SUB1 B) C))
                          (LESSP (PLUS (SUB1 A) C) B)
                          (EQUAL (DIFFERENCE (SUB1 A)
                                             (DIFFERENCE (SUB1 B) C))
                                 0)
                          (NOT (LESSP B C)))
                     (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                            0)).

      Applying the lemma SUB1-ELIM, replace A by (ADD1 X) to eliminate
      (SUB1 A).  We employ the type restriction lemma noted when SUB1 was
      introduced to restrict the new variable.  We would thus like to prove:

            (IMPLIES (AND (NUMBERP X)
                          (LESSP X (DIFFERENCE (SUB1 B) C))
                          (NOT (EQUAL (ADD1 X) 0))
                          (NOT (EQUAL B 0))
                          (NUMBERP B)
                          (NOT (LESSP (SUB1 B) C))
                          (LESSP (PLUS X C) B)
                          (EQUAL (DIFFERENCE X (DIFFERENCE (SUB1 B) C))
                                 0)
                          (NOT (LESSP B C)))
                     (EQUAL (DIFFERENCE (ADD1 X) (DIFFERENCE B C))
                            0)),

      which further simplifies, rewriting with SUB1-ADD1 and DIFF-SUB1-ARG2,
      and unfolding DIFFERENCE, to the following two new conjectures:

      Case 1.7.1.2.
              (IMPLIES (AND (NUMBERP X)
                            (LESSP X (DIFFERENCE (SUB1 B) C))
                            (NOT (EQUAL B 0))
                            (NUMBERP B)
                            (NOT (LESSP (SUB1 B) C))
                            (LESSP (PLUS X C) B)
                            (EQUAL (DIFFERENCE X (DIFFERENCE (SUB1 B) C))
                                   0)
                            (NOT (LESSP B C))
                            (NOT (EQUAL (DIFFERENCE B C) 0))
                            (NOT (LESSP X (DIFFERENCE B C))))
                       (EQUAL (ADD1 (DIFFERENCE X (DIFFERENCE B C)))
                              0)).

        This again simplifies, using linear arithmetic, to:

              T.

      Case 1.7.1.1.
              (IMPLIES (AND (NUMBERP X)
                            (LESSP X (DIFFERENCE (SUB1 B) C))
                            (NOT (EQUAL B 0))
                            (NUMBERP B)
                            (NOT (LESSP (SUB1 B) C))
                            (LESSP (PLUS X C) B)
                            (EQUAL (DIFFERENCE X (DIFFERENCE (SUB1 B) C))
                                   0)
                            (NOT (LESSP B C))
                            (EQUAL (DIFFERENCE B C) 0))
                       (EQUAL (ADD1 X) 0)),

        which again simplifies, using linear arithmetic, to:

              T.

  Case 1.6.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (NOT (LESSP (SUB1 B) C))
                        (LESSP (PLUS (SUB1 A) C) B)
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               0)
                        (LESSP B C))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          A)),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.5.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (NOT (LESSP (SUB1 B) C))
                        (NOT (LESSP (PLUS (SUB1 A) C) B))
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               (ADD1 (DIFFERENCE (PLUS (SUB1 A) C) B)))
                        (NOT (LESSP B C)))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          (ADD1 (DIFFERENCE (PLUS (SUB1 A) C) B)))),

    which again simplifies, using linear arithmetic, to:

          (IMPLIES (AND (LESSP A (DIFFERENCE B C))
                        (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (NOT (LESSP (SUB1 B) C))
                        (NOT (LESSP (PLUS (SUB1 A) C) B))
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               (ADD1 (DIFFERENCE (PLUS (SUB1 A) C) B)))
                        (NOT (LESSP B C)))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          (ADD1 (DIFFERENCE (PLUS (SUB1 A) C) B)))).

    But this again simplifies, using linear arithmetic, to:

          T.

  Case 1.4.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (NOT (LESSP (SUB1 B) C))
                        (NOT (LESSP (PLUS (SUB1 A) C) B))
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               (ADD1 (DIFFERENCE (PLUS (SUB1 A) C) B)))
                        (LESSP B C))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          A)),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.3.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (LESSP (SUB1 B) C)
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               (SUB1 A))
                        (NOT (LESSP B C))
                        (LESSP (PLUS (SUB1 A) C) B))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          0)),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.2.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (LESSP (SUB1 B) C)
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               (SUB1 A))
                        (NOT (LESSP B C))
                        (NOT (LESSP (PLUS (SUB1 A) C) B)))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          (ADD1 (DIFFERENCE (PLUS (SUB1 A) C) B)))),

    which again simplifies, using linear arithmetic, to:

          (IMPLIES (AND (LESSP A (DIFFERENCE B C))
                        (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (LESSP (SUB1 B) C)
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               (SUB1 A))
                        (NOT (LESSP B C))
                        (NOT (LESSP (PLUS (SUB1 A) C) B)))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          (ADD1 (DIFFERENCE (PLUS (SUB1 A) C) B)))).

    This again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL B 0))
                        (NUMBERP B)
                        (LESSP (SUB1 B) C)
                        (EQUAL (DIFFERENCE (SUB1 A)
                                           (DIFFERENCE (SUB1 B) C))
                               (SUB1 A))
                        (LESSP B C))
                   (EQUAL (DIFFERENCE A (DIFFERENCE B C))
                          A)).

    Applying the lemma SUB1-ELIM, replace B by (ADD1 X) to eliminate (SUB1 B).
    We employ the type restriction lemma noted when SUB1 was introduced to
    restrict the new variable.  This produces:

          (IMPLIES (AND (NUMBERP X)
                        (NOT (EQUAL A 0))
                        (NUMBERP A)
                        (NOT (EQUAL (ADD1 X) 0))
                        (LESSP X C)
                        (EQUAL (DIFFERENCE (SUB1 A) (DIFFERENCE X C))
                               (SUB1 A))
                        (LESSP (ADD1 X) C))
                   (EQUAL (DIFFERENCE A (DIFFERENCE (ADD1 X) C))
                          A)),

    which further simplifies, rewriting with SUB1-ADD1 and DIFF-SUB1-ARG2, and
    unfolding the definitions of LESSP, DIFFERENCE, and EQUAL, to:

          T.


     So next consider:

      (IMPLIES (AND (NOT (NUMBERP A))
                    (NOT (LESSP B C))
                    (NUMBERP C))
               (EQUAL 0 (DIFFERENCE C B))),

which we named *2 above.  Ah ha!  This conjecture is subsumed by another
subgoal awaiting our attention, namely *1 above.


     So we now return to:

      (IMPLIES (AND (NOT (LESSP B C)) (NUMBERP C))
               (EQUAL 0 (DIFFERENCE C B))),

which we named *1 above.  Perhaps we can prove it by induction.  There are
four plausible inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (OR (EQUAL C 0) (NOT (NUMBERP C)))
                    (p C B))
           (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                         (OR (EQUAL B 0) (NOT (NUMBERP B))))
                    (p C B))
           (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                         (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                         (p (SUB1 C) (SUB1 B)))
                    (p C B))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT inform us that the measure (COUNT B) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  Note,
however, the inductive instance chosen for C.  The above induction scheme
leads to the following four new conjectures:

Case 4. (IMPLIES (AND (OR (EQUAL C 0) (NOT (NUMBERP C)))
                      (NOT (LESSP B C))
                      (NUMBERP C))
                 (EQUAL 0 (DIFFERENCE C B))).

  This simplifies, opening up NOT, OR, EQUAL, LESSP, NUMBERP, and DIFFERENCE,
  to:

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (OR (EQUAL B 0) (NOT (NUMBERP B)))
                      (NOT (LESSP B C))
                      (NUMBERP C))
                 (EQUAL 0 (DIFFERENCE C B))).

  This simplifies, opening up the functions NOT, OR, EQUAL, and LESSP, to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (LESSP (SUB1 B) (SUB1 C))
                      (NOT (LESSP B C))
                      (NUMBERP C))
                 (EQUAL 0 (DIFFERENCE C B))).

  This simplifies, using linear arithmetic, to:

        (IMPLIES (AND (EQUAL C 0)
                      (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (LESSP (SUB1 B) (SUB1 C))
                      (NOT (LESSP B C))
                      (NUMBERP C))
                 (EQUAL 0 (DIFFERENCE C B))),

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

        T.

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

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

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

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

          T.

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

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

          T.

  Case 1.1.
          (IMPLIES (AND (LESSP C B)
                        (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                        (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                        (EQUAL 0
                               (DIFFERENCE (SUB1 C) (SUB1 B)))
                        (NOT (LESSP B C))
                        (NUMBERP C))
                   (EQUAL 0 (DIFFERENCE C B))),

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

    Case 1.1.2.
            (IMPLIES (AND (LESSP (SUB1 C) (SUB1 B))
                          (LESSP C B)
                          (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                          (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                          (EQUAL 0
                                 (DIFFERENCE (SUB1 C) (SUB1 B)))
                          (NOT (LESSP B C))
                          (NUMBERP C))
                     (EQUAL 0 (DIFFERENCE C B))),

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

            T.

    Case 1.1.1.
            (IMPLIES (AND (EQUAL C 0)
                          (LESSP C B)
                          (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                          (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                          (EQUAL 0
                                 (DIFFERENCE (SUB1 C) (SUB1 B)))
                          (NOT (LESSP B C))
                          (NUMBERP C))
                     (EQUAL 0 (DIFFERENCE C B))),

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

            T.


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


[ 0.0 0.1 0.0 ]

DIFF-DIFF-ARG2


(PROVE-LEMMA DIFF-DIFF-DIFF
             (REWRITE)
             (IMPLIES (AND (IF (LESSP A B) F T)
                           (IF (LESSP C D) F T))
                      (EQUAL (DIFFERENCE (DIFFERENCE A B)
                                         (DIFFERENCE C D))
                             (DIFFERENCE (PLUS A D) (PLUS B C))))
             ((ENABLE DIFF-DIFF-ARG1 DIFF-DIFF-ARG2 PLUS-DIFFERENCE-ARG2
                      PLUS-ZERO-ARG2)
              (DO-NOT-INDUCT T)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

WARNING:  the previously added lemma, DIFF-DIFF-ARG2, could be applied
whenever the newly proposed DIFF-DIFF-DIFF could!


WARNING:  the previously added lemma, DIFF-DIFF-ARG1, could be applied
whenever the newly proposed DIFF-DIFF-DIFF could!


This formula can be simplified, using the abbreviations AND, IMPLIES, and
DIFF-DIFF-ARG1, to the new goal:

      (IMPLIES (AND (NOT (LESSP A B))
                    (NOT (LESSP C D)))
               (EQUAL (DIFFERENCE A
                                  (PLUS B (DIFFERENCE C D)))
                      (DIFFERENCE (PLUS A D) (PLUS B C)))),

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

Case 2. (IMPLIES (AND (LESSP A (PLUS B (DIFFERENCE C D)))
                      (NOT (LESSP A B))
                      (NOT (LESSP C D)))
                 (EQUAL (DIFFERENCE A
                                    (PLUS B (DIFFERENCE C D)))
                        (DIFFERENCE (PLUS A D) (PLUS B C)))),

  which again simplifies, rewriting with PLUS-ZERO-ARG2, PLUS-DIFFERENCE-ARG2,
  and DIFF-DIFF-ARG2, and unfolding the functions ZEROP, LESSP, EQUAL,
  DIFFERENCE, and PLUS, to the following eight new formulas:

  Case 2.8.
          (IMPLIES (AND (NOT (LESSP D C))
                        (NOT (NUMBERP B))
                        (LESSP A 0)
                        (NOT (LESSP C D))
                        (NOT (NUMBERP C))
                        (NOT (EQUAL A 0))
                        (NUMBERP A))
                   (EQUAL A (DIFFERENCE (PLUS A D) 0))).

    This again simplifies, using linear arithmetic, to:

          T.

  Case 2.7.
          (IMPLIES (AND (NOT (LESSP D C))
                        (NOT (NUMBERP B))
                        (LESSP A 0)
                        (NOT (LESSP C D))
                        (NOT (NUMBERP C))
                        (EQUAL A 0))
                   (EQUAL 0 (DIFFERENCE (PLUS A D) 0))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.6.
          (IMPLIES (AND (NOT (LESSP D C))
                        (NOT (NUMBERP B))
                        (LESSP A 0)
                        (NOT (LESSP C D))
                        (NOT (NUMBERP C))
                        (NOT (NUMBERP A)))
                   (EQUAL 0 (DIFFERENCE (PLUS A D) 0))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.5.
          (IMPLIES (AND (NOT (LESSP D C))
                        (NOT (NUMBERP B))
                        (LESSP A 0)
                        (NOT (LESSP C D))
                        (NUMBERP C)
                        (NOT (EQUAL A 0))
                        (NUMBERP A))
                   (EQUAL A (DIFFERENCE (PLUS A D) C))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.4.
          (IMPLIES (AND (NOT (LESSP D C))
                        (NOT (NUMBERP B))
                        (LESSP A 0)
                        (NOT (LESSP C D))
                        (NUMBERP C)
                        (EQUAL A 0))
                   (EQUAL 0 (DIFFERENCE (PLUS A D) C))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.3.
          (IMPLIES (AND (NOT (LESSP D C))
                        (NOT (NUMBERP B))
                        (LESSP A 0)
                        (NOT (LESSP C D))
                        (NUMBERP C)
                        (NOT (NUMBERP A)))
                   (EQUAL 0 (DIFFERENCE (PLUS A D) C))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LESSP D C)
                        (LESSP A (DIFFERENCE (PLUS B C) D))
                        (NOT (LESSP A B))
                        (NOT (LESSP C D))
                        (LESSP (PLUS B C) D)
                        (NUMBERP A))
                   (EQUAL A
                          (DIFFERENCE (PLUS A D) (PLUS B C)))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LESSP D C)
                        (LESSP A (DIFFERENCE (PLUS B C) D))
                        (NOT (LESSP A B))
                        (NOT (LESSP C D))
                        (LESSP (PLUS B C) D)
                        (NOT (NUMBERP A)))
                   (EQUAL 0
                          (DIFFERENCE (PLUS A D) (PLUS B C)))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES (AND (LESSP (PLUS A D) (PLUS B C))
                      (NOT (LESSP A B))
                      (NOT (LESSP C D)))
                 (EQUAL (DIFFERENCE A
                                    (PLUS B (DIFFERENCE C D)))
                        (DIFFERENCE (PLUS A D) (PLUS B C)))),

  which again simplifies, rewriting with PLUS-ZERO-ARG2 and
  PLUS-DIFFERENCE-ARG2, and opening up the function ZEROP, to the following
  three new conjectures:

  Case 1.3.
          (IMPLIES (AND (LESSP (PLUS A D) (PLUS B C))
                        (NOT (LESSP A B))
                        (NOT (LESSP C D))
                        (NOT (LESSP D C))
                        (NUMBERP B))
                   (EQUAL (DIFFERENCE A B)
                          (DIFFERENCE (PLUS A D) (PLUS B C)))).

    However this again simplifies, using linear arithmetic, to:

          T.

  Case 1.2.
          (IMPLIES (AND (LESSP (PLUS A D) (PLUS B C))
                        (NOT (LESSP A B))
                        (NOT (LESSP C D))
                        (NOT (LESSP D C))
                        (NOT (NUMBERP B)))
                   (EQUAL (DIFFERENCE A 0)
                          (DIFFERENCE (PLUS A D) (PLUS B C)))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LESSP (PLUS A D) (PLUS B C))
                        (NOT (LESSP A B))
                        (NOT (LESSP C D))
                        (LESSP D C))
                   (EQUAL (DIFFERENCE A
                                      (DIFFERENCE (PLUS B C) D))
                          (DIFFERENCE (PLUS A D) (PLUS B C)))),

    which again simplifies, applying DIFF-DIFF-ARG2, to the following two new
    formulas:

    Case 1.1.2.
            (IMPLIES (AND (LESSP (PLUS A D) (PLUS B C))
                          (NOT (LESSP A B))
                          (NOT (LESSP C D))
                          (LESSP D C)
                          (LESSP (PLUS B C) D)
                          (NUMBERP A))
                     (EQUAL A
                            (DIFFERENCE (PLUS A D) (PLUS B C)))).

      But this again simplifies, using linear arithmetic, to:

            T.

    Case 1.1.1.
            (IMPLIES (AND (LESSP (PLUS A D) (PLUS B C))
                          (NOT (LESSP A B))
                          (NOT (LESSP C D))
                          (LESSP D C)
                          (LESSP (PLUS B C) D)
                          (NOT (NUMBERP A)))
                     (EQUAL 0
                            (DIFFERENCE (PLUS A D) (PLUS B C)))),

      which again simplifies, using linear arithmetic, to:

            T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFF-DIFF-DIFF


(TOGGLE DIFF-DIFF-DIFF-OFF DIFF-DIFF-DIFF T)

[ 0.0 0.0 0.0 ]

DIFF-DIFF-DIFF-OFF


(PROVE-LEMMA DIFFERENCE-LESSP-ARG1
             (REWRITE)
             (IMPLIES (LESSP A B)
                      (EQUAL (DIFFERENCE A B) 0))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     Give the conjecture the name *1.


     We will try to prove it by induction.  There are four plausible
inductions.  However, they merge into one likely candidate induction.  We will
induct according to the following scheme:
      (AND (IMPLIES (OR (EQUAL B 0) (NOT (NUMBERP B)))
                    (p A B))
           (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                         (OR (EQUAL A 0) (NOT (NUMBERP A))))
                    (p A B))
           (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                         (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                         (p (SUB1 A) (SUB1 B)))
                    (p A B))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT inform us that the measure (COUNT A) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  Note,
however, the inductive instance chosen for B.  The above induction scheme
generates four new goals:

Case 4. (IMPLIES (AND (OR (EQUAL B 0) (NOT (NUMBERP B)))
                      (LESSP A B))
                 (EQUAL (DIFFERENCE A B) 0)),

  which simplifies, expanding NOT, OR, EQUAL, and LESSP, to:

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (OR (EQUAL A 0) (NOT (NUMBERP A)))
                      (LESSP A B))
                 (EQUAL (DIFFERENCE A B) 0)),

  which simplifies, opening up the functions NOT, OR, EQUAL, LESSP, and
  DIFFERENCE, to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                      (NOT (LESSP (SUB1 A) (SUB1 B)))
                      (LESSP A B))
                 (EQUAL (DIFFERENCE A B) 0)),

  which simplifies, using linear arithmetic, to the formula:

        (IMPLIES (AND (LESSP A 1)
                      (NOT (OR (EQUAL B 0) (NOT (NUMBERP B))))
                      (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                      (NOT (LESSP (SUB1 A) (SUB1 B)))
                      (LESSP A B))
                 (EQUAL (DIFFERENCE A B) 0)).

  But this again simplifies, unfolding the functions SUB1, NUMBERP, EQUAL,
  LESSP, NOT, and OR, to:

        T.

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

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

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

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

          T.

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

    which again simplifies, unfolding 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-LESSP-ARG1


(TOGGLE DIFFERENCE-LESSP-ARG1-OFF DIFFERENCE-LESSP-ARG1 T)

[ 0.0 0.0 0.0 ]

DIFFERENCE-LESSP-ARG1-OFF


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

     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)
      (COND ((NLISTP L) ''0)
            ((NLISTP (CDR L))
             (LIST 'FIX (CAR L)))
            ((NLISTP (CDDR L))
             (LIST 'PLUS (CAR L) (CADR L)))
            (T (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


(PROVE-LEMMA NUMBERP-EVAL$-PLUS
             (REWRITE)
             (IMPLIES (AND (LISTP X) (EQUAL (CAR X) 'PLUS))
                      (NUMBERP (EVAL$ T X A)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

.

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


(TOGGLE NUMBERP-EVAL$-PLUS-OFF NUMBERP-EVAL$-PLUS T)

[ 0.0 0.0 0.0 ]

NUMBERP-EVAL$-PLUS-OFF


(PROVE-LEMMA NUMBERP-EVAL$-PLUS-TREE
             (REWRITE)
             (NUMBERP (EVAL$ T (PLUS-TREE L) A))
             ((ENABLE PLUS-TREE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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.1 0.0 ]

NUMBERP-EVAL$-PLUS-TREE


(TOGGLE NUMBERP-EVAL$-PLUS-TREE-OFF NUMBERP-EVAL$-PLUS-TREE T)

[ 0.0 0.0 0.0 ]

NUMBERP-EVAL$-PLUS-TREE-OFF


(PROVE-LEMMA MEMBER-IMPLIES-PLUS-TREE-GREATEREQP
             (REWRITE)
             (IMPLIES (MEMBER X Y)
                      (NOT (LESSP (EVAL$ T (PLUS-TREE Y) A)
                                  (EVAL$ T X A))))
             ((ENABLE PLUS-TREE PLUS-ZERO-ARG2)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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-ZERO-ARG2, and opening up the functions PLUS-TREE, FIX,
    and ZEROP, 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 1.0 0.0 ]

MEMBER-IMPLIES-PLUS-TREE-GREATEREQP


(TOGGLE MEMBER-IMPLIES-PLUS-TREE-GREATEREQP-OFF
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP T)

[ 0.0 0.0 0.0 ]

MEMBER-IMPLIES-PLUS-TREE-GREATEREQP-OFF


(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)))
             ((ENABLE DELETE PLUS-TREE DELETE-NON-MEMBER
                      DIFFERENCE-PLUS-CANCELLATION EQUAL-DIFFERENCE-0
                      EQUAL-PLUS-0 LISTP-DELETE
                      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP
                      NUMBERP-EVAL$-PLUS-TREE PLUS-ZERO-ARG2)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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, expanding the functions EQUAL and DIFFERENCE, to:

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

      But this 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 further simplifies, rewriting with EQUAL-DIFFERENCE-0, and
      unfolding the definitions of PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL,
      and EVAL$, to:

            (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)))
                   (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-CANCELLATION, 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-CANCELLATION, 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, LISTP-DELETE, and CDR-CONS, and
  expanding the functions NLISTP, MEMBER, DELETE, and PLUS-TREE, to six new
  formulas:

  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))
                        (NOT (LISTP (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 LISTP-DELETE, EQUAL-DIFFERENCE-0,
    REWRITE-EVAL$, and CAR-CONS, and opening up the functions PLUS-TREE, CDR,
    CAR, LISTP, LITATOM, EQUAL, EVAL$, and FIX, to the following two new
    conjectures:

    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))
                          (NOT (LISTP (CDR Y)))
                          (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                     (EQUAL 0
                            (DIFFERENCE 0 (EVAL$ T X A)))).

      However this again simplifies, using linear arithmetic and applying
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to the following three new formulas:

      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))
                            (NOT (LISTP (CDR Y)))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE 0 (EVAL$ T X A)))).

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

              (IMPLIES (AND (LESSP 0 (EVAL$ T X A))
                            (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 (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE 0 (EVAL$ T X A)))),

        which again simplifies, using linear arithmetic and applying
        MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, 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))
                            (NOT (LISTP (CDR Y)))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE 0 (EVAL$ T X A)))).

        But this again simplifies, rewriting with NUMBERP-EVAL$-PLUS-TREE, and
        unfolding the functions LESSP, EQUAL, and DIFFERENCE, 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))
                            (NOT (LISTP (CDR Y)))
                            (NOT (NUMBERP (EVAL$ T (CAR Y) A))))
                       (EQUAL 0
                              (DIFFERENCE 0 (EVAL$ T X A)))).

        This again simplifies, unfolding EQUAL and DIFFERENCE, 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))
                          (NOT (LISTP (CDR Y)))
                          (NUMBERP (EVAL$ T (CAR Y) A)))
                     (EQUAL (EVAL$ T (CAR Y) A)
                            (DIFFERENCE (EVAL$ T (CAR 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.6.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))
                            (NOT (LISTP (CDR Y)))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (EVAL$ T (CAR Y) A)
                                          (EVAL$ T X A)))),

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

              (IMPLIES (AND (LESSP (EVAL$ T (CAR Y) A)
                                   (EVAL$ T X A))
                            (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)))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (EVAL$ T (CAR Y) A)
                                          (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.6.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))
                            (NOT (LISTP (CDR Y)))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (EVAL$ T (CAR Y) A)
                                          (EVAL$ T X A)))),

        which again simplifies, rewriting with the lemma
        NUMBERP-EVAL$-PLUS-TREE, and opening up the functions LESSP and
        DIFFERENCE, to:

              T.

      Case 1.6.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))
                            (NOT (LISTP (CDR Y)))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (EVAL$ T (CAR Y) A)
                                          (EVAL$ T X A)))),

        which again simplifies, trivially, to the new formula:

              (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))
                            (NOT (LISTP (CDR Y)))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (EVAL$ T (CAR Y) A)
                                          (EVAL$ T X A)))),

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

              (IMPLIES (AND (LESSP (EVAL$ T (CAR Y) A)
                                   (EVAL$ T X A))
                            (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))
                            (NOT (LISTP (CDR Y)))
                            (NUMBERP (EVAL$ T (CAR Y) A)))
                       (EQUAL (EVAL$ T (CAR Y) A)
                              (DIFFERENCE (EVAL$ T (CAR Y) A)
                                          (EVAL$ T X A)))),

        which finally simplifies, using linear arithmetic, appealing to the
        lemma MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, and unfolding the functions
        EVAL$, EQUAL, LITATOM, LISTP, CAR, CDR, and PLUS-TREE, 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 (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
    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))
                        (LISTP (CDDR 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 conjectures:

    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 (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 appealing to the
      lemma 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 (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 the goal:

            (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 (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 and applying the
      lemma 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))
                        (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)))),

    which again simplifies, rewriting with LISTP-DELETE, REWRITE-EVAL$,
    CAR-CONS, CDR-CONS, and PLUS-ZERO-ARG2, and expanding the definitions of
    PLUS-TREE, FIX, and ZEROP, to the following three new goals:

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

      But this again simplifies, applying the lemmas EQUAL-DIFFERENCE-0 and
      NUMBERP-EVAL$-PLUS-TREE, and opening up the definition of PLUS, 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))
                          (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))
                           (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 appealing to 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))
                           (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))
                           (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)))).

        However this again simplifies, using linear arithmetic and applying
        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))
                          (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)))).

      However this 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))
                           (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 rewriting with
        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))
                           (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))
                           (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)))).

        However 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 (EQUAL X (CADR 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)))).

    But this again simplifies, rewriting with the lemmas 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))
                        (NOT (LISTP (CDDR Y)))
                        (NOT (EQUAL X (CADR 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)))).

    This further simplifies, appealing to the lemmas CONS-CAR-CDR,
    DELETE-NON-MEMBER, REWRITE-EVAL$, and CAR-CONS, and unfolding the
    functions MEMBER, DELETE, PLUS-TREE, and FIX, 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)))
                        (NOT (EQUAL X (CADR 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)))),

    which again simplifies, rewriting with LISTP-DELETE, REWRITE-EVAL$,
    CAR-CONS, CDR-CONS, and PLUS-ZERO-ARG2, and expanding PLUS-TREE, FIX, and
    ZEROP, to the following three new formulas:

    Case 1.2.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)))
                          (NOT (EQUAL X (CADR 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)))).

      But this again simplifies, applying EQUAL-DIFFERENCE-0, and expanding
      PLUS, to the following two new formulas:

      Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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))).

        This again simplifies, using linear arithmetic, to:

              T.

      Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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 goals:

        Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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)))).

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

                T.

        Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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)))).

          However this again simplifies, rewriting with
          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)))
                           (NOT (EQUAL X (CADR 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)),

          which finally simplifies, applying the lemmas CONS-CAR-CDR and
          DELETE-NON-MEMBER, and expanding the definitions of MEMBER and
          DELETE, to:

                T.

        Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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, trivially, to the new goal:

                (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)))
                           (NOT (EQUAL X (CADR 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 opening up the definitions
          of PLUS-TREE, FIX, MEMBER, and DELETE, to:

                T.

    Case 1.2.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)))
                          (NOT (EQUAL X (CADR 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, rewriting with 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)))
                          (NOT (EQUAL X (CADR 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, using linear arithmetic and rewriting with
      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, to the following three new formulas:

      Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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, appealing to the lemma
        NUMBERP-EVAL$-PLUS-TREE, to:

              T.

      Case 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)))
                           (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 (EQUAL X (CADR 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, applying the lemmas NUMBERP-EVAL$-PLUS-TREE
        and EQUAL-PLUS-0, and unfolding the definitions of LESSP and
        DIFFERENCE, to two new goals:

        Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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)))),

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

                T.

        Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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)))).

          This finally simplifies, applying CONS-CAR-CDR, DELETE-NON-MEMBER,
          REWRITE-EVAL$, CAR-CONS, and PLUS-ZERO-ARG2, and expanding the
          functions MEMBER, DELETE, PLUS-TREE, FIX, EQUAL, and ZEROP, to:

                T.

      Case 1.2.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)))
                           (NOT (EQUAL X (CADR 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, trivially, 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)))
                           (NOT (EQUAL X (CADR 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, rewriting with REWRITE-EVAL$, CAR-CONS,
        CONS-CAR-CDR, DELETE-NON-MEMBER, and PLUS-ZERO-ARG2, and opening up
        the definitions of PLUS-TREE, FIX, MEMBER, DELETE, LESSP, ZEROP, EQUAL,
        and DIFFERENCE, to:

              T.

    Case 1.2.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)))
                          (NOT (EQUAL X (CADR 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, obviously, 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)))
                          (NOT (EQUAL X (CADR 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, applying CONS-CAR-CDR, DELETE-NON-MEMBER,
      REWRITE-EVAL$, and CAR-CONS, and unfolding the functions MEMBER, DELETE,
      PLUS-TREE, and FIX, to:

            (IMPLIES (AND (LISTP Y)
                          (NOT (EQUAL X (CAR Y)))
                          (NUMBERP (EVAL$ T (CADR Y) A))
                          (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 X (CADR Y))))
                     (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                  (EVAL$ T (CADR Y) A))
                            (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                              (EVAL$ T (CADR Y) A))
                                        (EVAL$ T X A)))),

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

      Case 1.2.1.2.
              (IMPLIES (AND (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                         (EVAL$ T (CADR Y) A))
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (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 X (CADR Y))))
                       (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                    (EVAL$ T (CADR Y) A))
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))),

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

              (IMPLIES (AND (LESSP (EVAL$ T (CADR Y) A)
                                   (EVAL$ T X A))
                            (LESSP (PLUS (EVAL$ T (CAR Y) A)
                                         (EVAL$ T (CADR Y) A))
                                   (EVAL$ T X A))
                            (LISTP Y)
                            (NOT (EQUAL X (CAR Y)))
                            (NUMBERP (EVAL$ T (CADR Y) A))
                            (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 X (CADR Y))))
                       (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                    (EVAL$ T (CADR Y) A))
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))).

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

              T.

      Case 1.2.1.1.
              (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))
                            (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 X (CADR Y))))
                       (EQUAL (PLUS (EVAL$ T (CAR Y) A)
                                    (EVAL$ T (CADR Y) A))
                              (DIFFERENCE (PLUS (EVAL$ T (CAR Y) A)
                                                (EVAL$ T (CADR Y) A))
                                          (EVAL$ T X A)))).

        However this finally simplifies, using linear arithmetic, rewriting
        with MEMBER-IMPLIES-PLUS-TREE-GREATEREQP, CAR-CONS, and REWRITE-EVAL$,
        and opening up the definitions of FIX and PLUS-TREE, 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)))
                        (EQUAL X (CADR Y)))
                   (EQUAL (EVAL$ T (LIST 'FIX (CAR Y)) A)
                          (DIFFERENCE (EVAL$ T
                                             (LIST 'PLUS (CAR Y) (CADR Y))
                                             A)
                                      (EVAL$ T X A)))).

    But this again simplifies, appealing to the lemmas EQUAL-DIFFERENCE-0,
    REWRITE-EVAL$, CAR-CONS, CDR-CONS, and DIFFERENCE-PLUS-CANCELLATION, and
    expanding the definitions of DELETE, PLUS-TREE, CDR, CAR, LISTP, LITATOM,
    EQUAL, EVAL$, MEMBER, and FIX, to:

          T.


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


[ 0.0 12.9 0.1 ]

PLUS-TREE-DELETE


(TOGGLE PLUS-TREE-DELETE-OFF PLUS-TREE-DELETE T)

[ 0.0 0.0 0.0 ]

PLUS-TREE-DELETE-OFF


(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))))
             ((ENABLE PLUS-TREE SUBBAGP MEMBER-IMPLIES-PLUS-TREE-GREATEREQP
                      PLUS-TREE-DELETE PLUS-ZERO-ARG2 SUBBAGP-CDR2)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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-ZERO-ARG2, and expanding the definitions of PLUS-TREE, FIX, and ZEROP,
    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 1.4 0.0 ]

SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP


(TOGGLE SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP-OFF
        SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP T)

[ 0.0 0.0 0.0 ]

SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP-OFF


(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))))
             ((ENABLE BAGDIFF PLUS-TREE SUBBAGP COMMUTATIVITY-OF-PLUS
                      DIFF-DIFF-ARG1 DIFFERENCE-LESSP-ARG1
                      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP
                      NUMBERP-EVAL$-PLUS-TREE PLUS-TREE-DELETE PLUS-ZERO-ARG2
                      SUBBAGP-CDR2 SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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 DIFF-DIFF-ARG1, 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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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, appealing to the lemma NUMBERP-EVAL$-PLUS-TREE,
      and unfolding the functions PLUS, EQUAL, and DIFFERENCE, to two new
      conjectures:

      Case 4.3.2.2.
              (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 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)))
                 (NOT (EQUAL (EVAL$ T (PLUS-TREE Y) A) 0)))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      (EVAL$ T (PLUS-TREE Y) A))),

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

              T.

      Case 4.3.2.1.
              (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 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 Y) A) 0))
               (EQUAL (EVAL$ T
                             (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                             A)
                      0)).

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

        Case 4.3.2.1.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 0
                                    (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 Y) A) 0))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        0)),

          which again simplifies, clearly, to:

                T.

        Case 4.3.2.1.1.
                (IMPLIES
                 (AND
                  (LESSP 0
                         (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 0
                                    (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 Y) A) 0))
                 (EQUAL (EVAL$ T
                               (PLUS-TREE (BAGDIFF (DELETE (CAR X) Y) (CDR X)))
                               A)
                        0)).

          This again simplifies, using linear arithmetic, applying
          SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP and PLUS-TREE-DELETE, and
          expanding DIFFERENCE, 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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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)))).

      However this further simplifies, applying PLUS-TREE-DELETE,
      PLUS-ZERO-ARG2, and SUBBAGP-CDR2, and unfolding BAGDIFF, PLUS-TREE, CDR,
      CAR, LISTP, LITATOM, EQUAL, EVAL$, ZEROP, 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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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)))).

    However this again simplifies, appealing to the lemmas REWRITE-EVAL$,
    CAR-CONS, and CDR-CONS, 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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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, rewriting with REWRITE-EVAL$, CAR-CONS, and
    CDR-CONS, to the new formula:

          (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 Y) A)
                                    (PLUS (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))))),

    which further simplifies, appealing to the lemmas REWRITE-EVAL$, CAR-CONS,
    and PLUS-ZERO-ARG2, and opening up the definitions of PLUS-TREE, FIX, and
    ZEROP, to two new conjectures:

    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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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))),

      which again simplifies, rewriting with PLUS-ZERO-ARG2 and
      NUMBERP-EVAL$-PLUS-TREE, and opening up the definitions of ZEROP, EQUAL,
      and DIFFERENCE, to:

            T.

    Case 4.1.1.
            (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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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)))).

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

      Case 4.1.1.3.
              (IMPLIES
               (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (PLUS (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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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 appealing to the
        lemma 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)
                (NOT (NUMBERP (EVAL$ T (CADR X) A)))
                (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) 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, obviously, to:

              T.

      Case 4.1.1.1.
              (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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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, to:

              (IMPLIES
               (AND
                 (LESSP (EVAL$ T (PLUS-TREE Y) A)
                        (PLUS (EVAL$ T (CAR X) A) 0))
                 (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 (EVAL$ T (PLUS-TREE Y) A)
                                    (PLUS (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 finally simplifies, using linear arithmetic and applying
        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)))).

  This simplifies, expanding the function 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)))).

  This simplifies, expanding the definition of 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)))).

  This simplifies, rewriting with SUBBAGP-CDR2 and NUMBERP-EVAL$-PLUS-TREE,
  and unfolding the definitions of 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 6.7 0.0 ]

PLUS-TREE-BAGDIFF


(TOGGLE PLUS-TREE-BAGDIFF-OFF PLUS-TREE-BAGDIFF T)

[ 0.0 0.0 0.0 ]

PLUS-TREE-BAGDIFF-OFF


(PROVE-LEMMA NUMBERP-EVAL$-BRIDGE
             (REWRITE)
             (IMPLIES (EQUAL (EVAL$ T Z A)
                             (EVAL$ T (PLUS-TREE X) A))
                      (NUMBERP (EVAL$ T Z A)))
             ((ENABLE PLUS-TREE NUMBERP-EVAL$-PLUS-TREE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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 lemmas SUB1-ADD1, REWRITE-APPLY$,
  NUMBERP-EVAL$-PLUS-TREE, and CAR-CONS, and opening up NLISTP, EVAL$, EQUAL,
  V&C-APPLY$, PLUS, FIX-COST, APPLY$, CAR, and NUMBERP, 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 lemmas SUB1-ADD1, REWRITE-APPLY$, and CAR-CONS,
  and expanding the definitions of NLISTP, EVAL$, EQUAL, V&C-APPLY$, PLUS,
  FIX-COST, APPLY$, CAR, and NUMBERP, to the following 16 new goals:

  Case 1.16.
          (IMPLIES (AND (NOT (LITATOM Z))
                        (LISTP Z)
                        (NOT (EQUAL (CAR Z) 'QUOTE))
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                            0)))
                        (EQUAL (CAR F)
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    This again simplifies, expanding the definitions of EQUAL and CAR, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                            0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS W V) to
    eliminate (CDR Z) and (CAR Z).  The result is:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))).

    This further simplifies, obviously, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  The
    result is:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAR (PAIRLIST Y 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR Y)))
                   (NUMBERP (CADDR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y), D by (CONS X1 C) to eliminate (CDR D) and
    (CAR D), and C by (CONS D Z1) to eliminate (CAR C) and (CDR C).  This
    generates four new goals:

    Case 1.16.4.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAR (PAIRLIST Y 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT (CAR Y)))
                     (NUMBERP (CADDR Y))),

      which finally simplifies, unfolding PAIRLIST and CAR, to:

            T.

    Case 1.16.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAR (PAIRLIST (CONS W D) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CADR D))),

      which finally simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
      unfolding CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.16.2.
            (IMPLIES (AND (NOT (LISTP C))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CAR C))),

      which finally simplifies, appealing to the lemmas CDR-CONS and CAR-CONS,
      and unfolding CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.16.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (NOT (CAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                              0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP D)),

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

            T.

  Case 1.15.
          (IMPLIES (AND (NOT (LITATOM Z))
                        (LISTP Z)
                        (NOT (EQUAL (CAR Z) 'QUOTE))
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                            0)))
                        (EQUAL (CAR F)
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

    However this again simplifies, unfolding EQUAL and CAR, to the goal:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                            0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS W V) to
    eliminate (CDR Z) and (CAR Z).  The result is:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))).

    This further simplifies, clearly, to the new formula:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  We must
    thus prove the formula:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAR (PAIRLIST Y 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR Y))
                   (NUMBERP (CADR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y) and D by (CONS C X1) to eliminate (CAR D)
    and (CDR D).  This generates three new conjectures:

    Case 1.15.3.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAR (PAIRLIST Y 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (CAR Y))
                     (NUMBERP (CADR Y))),

      which finally simplifies, expanding the functions PAIRLIST and CAR, to:

            T.

    Case 1.15.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAR (PAIRLIST (CONS W D) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP (CAR D))),

      which finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      opening up the definitions of CDR, CAR, and PAIRLIST, to:

            T.

    Case 1.15.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (NOT (CAR (PAIRLIST (CONS W (CONS C X1)) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP C)).

      But this finally simplifies, applying the lemmas CDR-CONS and CAR-CONS,
      and unfolding the definitions of CDR, CAR, and PAIRLIST, to:

            T.

  Case 1.14.
          (IMPLIES (AND (NOT (LITATOM Z))
                        (LISTP Z)
                        (NOT (EQUAL (CAR Z) 'QUOTE))
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (EQUAL (CAR F)
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))),

    which again simplifies, unfolding the functions EQUAL and CAR, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))).

    This further simplifies, obviously, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  The
    result is:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAAR (PAIRLIST Y 0))
                        (NOT (CADR (PAIRLIST Y 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR Y)))
                   (NUMBERP (CADDR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y), D by (CONS X1 C) to eliminate (CDR D) and
    (CAR D), and C by (CONS D Z1) to eliminate (CAR C) and (CDR C).  This
    generates four new conjectures:

    Case 1.14.4.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAAR (PAIRLIST Y 0))
                          (NOT (CADR (PAIRLIST Y 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT (CAR Y)))
                     (NUMBERP (CADDR Y))),

      which finally simplifies, expanding the functions PAIRLIST, CAR, and CDR,
      to:

            T.

    Case 1.14.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAAR (PAIRLIST (CONS W D) 0))
                          (NOT (CADR (PAIRLIST (CONS W D) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CADR D))),

      which finally simplifies, appealing to the lemmas CDR-CONS and CAR-CONS,
      and expanding CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.14.2.
            (IMPLIES (AND (NOT (LISTP C))
                          (NUMBERP (EVAL$ T V A))
                          (CAAR (PAIRLIST (CONS W (CONS X1 C)) 0))
                          (NOT (CADR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CAR C))),

      which finally simplifies, applying CDR-CONS and CAR-CONS, and opening up
      the functions CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.14.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (CAAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                          0))
                          (NOT (CADR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                               0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP D)).

      However this finally simplifies, applying the lemmas CDR-CONS and
      CAR-CONS, and unfolding the definitions of CDR, CONS, CAR, and PAIRLIST,
      to:

            T.

  Case 1.13.
          (IMPLIES (AND (NOT (LITATOM Z))
                        (LISTP Z)
                        (NOT (EQUAL (CAR Z) 'QUOTE))
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (EQUAL (CAR F)
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))),

    which again simplifies, unfolding the definitions of EQUAL and CAR, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))).

    This further simplifies, clearly, to the new conjecture:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CADR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  We must
    thus prove the formula:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAAR (PAIRLIST Y 0))
                        (NOT (CADR (PAIRLIST Y 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR Y))
                   (NUMBERP (CADR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y) and D by (CONS C X1) to eliminate (CAR D)
    and (CDR D).  The result is three new conjectures:

    Case 1.13.3.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAAR (PAIRLIST Y 0))
                          (NOT (CADR (PAIRLIST Y 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (CAR Y))
                     (NUMBERP (CADR Y))),

      which finally simplifies, unfolding the functions PAIRLIST, CAR, and CDR,
      to:

            T.

    Case 1.13.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAAR (PAIRLIST (CONS W D) 0))
                          (NOT (CADR (PAIRLIST (CONS W D) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP (CAR D))),

      which finally simplifies, applying CDR-CONS and CAR-CONS, and opening up
      CDR, CAR, and PAIRLIST, to:

            T.

    Case 1.13.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (CAAR (PAIRLIST (CONS W (CONS C X1)) 0))
                          (NOT (CADR (PAIRLIST (CONS W (CONS C X1)) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP C)).

      But this finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      unfolding CDR, CAR, and PAIRLIST, to:

            T.

  Case 1.12.
          (IMPLIES (AND (NOT (LITATOM Z))
                        (LISTP Z)
                        (NOT (EQUAL (CAR Z) 'QUOTE))
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                              0)))
                        (EQUAL (CAR F)
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    This again simplifies, unfolding the functions EQUAL and CAR, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                              0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS W V) to
    eliminate (CDR Z) and (CAR Z).  The result is:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))).

    This further simplifies, obviously, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  The
    result is:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAAR (PAIRLIST Y 0)))
                        (NOT (CADDR (PAIRLIST Y 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR Y)))
                   (NUMBERP (CADDR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y), D by (CONS X1 C) to eliminate (CDR D) and
    (CAR D), and C by (CONS D Z1) to eliminate (CAR C) and (CDR C).  The
    result is four new conjectures:

    Case 1.12.4.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAAR (PAIRLIST Y 0)))
                          (NOT (CADDR (PAIRLIST Y 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT (CAR Y)))
                     (NUMBERP (CADDR Y))),

      which finally simplifies, opening up PAIRLIST and CAR, to:

            T.

    Case 1.12.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAAR (PAIRLIST (CONS W D) 0)))
                          (NOT (CADDR (PAIRLIST (CONS W D) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CADR D))),

      which finally simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
      opening up CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.12.2.
            (IMPLIES (AND (NOT (LISTP C))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAAR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                          (NOT (CADDR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CAR C))),

      which finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      opening up CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.12.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (NOT (CAAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                               0)))
                          (NOT (CADDR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                                0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP D)).

      However this finally simplifies, applying CDR-CONS and CAR-CONS, and
      unfolding the definitions of CDR, CONS, CAR, and PAIRLIST, to:

            T.

  Case 1.11.
          (IMPLIES (AND (NOT (LITATOM Z))
                        (LISTP Z)
                        (NOT (EQUAL (CAR Z) 'QUOTE))
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                              0)))
                        (EQUAL (CAR F)
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

    This again simplifies, unfolding the functions EQUAL and CAR, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                              0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))).

    This further simplifies, trivially, to the new formula:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (NOT (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  This
    generates the goal:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (NOT (CAAR (PAIRLIST Y 0)))
                        (NOT (CADDR (PAIRLIST Y 0)))
                        (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                        (CAR Y))
                   (NUMBERP (CADR Y))).

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

    Case 1.11.3.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAAR (PAIRLIST Y 0)))
                          (NOT (CADDR (PAIRLIST Y 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          (CAR Y))
                     (NUMBERP (CADR Y))),

      which finally simplifies, opening up the definitions of PAIRLIST and CAR,
      to:

            T.

    Case 1.11.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (NOT (CAAR (PAIRLIST (CONS W D) 0)))
                          (NOT (CADDR (PAIRLIST (CONS W D) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP (CAR D))),

      which finally simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
      expanding the functions CDR, CAR, and PAIRLIST, to:

            T.

    Case 1.11.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (NOT (CAAR (PAIRLIST (CONS W (CONS C X1)) 0)))
                          (NOT (CADDR (PAIRLIST (CONS W (CONS C X1)) 0)))
                          (EQUAL 0 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP C)),

      which finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      unfolding the definitions of CDR, CAR, and PAIRLIST, to:

            T.

  Case 1.10.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (NOT (EQUAL (CAR Z) 'IF))
            (NOT (MEMBER F
                         (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                   0)))
            (NOT (SUBRP (CAR Z)))
            (V&C$ T
                  (BODY (CAR Z))
                  (PAIRLIST (FORMALS (CAR Z))
                            (STRIP-CARS (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                  0))))
            (EQUAL
             (CAR
              (CONS
               (CAR
                 (V&C$ T
                       (BODY (CAR Z))
                       (PAIRLIST (FORMALS (CAR Z))
                                 (STRIP-CARS (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0)))))
               (ADD1
                (PLUS
                 (SUM-CDRS (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                 (CDR
                  (V&C$ T
                       (BODY (CAR Z))
                       (PAIRLIST (FORMALS (CAR Z))
                                 (STRIP-CARS (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0)))))))))
             (EVAL$ T (PLUS-TREE X) A)))
           (NUMBERP
            (CAR (V&C$ T
                       (BODY (CAR Z))
                       (PAIRLIST (FORMALS (CAR Z))
                                 (STRIP-CARS (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0))))))).

    However this again simplifies, applying the lemmas CAR-CONS and
    NUMBERP-EVAL$-PLUS-TREE, to:

          T.

  Case 1.9.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (NOT (EQUAL (CAR Z) 'IF))
            (NOT (MEMBER F
                         (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                   0)))
            (SUBRP (CAR Z))
            (EQUAL
             (CAR
               (CONS (APPLY-SUBR (CAR Z)
                                 (STRIP-CARS (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0)))
                     (ADD1 (SUM-CDRS (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                               0)))))
             (EVAL$ T (PLUS-TREE X) A)))
           (NUMBERP (APPLY-SUBR (CAR Z)
                                (STRIP-CARS (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                      0))))),

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

          T.

  Case 1.8.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                 0)))
            (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                          0))))
            (EQUAL
              (CAR (CONS (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                         (ADD1 (PLUS 0
                                     (CDADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0))))))
              (EVAL$ T (PLUS-TREE X) A))
            (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
           (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    But this again simplifies, applying CAR-CONS, and opening up the functions
    EQUAL and PLUS, to the new formula:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                      0))))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    Applying the lemma CAR-CDR-ELIM, replace Z by (CONS W V) to eliminate
    (CDR Z) and (CAR Z).  We would thus like to prove:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which further simplifies, obviously, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  This
    generates the conjecture:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (NOT (CAAR (PAIRLIST Y 0)))
                        (CADDR (PAIRLIST Y 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                        (EQUAL (CAADDR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR Y)))
                   (NUMBERP (CADDR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y), D by (CONS X1 C) to eliminate (CDR D) and
    (CAR D), and C by (CONS D Z1) to eliminate (CAR C) and (CDR C).  This
    generates four new conjectures:

    Case 1.8.4.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (NOT (CAAR (PAIRLIST Y 0)))
                          (CADDR (PAIRLIST Y 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                          (EQUAL (CAADDR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT (CAR Y)))
                     (NUMBERP (CADDR Y))),

      which finally simplifies, unfolding the definitions of PAIRLIST and CAR,
      to:

            T.

    Case 1.8.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (NOT (CAAR (PAIRLIST (CONS W D) 0)))
                          (CADDR (PAIRLIST (CONS W D) 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST (CONS W D) 0))))
                          (EQUAL (CAADDR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CADR D))),

      which finally simplifies, rewriting with the lemmas CDR-CONS and
      CAR-CONS, and unfolding the definitions of CDR, CONS, CAR, PAIRLIST, and
      NUMBERP, to:

            T.

    Case 1.8.2.
            (IMPLIES
                  (AND (NOT (LISTP C))
                       (NUMBERP (EVAL$ T V A))
                       (CAR (PAIRLIST (CONS W (CONS X1 C)) 0))
                       (NOT (CAAR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                       (CADDR (PAIRLIST (CONS W (CONS X1 C)) 0))
                       (NOT (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 C)) 0))))
                       (EQUAL (CAADDR (PAIRLIST (CONS W (CONS X1 C)) 0))
                              (EVAL$ T (PLUS-TREE X) A))
                       (NOT W))
                  (NUMBERP (CAR C))),

      which finally simplifies, applying CDR-CONS and CAR-CONS, and unfolding
      CDR, CONS, CAR, PAIRLIST, and NUMBERP, to:

            T.

    Case 1.8.1.
            (IMPLIES
              (AND (NUMBERP (EVAL$ T V A))
                   (CAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                  0))
                   (NOT (CAAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                        0)))
                   (CADDR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                    0))
                   (NOT (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                                 0))))
                   (EQUAL (CAADDR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                            0))
                          (EVAL$ T (PLUS-TREE X) A))
                   (NOT W))
              (NUMBERP D)).

      But this finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      opening up CDR, CONS, CAR, PAIRLIST, and NUMBERP, to:

            T.

  Case 1.7.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                 0)))
            (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                          0))))
            (EQUAL
              (CAR (CONS (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                         (ADD1 (PLUS 0
                                     (CDADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0))))))
              (EVAL$ T (PLUS-TREE X) A))
            (CAR (EVAL$ 'LIST (CDR Z) A)))
           (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

    This again simplifies, rewriting with the lemma CAR-CONS, and opening up
    EQUAL and PLUS, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                      0))))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))).

    This further simplifies, obviously, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  This
    generates:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (NOT (CAAR (PAIRLIST Y 0)))
                        (CADDR (PAIRLIST Y 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                        (EQUAL (CAADDR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR Y))
                   (NUMBERP (CADR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y) and D by (CONS C X1) to eliminate (CAR D)
    and (CDR D).  This generates three new goals:

    Case 1.7.3.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (NOT (CAAR (PAIRLIST Y 0)))
                          (CADDR (PAIRLIST Y 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                          (EQUAL (CAADDR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (CAR Y))
                     (NUMBERP (CADR Y))),

      which finally simplifies, unfolding PAIRLIST and CAR, to:

            T.

    Case 1.7.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (NOT (CAAR (PAIRLIST (CONS W D) 0)))
                          (CADDR (PAIRLIST (CONS W D) 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST (CONS W D) 0))))
                          (EQUAL (CAADDR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP (CAR D))),

      which finally simplifies, applying CDR-CONS and CAR-CONS, and expanding
      the functions CDR, CAR, and PAIRLIST, to:

            T.

    Case 1.7.1.
            (IMPLIES
                  (AND (NUMBERP (EVAL$ T V A))
                       (CAR (PAIRLIST (CONS W (CONS C X1)) 0))
                       (NOT (CAAR (PAIRLIST (CONS W (CONS C X1)) 0)))
                       (CADDR (PAIRLIST (CONS W (CONS C X1)) 0))
                       (NOT (NUMBERP (CDAR (PAIRLIST (CONS W (CONS C X1)) 0))))
                       (EQUAL (CAADDR (PAIRLIST (CONS W (CONS C X1)) 0))
                              (EVAL$ T (PLUS-TREE X) A))
                       W)
                  (NUMBERP C)).

      However this finally simplifies, rewriting with CDR-CONS and CAR-CONS,
      and opening up the definitions of CDR, CAR, and PAIRLIST, to:

            T.

  Case 1.6.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                 0)))
            (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                     0)))
            (EQUAL
             (CAR
                 (CONS (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                       (ADD1 (PLUS (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                                   (CDADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                     0))))))
             (EVAL$ T (PLUS-TREE X) A))
            (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
           (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    But this again simplifies, applying CAR-CONS, and unfolding EQUAL, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                 0)))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    Applying the lemma CAR-CDR-ELIM, replace Z by (CONS W V) to eliminate
    (CDR Z) and (CAR Z).  We thus obtain:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which further simplifies, clearly, to the new goal:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  This
    generates:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (NOT (CAAR (PAIRLIST Y 0)))
                        (CADDR (PAIRLIST Y 0))
                        (NUMBERP (CDAR (PAIRLIST Y 0)))
                        (EQUAL (CAADDR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR Y)))
                   (NUMBERP (CADDR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y), D by (CONS X1 C) to eliminate (CDR D) and
    (CAR D), and C by (CONS D Z1) to eliminate (CAR C) and (CDR C).  The
    result is four new formulas:

    Case 1.6.4.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (NOT (CAAR (PAIRLIST Y 0)))
                          (CADDR (PAIRLIST Y 0))
                          (NUMBERP (CDAR (PAIRLIST Y 0)))
                          (EQUAL (CAADDR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT (CAR Y)))
                     (NUMBERP (CADDR Y))),

      which finally simplifies, unfolding the definitions of PAIRLIST and CAR,
      to:

            T.

    Case 1.6.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (NOT (CAAR (PAIRLIST (CONS W D) 0)))
                          (CADDR (PAIRLIST (CONS W D) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W D) 0)))
                          (EQUAL (CAADDR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CADR D))),

      which finally simplifies, applying CDR-CONS, CAR-CONS, and CDR-NLISTP,
      and unfolding CDR, CONS, CAR, PAIRLIST, and NUMBERP, to:

            T.

    Case 1.6.2.
            (IMPLIES (AND (NOT (LISTP C))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W (CONS X1 C)) 0))
                          (NOT (CAAR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                          (CADDR (PAIRLIST (CONS W (CONS X1 C)) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                          (EQUAL (CAADDR (PAIRLIST (CONS W (CONS X1 C)) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CAR C))).

      This finally simplifies, rewriting with CDR-CONS, CAR-CONS, and
      CAR-NLISTP, and expanding the definitions of CDR, CONS, CAR, PAIRLIST,
      and NUMBERP, to:

            T.

    Case 1.6.1.
            (IMPLIES
                   (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                       0))
                        (NOT (CAAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                             0)))
                        (CADDR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                         0))
                        (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                                 0)))
                        (EQUAL (CAADDR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                                 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT W))
                   (NUMBERP D)).

      But this further simplifies, appealing to the lemmas CDR-CONS and
      CAR-CONS, and unfolding the definitions of CDR, CONS, CAR, PAIRLIST, and
      NUMBERP, to:

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

      This finally simplifies, appealing to the lemma NUMBERP-EVAL$-PLUS-TREE,
      to:

            T.

  Case 1.5.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                 0)))
            (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                     0)))
            (EQUAL
             (CAR
                 (CONS (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                       (ADD1 (PLUS (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                                   (CDADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                     0))))))
             (EVAL$ T (PLUS-TREE X) A))
            (CAR (EVAL$ 'LIST (CDR Z) A)))
           (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))),

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

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                             0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                 0)))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which further simplifies, obviously, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (CADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADDR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  The
    result is:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (NOT (CAAR (PAIRLIST Y 0)))
                        (CADDR (PAIRLIST Y 0))
                        (NUMBERP (CDAR (PAIRLIST Y 0)))
                        (EQUAL (CAADDR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR Y))
                   (NUMBERP (CADR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y) and D by (CONS C X1) to eliminate (CAR D)
    and (CDR D).  The result is three new conjectures:

    Case 1.5.3.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (NOT (CAAR (PAIRLIST Y 0)))
                          (CADDR (PAIRLIST Y 0))
                          (NUMBERP (CDAR (PAIRLIST Y 0)))
                          (EQUAL (CAADDR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (CAR Y))
                     (NUMBERP (CADR Y))),

      which finally simplifies, opening up the functions PAIRLIST and CAR, to:

            T.

    Case 1.5.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (NOT (CAAR (PAIRLIST (CONS W D) 0)))
                          (CADDR (PAIRLIST (CONS W D) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W D) 0)))
                          (EQUAL (CAADDR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP (CAR D))),

      which finally simplifies, applying CDR-CONS and CAR-CONS, and unfolding
      the definitions of CDR, CAR, and PAIRLIST, to:

            T.

    Case 1.5.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W (CONS C X1)) 0))
                          (NOT (CAAR (PAIRLIST (CONS W (CONS C X1)) 0)))
                          (CADDR (PAIRLIST (CONS W (CONS C X1)) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W (CONS C X1)) 0)))
                          (EQUAL (CAADDR (PAIRLIST (CONS W (CONS C X1)) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP C)).

      This finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      expanding the definitions of CDR, CAR, and PAIRLIST, to:

            T.

  Case 1.4.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                          0))))
            (EQUAL
               (CAR (CONS (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                          (ADD1 (PLUS 0
                                      (CDADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0))))))
               (EVAL$ T (PLUS-TREE X) A))
            (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
           (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    However this again simplifies, applying CAR-CONS, and opening up the
    definitions of EQUAL and PLUS, to the new conjecture:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                      0))))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which further simplifies, trivially, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  This
    generates the goal:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (CAAR (PAIRLIST Y 0))
                        (CADR (PAIRLIST Y 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                        (EQUAL (CAADR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR Y)))
                   (NUMBERP (CADDR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y), D by (CONS X1 C) to eliminate (CDR D) and
    (CAR D), and C by (CONS D Z1) to eliminate (CAR C) and (CDR C).  The
    result is four new formulas:

    Case 1.4.4.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (CAAR (PAIRLIST Y 0))
                          (CADR (PAIRLIST Y 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                          (EQUAL (CAADR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT (CAR Y)))
                     (NUMBERP (CADDR Y))),

      which finally simplifies, opening up the definitions of PAIRLIST, CAR,
      CDR, and NUMBERP, to:

            T.

    Case 1.4.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (CAAR (PAIRLIST (CONS W D) 0))
                          (CADR (PAIRLIST (CONS W D) 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST (CONS W D) 0))))
                          (EQUAL (CAADR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CADR D))),

      which finally simplifies, applying CDR-CONS and CAR-CONS, and unfolding
      the functions CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.4.2.
            (IMPLIES
                  (AND (NOT (LISTP C))
                       (NUMBERP (EVAL$ T V A))
                       (CAR (PAIRLIST (CONS W (CONS X1 C)) 0))
                       (CAAR (PAIRLIST (CONS W (CONS X1 C)) 0))
                       (CADR (PAIRLIST (CONS W (CONS X1 C)) 0))
                       (NOT (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 C)) 0))))
                       (EQUAL (CAADR (PAIRLIST (CONS W (CONS X1 C)) 0))
                              (EVAL$ T (PLUS-TREE X) A))
                       (NOT W))
                  (NUMBERP (CAR C))).

      However this finally simplifies, applying CDR-CONS and CAR-CONS, and
      unfolding the functions CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.4.1.
            (IMPLIES
              (AND (NUMBERP (EVAL$ T V A))
                   (CAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                  0))
                   (CAAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                   0))
                   (CADR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                   0))
                   (NOT (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                                 0))))
                   (EQUAL (CAADR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                           0))
                          (EVAL$ T (PLUS-TREE X) A))
                   (NOT W))
              (NUMBERP D)).

      This finally simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
      opening up the definitions of CDR, CONS, CAR, and PAIRLIST, to:

            T.

  Case 1.3.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                          0))))
            (EQUAL
               (CAR (CONS (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                          (ADD1 (PLUS 0
                                      (CDADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                       0))))))
               (EVAL$ T (PLUS-TREE X) A))
            (CAR (EVAL$ 'LIST (CDR Z) A)))
           (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))),

    which again simplifies, applying CAR-CONS, and unfolding EQUAL and PLUS,
    to the new conjecture:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                      0))))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which further simplifies, clearly, to the new conjecture:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0))))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  We must
    thus prove:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (CAAR (PAIRLIST Y 0))
                        (CADR (PAIRLIST Y 0))
                        (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                        (EQUAL (CAADR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR Y))
                   (NUMBERP (CADR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y) and D by (CONS C X1) to eliminate (CAR D)
    and (CDR D).  We must thus prove three new conjectures:

    Case 1.3.3.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (CAAR (PAIRLIST Y 0))
                          (CADR (PAIRLIST Y 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST Y 0))))
                          (EQUAL (CAADR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (CAR Y))
                     (NUMBERP (CADR Y))),

      which finally simplifies, expanding the definitions of PAIRLIST, CAR,
      CDR, and NUMBERP, to:

            T.

    Case 1.3.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (CAAR (PAIRLIST (CONS W D) 0))
                          (CADR (PAIRLIST (CONS W D) 0))
                          (NOT (NUMBERP (CDAR (PAIRLIST (CONS W D) 0))))
                          (EQUAL (CAADR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP (CAR D))),

      which finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      expanding the definitions of CDR, CAR, PAIRLIST, and NUMBERP, to:

            T.

    Case 1.3.1.
            (IMPLIES
                  (AND (NUMBERP (EVAL$ T V A))
                       (CAR (PAIRLIST (CONS W (CONS C X1)) 0))
                       (CAAR (PAIRLIST (CONS W (CONS C X1)) 0))
                       (CADR (PAIRLIST (CONS W (CONS C X1)) 0))
                       (NOT (NUMBERP (CDAR (PAIRLIST (CONS W (CONS C X1)) 0))))
                       (EQUAL (CAADR (PAIRLIST (CONS W (CONS C X1)) 0))
                              (EVAL$ T (PLUS-TREE X) A))
                       W)
                  (NUMBERP C)).

      However this finally simplifies, rewriting with CDR-CONS and CAR-CONS,
      and expanding the functions CDR, CAR, PAIRLIST, and NUMBERP, to:

            T.

  Case 1.2.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                     0)))
            (EQUAL
             (CAR
                 (CONS (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                       (ADD1 (PLUS (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                                   (CDADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                    0))))))
             (EVAL$ T (PLUS-TREE X) A))
            (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
           (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

    But this again simplifies, rewriting with CAR-CONS, and opening up the
    definition of EQUAL, to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                 0)))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST (CDR Z) A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST (CDR Z) A)))).

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

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which further simplifies, clearly, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR (EVAL$ 'LIST V A))))
                   (NUMBERP (CADDR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  This
    generates:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (CAAR (PAIRLIST Y 0))
                        (CADR (PAIRLIST Y 0))
                        (NUMBERP (CDAR (PAIRLIST Y 0)))
                        (EQUAL (CAADR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT (CAR Y)))
                   (NUMBERP (CADDR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y), D by (CONS X1 C) to eliminate (CDR D) and
    (CAR D), and C by (CONS D Z1) to eliminate (CAR C) and (CDR C).  The
    result is four new goals:

    Case 1.2.4.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (CAAR (PAIRLIST Y 0))
                          (CADR (PAIRLIST Y 0))
                          (NUMBERP (CDAR (PAIRLIST Y 0)))
                          (EQUAL (CAADR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT (CAR Y)))
                     (NUMBERP (CADDR Y))),

      which finally simplifies, appealing to the lemma CAR-NLISTP, and
      expanding PAIRLIST, CAR, CDR, and NUMBERP, to:

            T.

    Case 1.2.3.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (CAAR (PAIRLIST (CONS W D) 0))
                          (CADR (PAIRLIST (CONS W D) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W D) 0)))
                          (EQUAL (CAADR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CADR D))),

      which finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      opening up the definitions of CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.2.2.
            (IMPLIES (AND (NOT (LISTP C))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W (CONS X1 C)) 0))
                          (CAAR (PAIRLIST (CONS W (CONS X1 C)) 0))
                          (CADR (PAIRLIST (CONS W (CONS X1 C)) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 C)) 0)))
                          (EQUAL (CAADR (PAIRLIST (CONS W (CONS X1 C)) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (NOT W))
                     (NUMBERP (CAR C))).

      This finally simplifies, applying CDR-CONS and CAR-CONS, and unfolding
      the functions CDR, CONS, CAR, and PAIRLIST, to:

            T.

    Case 1.2.1.
            (IMPLIES
                   (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                       0))
                        (CAAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                        0))
                        (CADR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                        0))
                        (NUMBERP (CDAR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                                 0)))
                        (EQUAL (CAADR (PAIRLIST (CONS W (CONS X1 (CONS D Z1)))
                                                0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (NOT W))
                   (NUMBERP D)).

      But this finally simplifies, rewriting with CDR-CONS and CAR-CONS, and
      expanding the definitions of CDR, CONS, CAR, and PAIRLIST, to:

            T.

  Case 1.1.
          (IMPLIES
           (AND
            (NOT (LITATOM Z))
            (LISTP Z)
            (NOT (EQUAL (CAR Z) 'QUOTE))
            (NUMBERP (EVAL$ T (CDR Z) A))
            (EQUAL (CAR Z) 'IF)
            (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
            (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                     0)))
            (EQUAL
             (CAR
                 (CONS (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                       (ADD1 (PLUS (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                                   (CDADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                    0))))))
             (EVAL$ T (PLUS-TREE X) A))
            (CAR (EVAL$ 'LIST (CDR Z) A)))
           (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

    But this again simplifies, rewriting with CAR-CONS, and expanding EQUAL,
    to:

          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (EVAL$ T (CDR Z) A))
                        (EQUAL (CAR Z) 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST (CDR Z) A)
                                                 0)))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST (CDR Z) A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST (CDR Z) A)))
                   (NUMBERP (CADR (EVAL$ 'LIST (CDR Z) A)))).

    Applying the lemma CAR-CDR-ELIM, replace Z by (CONS W V) to eliminate
    (CDR Z) and (CAR Z).  We would thus like to prove the new conjecture:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (EQUAL W 'IF)
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which further simplifies, clearly, to:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CAAR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (CADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                        (NUMBERP (CDAR (PAIRLIST (EVAL$ 'LIST V A) 0)))
                        (EQUAL (CAADR (PAIRLIST (EVAL$ 'LIST V A) 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR (EVAL$ 'LIST V A)))
                   (NUMBERP (CADR (EVAL$ 'LIST V A)))),

    which we generalize by replacing (EVAL$ (QUOTE LIST) V A) by Y.  This
    generates the goal:

          (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                        (CAR (PAIRLIST Y 0))
                        (CAAR (PAIRLIST Y 0))
                        (CADR (PAIRLIST Y 0))
                        (NUMBERP (CDAR (PAIRLIST Y 0)))
                        (EQUAL (CAADR (PAIRLIST Y 0))
                               (EVAL$ T (PLUS-TREE X) A))
                        (CAR Y))
                   (NUMBERP (CADR Y))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Y by (CONS W D) to
    eliminate (CAR Y) and (CDR Y) and D by (CONS C X1) to eliminate (CAR D)
    and (CDR D).  We must thus prove three new conjectures:

    Case 1.1.3.
            (IMPLIES (AND (NOT (LISTP Y))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST Y 0))
                          (CAAR (PAIRLIST Y 0))
                          (CADR (PAIRLIST Y 0))
                          (NUMBERP (CDAR (PAIRLIST Y 0)))
                          (EQUAL (CAADR (PAIRLIST Y 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          (CAR Y))
                     (NUMBERP (CADR Y))),

      which finally simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
      opening up the definitions of PAIRLIST, CAR, CDR, and NUMBERP, to:

            T.

    Case 1.1.2.
            (IMPLIES (AND (NOT (LISTP D))
                          (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W D) 0))
                          (CAAR (PAIRLIST (CONS W D) 0))
                          (CADR (PAIRLIST (CONS W D) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W D) 0)))
                          (EQUAL (CAADR (PAIRLIST (CONS W D) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP (CAR D))).

      This finally simplifies, rewriting with CDR-CONS, CAR-CONS, and
      CAR-NLISTP, and expanding the functions CDR, CAR, PAIRLIST, and NUMBERP,
      to:

            T.

    Case 1.1.1.
            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (CAR (PAIRLIST (CONS W (CONS C X1)) 0))
                          (CAAR (PAIRLIST (CONS W (CONS C X1)) 0))
                          (CADR (PAIRLIST (CONS W (CONS C X1)) 0))
                          (NUMBERP (CDAR (PAIRLIST (CONS W (CONS C X1)) 0)))
                          (EQUAL (CAADR (PAIRLIST (CONS W (CONS C X1)) 0))
                                 (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP C)).

      However this further simplifies, appealing to the lemmas CDR-CONS and
      CAR-CONS, and unfolding CDR, CAR, PAIRLIST, and NUMBERP, to:

            (IMPLIES (AND (NUMBERP (EVAL$ T V A))
                          (EQUAL C (EVAL$ T (PLUS-TREE X) A))
                          W)
                     (NUMBERP C)).

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

            T.


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


[ 0.0 3.8 0.3 ]

NUMBERP-EVAL$-BRIDGE


(TOGGLE NUMBERP-EVAL$-BRIDGE-OFF NUMBERP-EVAL$-BRIDGE T)

[ 0.0 0.0 0.0 ]

NUMBERP-EVAL$-BRIDGE-OFF


(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))
             ((ENABLE SUBBAGP PLUS-FRINGE PLUS-TREE
                      SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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

      T.

Q.E.D.


[ 0.0 0.3 0.0 ]

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

(TOGGLE BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP-OFF
        BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP T)

[ 0.0 0.0 0.0 ]

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

(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)))
             ((ENABLE PLUS-ZERO-ARG2 COMMUTATIVITY2-OF-PLUS
                      COMMUTATIVITY-OF-PLUS EQUAL-PLUS-0 PLUS-CANCELLATION
                      PLUS-TREE NUMBERP-EVAL$-PLUS-TREE NUMBERP-EVAL$-BRIDGE)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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,
    EQUAL-PLUS-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
      PLUS-ZERO-ARG2, and opening up PLUS and ZEROP, 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 PLUS-ZERO-ARG2, and expanding APPEND,
      PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, and ZEROP, 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
      PLUS-ZERO-ARG2, and unfolding APPEND, PLUS-TREE, CDR, CAR, LISTP,
      LITATOM, EQUAL, EVAL$, and ZEROP, 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-ZERO-ARG2, and opening up the definitions of PLUS-TREE,
    FIX, and ZEROP, 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 PLUS-ZERO-ARG2, and expanding the functions PLUS and ZEROP, 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,
      PLUS-ZERO-ARG2, REWRITE-EVAL$, CAR-CONS, and NUMBERP-EVAL$-BRIDGE, and
      opening up APPEND, PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$,
      ZEROP, 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,
      PLUS-ZERO-ARG2, REWRITE-EVAL$, CAR-CONS, and NUMBERP-EVAL$-BRIDGE, and
      opening up the functions APPEND, PLUS-TREE, CDR, CAR, LISTP, LITATOM,
      EQUAL, EVAL$, ZEROP, 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,
    EQUAL-PLUS-0, REWRITE-EVAL$, CAR-CONS, CDR-CONS, and PLUS-ZERO-ARG2, and
    expanding PLUS-TREE, CDR, CAR, LISTP, LITATOM, EQUAL, EVAL$, FIX, ZEROP,
    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-ZERO-ARG2, and COMMUTATIVITY2-OF-PLUS, and expanding the definitions
    of PLUS-TREE, FIX, and ZEROP, 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,
    EQUAL-PLUS-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, and
      PLUS-ZERO-ARG2, and unfolding the functions PLUS-TREE, FIX, and ZEROP,
      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, and PLUS-ZERO-ARG2, and expanding PLUS-TREE, FIX,
    and ZEROP, 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-ZERO-ARG2, COMMUTATIVITY2-OF-PLUS, and
    PLUS-CANCELLATION, and expanding PLUS-TREE, FIX, and ZEROP, 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
      EQUAL-PLUS-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
      EQUAL-PLUS-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 PLUS-ZERO-ARG2, and expanding PLUS-TREE, FIX, NUMBERP,
        and ZEROP, 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, and PLUS-ZERO-ARG2, and unfolding the
      definitions of PLUS-TREE, FIX, and ZEROP, 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 5.8 0.0 ]

EVAL$-PLUS-TREE-APPEND


(TOGGLE EVAL$-PLUS-TREE-APPEND-OFF EVAL$-PLUS-TREE-APPEND T)

[ 0.0 0.0 0.0 ]

EVAL$-PLUS-TREE-APPEND-OFF


(PROVE-LEMMA PLUS-TREE-PLUS-FRINGE
             (REWRITE)
             (EQUAL (EVAL$ T
                           (PLUS-TREE (PLUS-FRINGE X))
                           A)
                    (FIX (EVAL$ T X A)))
             ((ENABLE PLUS-ZERO-ARG2 COMMUTATIVITY-OF-PLUS PLUS-FRINGE
                      PLUS-TREE NUMBERP-EVAL$-PLUS NUMBERP-EVAL$-BRIDGE
                      EVAL$-PLUS-TREE-APPEND)
              (INDUCT (PLUS-FRINGE X))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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 PLUS-ZERO-ARG2, and unfolding the definitions of FIX, EQUAL, PLUS-FRINGE,
  PLUS, and ZEROP, 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-ZERO-ARG2, and expanding the definitions of ZEROP and
      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-ZERO-ARG2, and
      opening up ZEROP, 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).  This produces 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 opening up the definitions of CAR,
      CONS, LISTP, PLUS-FRINGE, CDR, PLUS-TREE, 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, appealing to the lemmas CAR-NLISTP,
      REWRITE-EVAL$, CAR-CONS, CDR-CONS, and PLUS-ZERO-ARG2, and opening up
      the definitions of CONS, LISTP, PLUS-FRINGE, CAR, CDR, PLUS-TREE,
      LITATOM, EQUAL, EVAL$, FIX, and ZEROP, 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))),

      which further simplifies, rewriting with REWRITE-EVAL$, CAR-CONS,
      CDR-CONS, and NUMBERP-EVAL$-BRIDGE, and opening up the function 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))).

    However this again simplifies, applying NUMBERP-EVAL$-BRIDGE, to the new
    formula:

          (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 thus obtain 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))).

      However this further simplifies, rewriting with CDR-NLISTP,
      REWRITE-EVAL$, and CAR-NLISTP, and expanding CAR, CONS, LISTP,
      PLUS-FRINGE, CDR, PLUS-TREE, 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))).

      This further simplifies, rewriting with CAR-NLISTP, REWRITE-EVAL$,
      NUMBERP-EVAL$-BRIDGE, PLUS-ZERO-ARG2, CAR-CONS, and CDR-CONS, and
      expanding the functions CONS, LISTP, PLUS-FRINGE, CAR, CDR, PLUS-TREE,
      LITATOM, EQUAL, EVAL$, FIX, and ZEROP, 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))).

      This further simplifies, applying 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)))).

  This simplifies, applying the lemmas CAR-CONS, CDR-CONS, and REWRITE-EVAL$,
  and expanding the definitions of AND, PLUS-FRINGE, LISTP, PLUS-TREE, EQUAL,
  EVAL$, and FIX, to:

        T.

Q.E.D.


[ 0.0 2.3 0.0 ]

PLUS-TREE-PLUS-FRINGE


(TOGGLE PLUS-TREE-PLUS-FRINGE-OFF PLUS-TREE-PLUS-FRINGE T)

[ 0.0 0.0 0.0 ]

PLUS-TREE-PLUS-FRINGE-OFF


(PROVE-LEMMA MEMBER-IMPLIES-NUMBERP
             (REWRITE)
             (IMPLIES (AND (MEMBER C (PLUS-FRINGE X))
                           (NUMBERP (EVAL$ T C A)))
                      (NUMBERP (EVAL$ T X A)))
             ((ENABLE PLUS-FRINGE NUMBERP-EVAL$-PLUS)
              (INDUCT (PLUS-FRINGE X))
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


(TOGGLE MEMBER-IMPLIES-NUMBERP-OFF MEMBER-IMPLIES-NUMBERP T)

[ 0.0 0.0 0.0 ]

MEMBER-IMPLIES-NUMBERP-OFF


(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)))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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.1 0.0 ]

CADR-EVAL$-LIST


(TOGGLE CADR-EVAL$-LIST-OFF CADR-EVAL$-LIST T)

[ 0.0 0.0 0.0 ]

CADR-EVAL$-LIST-OFF


(PROVE-LEMMA EVAL$-QUOTE
             (REWRITE)
             (EQUAL (EVAL$ T (CONS 'QUOTE ARGS) A)
                    (CAR ARGS))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

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


(TOGGLE EVAL$-QUOTE-OFF EVAL$-QUOTE T)

[ 0.0 0.0 0.0 ]

EVAL$-QUOTE-OFF


(PROVE-LEMMA LISTP-EVAL$
             (REWRITE)
             (EQUAL (LISTP (EVAL$ 'LIST X A))
                    (LISTP X))
             ((ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))


     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$


(TOGGLE LISTP-EVAL$-OFF LISTP-EVAL$ T)

[ 0.0 0.0 0.0 ]

LISTP-EVAL$-OFF


(DEFN CANCEL-EQUAL-PLUS
      (X)
      (IF (AND (LISTP X)
               (EQUAL (CAR X) 'EQUAL))
          (COND ((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)))))))
                ((AND (LISTP (CADR X))
                      (EQUAL (CAADR X) 'PLUS)
                      (MEMBER (CADDR X)
                              (PLUS-FRINGE (CADR X))))
                 (LIST 'IF
                       (LIST 'NUMBERP (CADDR X))
                       (CONS 'EQUAL
                             (CONS (PLUS-TREE (DELETE (CADDR X)
                                                      (PLUS-FRINGE (CADR X))))
                                   '('0)))
                       (LIST 'QUOTE F)))
                ((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)))
                (T X))
          X))

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




[ 0.0 0.0 0.0 ]

CANCEL-EQUAL-PLUS


(PROVE-LEMMA CORRECTNESS-OF-CANCEL-EQUAL-PLUS
             ((META EQUAL))
             (EQUAL (EVAL$ T X A)
                    (EVAL$ T (CANCEL-EQUAL-PLUS X) A))
             ((ENABLE BRIDGE-TO-SUBBAGP-IMPLIES-PLUS-TREE-GREATEREQP
                      CANCEL-EQUAL-PLUS DIFFERENCE-CANCELLATION
                      EQUAL-DIFFERENCE-0 EVAL$-QUOTE MEMBER-IMPLIES-NUMBERP
                      MEMBER-IMPLIES-PLUS-TREE-GREATEREQP NUMBERP-EVAL$-PLUS
                      PLUS-TREE-BAGDIFF PLUS-TREE-DELETE PLUS-TREE-PLUS-FRINGE
                      SUBBAGP-BAGINT1 SUBBAGP-BAGINT2)
              (DISABLE EVAL$)
              (ENABLE-THEORY GROUND-ZERO)
              (DISABLE-THEORY T)))

This formula simplifies, opening up the function CANCEL-EQUAL-PLUS, 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, 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$