(BOOT-STRAP)

[ 0.0 0.1 0.0 ]

GROUND-ZERO


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

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

(TOGGLE-DEFINED-FUNCTIONS TURN-OFF-LISP-DEFNS T)

[ 0.0 0.0 0.0 ]

TURN-OFF-LISP-DEFNS


(DEFN FUNCTION
      (FN)
      (EQUAL (CAR FN) 2))

     Observe that (OR (FALSEP (FUNCTION FN)) (TRUEP (FUNCTION FN))) is a
theorem.




[ 0.0 0.0 0.0 ]

FUNCTION


(DEFN VARIABLE (X) (NUMBERP X))

     Observe that (OR (FALSEP (VARIABLE X)) (TRUEP (VARIABLE X))) is a theorem.




[ 0.0 0.0 0.0 ]

VARIABLE


(DEFN PREDICATE (P) (EQUAL (CAR P) 3))

     Observe that (OR (FALSEP (PREDICATE P)) (TRUEP (PREDICATE P))) is a
theorem.




[ 0.0 0.0 0.0 ]

PREDICATE


(DEFN DEGREE (FN) (FIX (CDDR FN)))

     Note that (NUMBERP (DEGREE FN)) is a theorem.




[ 0.0 0.0 0.0 ]

DEGREE


(DEFN INDEX (FN) (FIX (CADR FN)))

     Note that (NUMBERP (INDEX FN)) is a theorem.




[ 0.0 0.0 0.0 ]

INDEX


(DEFN V (X) (FIX X))

     Observe that (NUMBERP (V X)) is a theorem.




[ 0.0 0.0 0.0 ]

V


(PROVE-LEMMA NUMBERP-FIX
             (REWRITE)
             (NUMBERP (FIX X)))

This simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NUMBERP-FIX


(PROVE-LEMMA VARIABLE-V
             (REWRITE)
             (VARIABLE (V X)))

WARNING:  Note that the rewrite rule VARIABLE-V will be stored so as to apply
only to terms with the nonrecursive function symbol VARIABLE.


This conjecture can be simplified, using the abbreviation VARIABLE, to the
goal:

      (NUMBERP (V X)).

This simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

VARIABLE-V


(DEFN FN
      (X Y)
      (CONS 2 (CONS (FIX X) (FIX Y))))

     Observe that (LISTP (FN X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

FN


(DEFN P
      (X Y)
      (CONS 3 (CONS (FIX X) (FIX Y))))

     Observe that (LISTP (P X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

P


(PROVE-LEMMA FUNCTION-FN
             (REWRITE)
             (FUNCTION (FN X Y)))

WARNING:  Note that the rewrite rule FUNCTION-FN will be stored so as to apply
only to terms with the nonrecursive function symbol FUNCTION.


This formula can be simplified, using the abbreviation FUNCTION, to the new
formula:

      (EQUAL (CAR (FN X Y)) 2),

which simplifies, expanding the function FN, to four new conjectures:

Case 4. (IMPLIES (AND (NOT (NUMBERP X)) (NUMBERP Y))
                 (EQUAL (CAR (CONS 2 (CONS 0 Y))) 2)),

  which again simplifies, rewriting with the lemma CAR-CONS, and opening up
  EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NUMBERP X))
                      (NOT (NUMBERP Y)))
                 (EQUAL (CAR '(2 0 . 0)) 2)),

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

        T.

Case 2. (IMPLIES (AND (NUMBERP X) (NUMBERP Y))
                 (EQUAL (CAR (CONS 2 (CONS X Y))) 2)),

  which again simplifies, applying the lemma CAR-CONS, and expanding EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X) (NOT (NUMBERP Y)))
                 (EQUAL (CAR (CONS 2 (CONS X 0))) 2)),

  which again simplifies, applying CAR-CONS, and opening up EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FUNCTION-FN


(PROVE-LEMMA PREDICATE-P
             (REWRITE)
             (PREDICATE (P X Y)))

WARNING:  Note that the rewrite rule PREDICATE-P will be stored so as to apply
only to terms with the nonrecursive function symbol PREDICATE.


This formula can be simplified, using the abbreviation PREDICATE, to the new
formula:

      (EQUAL (CAR (P X Y)) 3),

which simplifies, expanding the function P, to four new conjectures:

Case 4. (IMPLIES (AND (NOT (NUMBERP X)) (NUMBERP Y))
                 (EQUAL (CAR (CONS 3 (CONS 0 Y))) 3)),

  which again simplifies, rewriting with the lemma CAR-CONS, and opening up
  EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NUMBERP X))
                      (NOT (NUMBERP Y)))
                 (EQUAL (CAR '(3 0 . 0)) 3)),

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

        T.

Case 2. (IMPLIES (AND (NUMBERP X) (NUMBERP Y))
                 (EQUAL (CAR (CONS 3 (CONS X Y))) 3)),

  which again simplifies, applying the lemma CAR-CONS, and expanding EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X) (NOT (NUMBERP Y)))
                 (EQUAL (CAR (CONS 3 (CONS X 0))) 3)),

  which again simplifies, applying CAR-CONS, and opening up EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PREDICATE-P


(ADD-SHELL F-NOT NIL F-NOTP
           ((ARG (NONE-OF) ZERO)))

[ 0.0 0.0 0.0 ]

F-NOT


(ADD-SHELL F-OR NIL F-ORP
           ((ARG1 (NONE-OF) ZERO)
            (ARG2 (NONE-OF) ZERO)))

[ 0.0 0.0 0.0 ]

F-OR


(ADD-SHELL FORSOME NIL FORSOMEP
           ((BIND (ONE-OF NUMBERP) ZERO)
            (BODY (NONE-OF) ZERO)))

[ 0.0 0.0 0.0 ]

FORSOME


(DEFN FIX1 (X) (IF (NUMBERP X) X NIL))

     Note that (OR (NUMBERP (FIX1 X)) (LITATOM (FIX1 X))) is a theorem.




[ 0.0 0.0 0.0 ]

FIX1


(PROVE-LEMMA BIND-COUNT
             (REWRITE)
             (IMPLIES (FORSOMEP X)
                      (LESSP (COUNT (BIND X)) (COUNT X))))

WARNING:  Note that the proposed lemma BIND-COUNT is to be stored as zero type
prescription rules, zero compound recognizer rules, one linear rule, and zero
replacement rules.


This formula simplifies, applying COUNT-NUMBERP, to the new conjecture:

      (IMPLIES (FORSOMEP X)
               (LESSP (BIND X) (COUNT X))).

Applying the lemma BIND-BODY-ELIM, replace X by (FORSOME Z V) to eliminate
(BIND X) and (BODY X).  We use the type restriction lemma noted when BIND was
introduced to restrict the new variables.  We would thus like to prove:

      (IMPLIES (NUMBERP Z)
               (LESSP Z (COUNT (FORSOME Z V)))),

which further simplifies, appealing to the lemmas COUNT-NUMBERP, COUNT-FORSOME,
and SUB1-ADD1, and unfolding the definition of LESSP, to the formula:

      (IMPLIES (AND (NUMBERP Z) (NOT (EQUAL Z 0)))
               (LESSP (SUB1 Z) (PLUS Z (COUNT V)))).

But this again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

BIND-COUNT


(DEFN EQL
      (X Y)
      (IF (LISTP X)
          (IF (LISTP Y)
              (AND (EQL (CAR X) (CAR Y))
                   (EQL (CDR X) (CDR Y)))
              F)
          (IF (LISTP Y)
              F
              (IF (F-NOTP X)
                  (IF (F-NOTP Y)
                      (EQL (ARG X) (ARG Y))
                      F)
                  (IF (F-NOTP Y)
                      F
                      (IF (F-ORP X)
                          (IF (F-ORP Y)
                              (AND (EQL (ARG1 X) (ARG1 Y))
                                   (EQL (ARG2 X) (ARG2 Y)))
                              F)
                          (IF (F-ORP Y)
                              F
                              (IF (FORSOMEP X)
                                  (IF (FORSOMEP Y)
                                      (AND (EQUAL (BIND X) (BIND Y))
                                           (EQL (BODY X) (BODY Y)))
                                      F)
                                  (IF (FORSOMEP Y)
                                      F
                                      (EQUAL (FIX1 X) (FIX1 Y)))))))))))

     Linear arithmetic and the lemmas CDR-LESSP, CAR-LESSP, ARG-LESSP,
ARG2-LESSP, ARG1-LESSP, and BODY-LESSP can be used to prove that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, EQL is accepted under the definitional principle.  The
definition of EQL can be justified in another way.  Linear arithmetic and the
lemmas CDR-LESSP, CAR-LESSP, ARG-LESSP, ARG2-LESSP, ARG1-LESSP, and BODY-LESSP
can be used to show that the measure (COUNT Y) decreases according to the
well-founded relation LESSP in each recursive call.  From the definition we
can conclude that (OR (FALSEP (EQL X Y)) (TRUEP (EQL X Y))) is a theorem.




[ 0.0 0.0 0.0 ]

EQL


(PROVE-LEMMA EQL-COMM
             (REWRITE)
             (EQUAL (EQL X Y) (EQL Y X)))


     Give the conjecture the name *1.


     We will appeal to 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 (AND (LISTP X)
                         (LISTP Y)
                         (p (CDR X) (CDR Y))
                         (p (CAR X) (CAR Y)))
                    (p X Y))
           (IMPLIES (AND (LISTP X) (NOT (LISTP Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X)) (LISTP Y))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (F-NOTP X)
                         (F-NOTP Y)
                         (p (ARG X) (ARG Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (F-NOTP X)
                         (NOT (F-NOTP Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (F-NOTP Y))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (NOT (F-NOTP Y))
                         (F-ORP X)
                         (F-ORP Y)
                         (p (ARG2 X) (ARG2 Y))
                         (p (ARG1 X) (ARG1 Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (NOT (F-NOTP Y))
                         (F-ORP X)
                         (NOT (F-ORP Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (NOT (F-NOTP Y))
                         (NOT (F-ORP X))
                         (F-ORP Y))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (NOT (F-NOTP Y))
                         (NOT (F-ORP X))
                         (NOT (F-ORP Y))
                         (FORSOMEP X)
                         (FORSOMEP Y)
                         (p (BODY X) (BODY Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (NOT (F-NOTP Y))
                         (NOT (F-ORP X))
                         (NOT (F-ORP Y))
                         (FORSOMEP X)
                         (NOT (FORSOMEP Y)))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (NOT (F-NOTP Y))
                         (NOT (F-ORP X))
                         (NOT (F-ORP Y))
                         (NOT (FORSOMEP X))
                         (FORSOMEP Y))
                    (p X Y))
           (IMPLIES (AND (NOT (LISTP X))
                         (NOT (LISTP Y))
                         (NOT (F-NOTP X))
                         (NOT (F-NOTP Y))
                         (NOT (F-ORP X))
                         (NOT (F-ORP Y))
                         (NOT (FORSOMEP X))
                         (NOT (FORSOMEP Y)))
                    (p X Y))).
Linear arithmetic and the lemmas CDR-LESSP, CAR-LESSP, ARG-LESSP, ARG2-LESSP,
ARG1-LESSP, and BODY-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 produces the following 13 new conjectures:

Case 13.(IMPLIES (AND (LISTP X)
                      (LISTP Y)
                      (EQUAL (EQL (CDR X) (CDR Y))
                             (EQL (CDR Y) (CDR X)))
                      (EQUAL (EQL (CAR X) (CAR Y))
                             (EQL (CAR Y) (CAR X))))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, expanding the function EQL, to:

        T.

Case 12.(IMPLIES (AND (LISTP X) (NOT (LISTP Y)))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, opening up EQL and EQUAL, to:

        T.

Case 11.(IMPLIES (AND (NOT (LISTP X)) (LISTP Y))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, unfolding the definitions of EQL and EQUAL, to:

        T.

Case 10.(IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (F-NOTP X)
                      (F-NOTP Y)
                      (EQUAL (EQL (ARG X) (ARG Y))
                             (EQL (ARG Y) (ARG X))))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, unfolding the definition of EQL, to:

        T.

Case 9. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (F-NOTP X)
                      (NOT (F-NOTP Y)))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, opening up the functions EQL and EQUAL, to:

        T.

Case 8. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (F-NOTP Y))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, opening up EQL and EQUAL, to:

        T.

Case 7. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (NOT (F-NOTP Y))
                      (F-ORP X)
                      (F-ORP Y)
                      (EQUAL (EQL (ARG2 X) (ARG2 Y))
                             (EQL (ARG2 Y) (ARG2 X)))
                      (EQUAL (EQL (ARG1 X) (ARG1 Y))
                             (EQL (ARG1 Y) (ARG1 X))))
                 (EQUAL (EQL X Y) (EQL Y X))).

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

        T.

Case 6. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (NOT (F-NOTP Y))
                      (F-ORP X)
                      (NOT (F-ORP Y)))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, expanding EQL and EQUAL, to:

        T.

Case 5. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (NOT (F-NOTP Y))
                      (NOT (F-ORP X))
                      (F-ORP Y))
                 (EQUAL (EQL X Y) (EQL Y X))).

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

        T.

Case 4. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (NOT (F-NOTP Y))
                      (NOT (F-ORP X))
                      (NOT (F-ORP Y))
                      (FORSOMEP X)
                      (FORSOMEP Y)
                      (EQUAL (EQL (BODY X) (BODY Y))
                             (EQL (BODY Y) (BODY X))))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, expanding the function EQL, to the following two new
  formulas:

  Case 4.2.
          (IMPLIES (AND (FORSOMEP X)
                        (FORSOMEP Y)
                        (EQUAL (EQL (BODY X) (BODY Y))
                               (EQL (BODY Y) (BODY X)))
                        (NOT (EQUAL (BIND Y) (BIND X)))
                        (EQUAL (BIND X) (BIND Y)))
                   (EQUAL (EQL (BODY X) (BODY Y)) F)).

    This again simplifies, obviously, to:

          T.

  Case 4.1.
          (IMPLIES (AND (FORSOMEP X)
                        (FORSOMEP Y)
                        (EQUAL (EQL (BODY X) (BODY Y))
                               (EQL (BODY Y) (BODY X)))
                        (EQUAL (BIND Y) (BIND X))
                        (NOT (EQUAL (BIND X) (BIND Y))))
                   (EQUAL F (EQL (BODY X) (BODY Y)))).

    This again simplifies, trivially, to:

          T.

Case 3. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (NOT (F-NOTP Y))
                      (NOT (F-ORP X))
                      (NOT (F-ORP Y))
                      (FORSOMEP X)
                      (NOT (FORSOMEP Y)))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, unfolding the functions EQL and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (NOT (F-NOTP Y))
                      (NOT (F-ORP X))
                      (NOT (F-ORP Y))
                      (NOT (FORSOMEP X))
                      (FORSOMEP Y))
                 (EQUAL (EQL X Y) (EQL Y X))).

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

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP Y))
                      (NOT (F-NOTP X))
                      (NOT (F-NOTP Y))
                      (NOT (F-ORP X))
                      (NOT (F-ORP Y))
                      (NOT (FORSOMEP X))
                      (NOT (FORSOMEP Y)))
                 (EQUAL (EQL X Y) (EQL Y X))).

  This simplifies, opening up EQL and FIX1, to the following six new formulas:

  Case 1.6.
          (IMPLIES (AND (NOT (LISTP X))
                        (NOT (LISTP Y))
                        (NOT (F-NOTP X))
                        (NOT (F-NOTP Y))
                        (NOT (F-ORP X))
                        (NOT (F-ORP Y))
                        (NOT (FORSOMEP X))
                        (NOT (FORSOMEP Y))
                        (NUMBERP X)
                        (NUMBERP Y)
                        (NOT (EQUAL Y X)))
                   (NOT (EQUAL X Y))).

    This again simplifies, obviously, to:

          T.

  Case 1.5.
          (IMPLIES (AND (NOT (LISTP X))
                        (NOT (LISTP Y))
                        (NOT (F-NOTP X))
                        (NOT (F-NOTP Y))
                        (NOT (F-ORP X))
                        (NOT (F-ORP Y))
                        (NOT (FORSOMEP X))
                        (NOT (FORSOMEP Y))
                        (NUMBERP X)
                        (NUMBERP Y)
                        (EQUAL Y X))
                   (EQUAL (EQUAL X Y) T)).

    This again simplifies, expanding the function EQUAL, to:

          T.

  Case 1.4.
          (IMPLIES (AND (NOT (LISTP X))
                        (NOT (LISTP Y))
                        (NOT (F-NOTP X))
                        (NOT (F-NOTP Y))
                        (NOT (F-ORP X))
                        (NOT (F-ORP Y))
                        (NOT (FORSOMEP X))
                        (NOT (FORSOMEP Y))
                        (NUMBERP X)
                        (NOT (NUMBERP Y))
                        (NOT (EQUAL NIL X)))
                   (NOT (EQUAL X NIL))),

    which again simplifies, clearly, to:

          T.

  Case 1.3.
          (IMPLIES (AND (NOT (LISTP X))
                        (NOT (LISTP Y))
                        (NOT (F-NOTP X))
                        (NOT (F-NOTP Y))
                        (NOT (F-ORP X))
                        (NOT (F-ORP Y))
                        (NOT (FORSOMEP X))
                        (NOT (FORSOMEP Y))
                        (NUMBERP X)
                        (NOT (NUMBERP Y))
                        (EQUAL NIL X))
                   (EQUAL (EQUAL X NIL) T)).

    This again simplifies, obviously, to:

          T.

  Case 1.2.
          (IMPLIES (AND (NOT (LISTP X))
                        (NOT (LISTP Y))
                        (NOT (F-NOTP X))
                        (NOT (F-NOTP Y))
                        (NOT (F-ORP X))
                        (NOT (F-ORP Y))
                        (NOT (FORSOMEP X))
                        (NOT (FORSOMEP Y))
                        (NOT (NUMBERP X))
                        (NUMBERP Y)
                        (NOT (EQUAL Y NIL)))
                   (NOT (EQUAL NIL Y))).

    This again simplifies, obviously, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (LISTP X))
                        (NOT (LISTP Y))
                        (NOT (F-NOTP X))
                        (NOT (F-NOTP Y))
                        (NOT (F-ORP X))
                        (NOT (F-ORP Y))
                        (NOT (FORSOMEP X))
                        (NOT (FORSOMEP Y))
                        (NOT (NUMBERP X))
                        (NUMBERP Y)
                        (EQUAL Y NIL))
                   (EQUAL (EQUAL NIL Y) T)).

    This again simplifies, clearly, to:

          T.


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


[ 0.0 0.0 0.1 ]

EQL-COMM


(PROVE-LEMMA EQUAL-EQL
             (REWRITE)
             (IMPLIES (EQUAL X Y) (EQL X Y)))


     Give the conjecture the name *1.


     We will appeal to induction.  Two inductions are suggested by terms in
the conjecture.  However, they merge into one likely candidate induction.  We
will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP Y)
                         (p (CDR Y))
                         (p (CAR Y)))
                    (p Y))
           (IMPLIES (AND (NOT (LISTP Y))
                         (F-NOTP Y)
                         (p (ARG Y)))
                    (p Y))
           (IMPLIES (AND (NOT (LISTP Y))
                         (NOT (F-NOTP Y))
                         (F-ORP Y)
                         (p (ARG2 Y))
                         (p (ARG1 Y)))
                    (p Y))
           (IMPLIES (AND (NOT (LISTP Y))
                         (NOT (F-NOTP Y))
                         (NOT (F-ORP Y))
                         (FORSOMEP Y)
                         (p (BODY Y)))
                    (p Y))
           (IMPLIES (AND (NOT (LISTP Y))
                         (NOT (F-NOTP Y))
                         (NOT (F-ORP Y))
                         (NOT (FORSOMEP Y)))
                    (p Y))).
Linear arithmetic and the lemmas CDR-LESSP, CAR-LESSP, ARG-LESSP, ARG2-LESSP,
ARG1-LESSP, and BODY-LESSP inform us that the measure (COUNT Y) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  The above induction scheme produces the following five new
conjectures:

Case 5. (IMPLIES (AND (LISTP Y)
                      (EQL (CDR Y) (CDR Y))
                      (EQL (CAR Y) (CAR Y)))
                 (EQL Y Y)).

  This simplifies, expanding the function EQL, to:

        T.

Case 4. (IMPLIES (AND (NOT (LISTP Y))
                      (F-NOTP Y)
                      (EQL (ARG Y) (ARG Y)))
                 (EQL Y Y)).

  This simplifies, opening up EQL, to:

        T.

Case 3. (IMPLIES (AND (NOT (LISTP Y))
                      (NOT (F-NOTP Y))
                      (F-ORP Y)
                      (EQL (ARG2 Y) (ARG2 Y))
                      (EQL (ARG1 Y) (ARG1 Y)))
                 (EQL Y Y)).

  This simplifies, unfolding the definition of EQL, to:

        T.

Case 2. (IMPLIES (AND (NOT (LISTP Y))
                      (NOT (F-NOTP Y))
                      (NOT (F-ORP Y))
                      (FORSOMEP Y)
                      (EQL (BODY Y) (BODY Y)))
                 (EQL Y Y)).

  This simplifies, unfolding the definition of EQL, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Y))
                      (NOT (F-NOTP Y))
                      (NOT (F-ORP Y))
                      (NOT (FORSOMEP Y)))
                 (EQL Y Y)).

  This simplifies, opening up the functions EQL and FIX1, to:

        T.


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


[ 0.0 0.0 0.0 ]

EQUAL-EQL


(PROVE-LEMMA NUMBERP-EQL
             (REWRITE)
             (IMPLIES (OR (NUMBERP X) (NUMBERP Y))
                      (EQUAL (EQL X Y) (EQUAL X Y))))

WARNING:  the previously added lemma, EQL-COMM, could be applied whenever the
newly proposed NUMBERP-EQL could!


This conjecture simplifies, expanding the definitions of OR, FIX1, and EQL, to
the following 12 new formulas:

Case 12.(IMPLIES (AND (NUMBERP X) (EQUAL X Y))
                 (EQUAL (EQUAL X Y) T)).

  This again simplifies, expanding the function EQUAL, to:

        T.

Case 11.(IMPLIES (AND (NUMBERP X) (EQUAL X Y))
                 (NOT (LISTP Y))),

  which again simplifies, clearly, to:

        T.

Case 10.(IMPLIES (AND (NUMBERP X) (EQUAL X Y))
                 (NOT (F-ORP Y))).

  This again simplifies, trivially, to:

        T.

Case 9. (IMPLIES (AND (NUMBERP X) (EQUAL X Y))
                 (NUMBERP Y)).

  This again simplifies, obviously, to:

        T.

Case 8. (IMPLIES (AND (NUMBERP X) (EQUAL X Y))
                 (NOT (FORSOMEP Y))).

  This again simplifies, clearly, to:

        T.

Case 7. (IMPLIES (AND (NUMBERP X) (EQUAL X Y))
                 (NOT (F-NOTP Y))).

  This again simplifies, clearly, to:

        T.

Case 6. (IMPLIES (AND (NUMBERP Y) (EQUAL X Y))
                 (EQUAL (EQUAL X Y) T)).

  But this again simplifies, opening up EQUAL, to:

        T.

Case 5. (IMPLIES (AND (NUMBERP Y) (EQUAL X Y))
                 (NOT (LISTP X))),

  which again simplifies, obviously, to:

        T.

Case 4. (IMPLIES (AND (NUMBERP Y) (EQUAL X Y))
                 (NOT (F-ORP X))).

  This again simplifies, clearly, to:

        T.

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

  This again simplifies, obviously, to:

        T.

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

  This again simplifies, clearly, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP Y) (EQUAL X Y))
                 (NOT (F-NOTP X))).

  This again simplifies, trivially, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NUMBERP-EQL


(PROVE-LEMMA LISTP-EQL
             (REWRITE)
             (EQUAL (EQL (CONS X Y) (CONS U V))
                    (AND (EQL X U) (EQL Y V))))

WARNING:  the previously added lemma, EQL-COMM, could be applied whenever the
newly proposed LISTP-EQL could!


This simplifies, rewriting with CDR-CONS, CAR-CONS, and EQL-COMM, and opening
up EQL and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

LISTP-EQL


(PROVE-LEMMA F-NOTP-EQL
             (REWRITE)
             (EQUAL (EQL (F-NOT X) (F-NOT Y))
                    (EQL X Y)))

WARNING:  the previously added lemma, EQL-COMM, could be applied whenever the
newly proposed F-NOTP-EQL could!


This conjecture simplifies, applying ARG-F-NOT, and unfolding the function EQL,
to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

F-NOTP-EQL


(PROVE-LEMMA F-ORP-EQL
             (REWRITE)
             (EQUAL (EQL (F-OR X Y) (F-OR U V))
                    (AND (EQL X U) (EQL Y V))))

WARNING:  the previously added lemma, EQL-COMM, could be applied whenever the
newly proposed F-ORP-EQL could!


This simplifies, rewriting with ARG2-F-OR, ARG1-F-OR, and EQL-COMM, and
opening up EQL and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

F-ORP-EQL


(PROVE-LEMMA FORSOMEP-EQL
             (REWRITE)
             (EQUAL (EQL (FORSOME X Y) (FORSOME U V))
                    (AND (EQUAL (FIX X) (FIX U))
                         (EQL Y V))))

WARNING:  the previously added lemma, EQL-COMM, could be applied whenever the
newly proposed FORSOMEP-EQL could!


This formula simplifies, applying the lemmas BODY-FORSOME, BIND-FORSOME, and
EQL-COMM, and unfolding EQL, FIX, and AND, to the following six new goals:

Case 6. (IMPLIES (AND (NUMBERP U)
                      (NUMBERP X)
                      (NOT (EQUAL X U))
                      (EQUAL U X))
                 (EQUAL (EQL V Y) F)).

  This again simplifies, obviously, to:

        T.

Case 5. (IMPLIES (AND (NUMBERP U)
                      (NOT (NUMBERP X))
                      (NOT (EQUAL 0 U))
                      (EQUAL U 0))
                 (EQUAL (EQL V Y) F)).

  This again simplifies, trivially, to:

        T.

Case 4. (IMPLIES (AND (NOT (NUMBERP U))
                      (NUMBERP X)
                      (NOT (EQUAL X 0))
                      (EQUAL 0 X))
                 (EQUAL (EQL V Y) F)).

  This again simplifies, clearly, to:

        T.

Case 3. (IMPLIES (AND (NUMBERP U)
                      (NUMBERP X)
                      (EQUAL X U)
                      (NOT (EQUAL U X)))
                 (EQUAL F (EQL V Y))).

  This again simplifies, clearly, to:

        T.

Case 2. (IMPLIES (AND (NUMBERP U)
                      (NOT (NUMBERP X))
                      (EQUAL 0 U)
                      (NOT (EQUAL U 0)))
                 (EQUAL F (EQL V Y))).

  This again simplifies, obviously, to:

        T.

Case 1. (IMPLIES (AND (NOT (NUMBERP U))
                      (NUMBERP X)
                      (EQUAL X 0)
                      (NOT (EQUAL 0 X)))
                 (EQUAL F (EQL V Y))).

  This again simplifies, clearly, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORSOMEP-EQL


(DEFN MEMB
      (X Y)
      (IF (LISTP Y)
          (IF (EQL X (CAR Y))
              T
              (MEMB X (CDR Y)))
          F))

     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, MEMB is accepted under the definitional principle.
Note that (OR (FALSEP (MEMB X Y)) (TRUEP (MEMB X Y))) is a theorem.




[ 0.0 0.0 0.0 ]

MEMB


(PROVE-LEMMA DEGREE-FN
             (REWRITE)
             (EQUAL (DEGREE (FN X Y)) (FIX Y)))

WARNING:  Note that the rewrite rule DEGREE-FN will be stored so as to apply
only to terms with the nonrecursive function symbol DEGREE.


This simplifies, unfolding FN and FIX, to four new formulas:

Case 4. (IMPLIES (AND (NOT (NUMBERP Y))
                      (NOT (NUMBERP X)))
                 (EQUAL (DEGREE '(2 0 . 0)) 0)),

  which again simplifies, unfolding NUMBERP, CDR, DEGREE, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NUMBERP Y)) (NUMBERP X))
                 (EQUAL (DEGREE (CONS 2 (CONS X 0)))
                        0)),

  which again simplifies, applying CDR-CONS, and opening up the definitions of
  NUMBERP, DEGREE, and EQUAL, to:

        T.

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

  But this again simplifies, rewriting with CDR-CONS, and opening up the
  definition of DEGREE, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP Y) (NUMBERP X))
                 (EQUAL (DEGREE (CONS 2 (CONS X Y)))
                        Y)).

  However this again simplifies, applying CDR-CONS, and unfolding the
  definition of DEGREE, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEGREE-FN


(PROVE-LEMMA DEGREE-P
             (REWRITE)
             (EQUAL (DEGREE (P X Y)) (FIX Y)))

WARNING:  Note that the rewrite rule DEGREE-P will be stored so as to apply
only to terms with the nonrecursive function symbol DEGREE.


This simplifies, unfolding P and FIX, to four new formulas:

Case 4. (IMPLIES (AND (NOT (NUMBERP Y))
                      (NOT (NUMBERP X)))
                 (EQUAL (DEGREE '(3 0 . 0)) 0)),

  which again simplifies, unfolding NUMBERP, CDR, DEGREE, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NUMBERP Y)) (NUMBERP X))
                 (EQUAL (DEGREE (CONS 3 (CONS X 0)))
                        0)),

  which again simplifies, applying CDR-CONS, and opening up the definitions of
  NUMBERP, DEGREE, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NUMBERP Y) (NOT (NUMBERP X)))
                 (EQUAL (DEGREE (CONS 3 (CONS 0 Y)))
                        Y)).

  But this again simplifies, rewriting with CDR-CONS, and opening up the
  definition of DEGREE, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP Y) (NUMBERP X))
                 (EQUAL (DEGREE (CONS 3 (CONS X Y)))
                        Y)).

  However this again simplifies, applying CDR-CONS, and unfolding the
  definition of DEGREE, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEGREE-P


(PROVE-LEMMA INDEX-FN
             (REWRITE)
             (EQUAL (INDEX (FN X Y)) (FIX X)))

WARNING:  Note that the rewrite rule INDEX-FN will be stored so as to apply
only to terms with the nonrecursive function symbol INDEX.


This simplifies, unfolding FN and FIX, to four new formulas:

Case 4. (IMPLIES (AND (NOT (NUMBERP X)) (NUMBERP Y))
                 (EQUAL (INDEX (CONS 2 (CONS 0 Y)))
                        0)),

  which again simplifies, rewriting with CAR-CONS and CDR-CONS, and unfolding
  the definitions of NUMBERP, INDEX, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NUMBERP X))
                      (NOT (NUMBERP Y)))
                 (EQUAL (INDEX '(2 0 . 0)) 0)).

  This again simplifies, expanding the functions NUMBERP, CAR, CDR, INDEX, and
  EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NUMBERP X) (NUMBERP Y))
                 (EQUAL (INDEX (CONS 2 (CONS X Y)))
                        X)),

  which again simplifies, rewriting with CAR-CONS and CDR-CONS, and opening up
  the definition of INDEX, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X) (NOT (NUMBERP Y)))
                 (EQUAL (INDEX (CONS 2 (CONS X 0)))
                        X)).

  However this again simplifies, applying CAR-CONS and CDR-CONS, and unfolding
  the definition of INDEX, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INDEX-FN


(PROVE-LEMMA INDEX-P
             (REWRITE)
             (EQUAL (INDEX (P X Y)) (FIX X)))

WARNING:  Note that the rewrite rule INDEX-P will be stored so as to apply
only to terms with the nonrecursive function symbol INDEX.


This simplifies, unfolding P and FIX, to four new formulas:

Case 4. (IMPLIES (AND (NOT (NUMBERP X)) (NUMBERP Y))
                 (EQUAL (INDEX (CONS 3 (CONS 0 Y)))
                        0)),

  which again simplifies, rewriting with CAR-CONS and CDR-CONS, and unfolding
  the definitions of NUMBERP, INDEX, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NUMBERP X))
                      (NOT (NUMBERP Y)))
                 (EQUAL (INDEX '(3 0 . 0)) 0)).

  This again simplifies, expanding the functions NUMBERP, CAR, CDR, INDEX, and
  EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NUMBERP X) (NUMBERP Y))
                 (EQUAL (INDEX (CONS 3 (CONS X Y)))
                        X)),

  which again simplifies, rewriting with CAR-CONS and CDR-CONS, and opening up
  the definition of INDEX, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X) (NOT (NUMBERP Y)))
                 (EQUAL (INDEX (CONS 3 (CONS X 0)))
                        X)).

  However this again simplifies, applying CAR-CONS and CDR-CONS, and unfolding
  the definition of INDEX, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INDEX-P


(PROVE-LEMMA NOT-FUNCTION
             (REWRITE)
             (IMPLIES (OR (NLISTP X) (PREDICATE X))
                      (NOT (FUNCTION X))))

WARNING:  Note that the rewrite rule NOT-FUNCTION will be stored so as to
apply only to terms with the nonrecursive function symbol FUNCTION.


This conjecture can be simplified, using the abbreviations NOT, IMPLIES,
FUNCTION, and PREDICATE, to:

      (IMPLIES (OR (NLISTP X) (EQUAL (CAR X) 3))
               (NOT (EQUAL (CAR X) 2))).

This simplifies, applying CAR-NLISTP, and unfolding the functions NLISTP,
EQUAL, and OR, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NOT-FUNCTION


(PROVE-LEMMA NOT-PREDICATE
             (REWRITE)
             (IMPLIES (OR (NLISTP X) (FUNCTION X))
                      (NOT (PREDICATE X))))

WARNING:  Note that the rewrite rule NOT-PREDICATE will be stored so as to
apply only to terms with the nonrecursive function symbol PREDICATE.


This conjecture can be simplified, using the abbreviations NOT, IMPLIES,
PREDICATE, and FUNCTION, to:

      (IMPLIES (OR (NLISTP X) (EQUAL (CAR X) 2))
               (NOT (EQUAL (CAR X) 3))).

This simplifies, applying CAR-NLISTP, and unfolding the functions NLISTP,
EQUAL, and OR, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NOT-PREDICATE


(TOGGLE G0616 INDEX T)

[ 0.0 0.0 0.0 ]

G0616


(TOGGLE G0617 DEGREE T)

[ 0.0 0.0 0.0 ]

G0617


(TOGGLE G0618 V T)

[ 0.0 0.0 0.0 ]

G0618


(TOGGLE G0619 FN T)

[ 0.0 0.0 0.0 ]

G0619


(TOGGLE G0620 P T)

[ 0.0 0.0 0.0 ]

G0620


(TOGGLE G0621 FUNCTION T)

[ 0.0 0.0 0.0 ]

G0621


(TOGGLE G0622 PREDICATE T)

[ 0.0 0.0 0.0 ]

G0622


(DEFN FUNC-PRED
      (X)
      (OR (FUNCTION X) (PREDICATE X)))

     Observe that (OR (FALSEP (FUNC-PRED X)) (TRUEP (FUNC-PRED X))) is a
theorem.




[ 0.0 0.0 0.0 ]

FUNC-PRED


(DEFN APPEND
      (X Y)
      (IF (LISTP X)
          (CONS (CAR X) (APPEND (CDR X) Y))
          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
recursive call.  Hence, APPEND is accepted under the definitional principle.
From the definition we can conclude that:
      (OR (LISTP (APPEND X Y))
          (EQUAL (APPEND X Y) Y))
is a theorem.




[ 0.0 0.0 0.0 ]

APPEND


(DEFN DEL
      (X Y)
      (IF (LISTP Y)
          (IF (EQL X (CAR Y))
              (DEL X (CDR Y))
              (CONS (CAR Y) (DEL X (CDR Y))))
          Y))

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




[ 0.0 0.0 0.0 ]

DEL


(PROVE-LEMMA NOT-MEMB-DEL
             (REWRITE)
             (NOT (MEMB X (DEL X Y))))


     Name the conjecture *1.


     Let us appeal to the induction principle.  There is only one suggested
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP Y)
                         (EQL X (CAR Y))
                         (p X (CDR Y)))
                    (p X Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (EQL X (CAR Y)))
                         (p X (CDR Y)))
                    (p X Y))
           (IMPLIES (NOT (LISTP Y)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme leads to three new conjectures:

Case 3. (IMPLIES (AND (LISTP Y)
                      (EQL X (CAR Y))
                      (NOT (MEMB X (DEL X (CDR Y)))))
                 (NOT (MEMB X (DEL X Y)))),

  which simplifies, expanding DEL, to:

        T.

Case 2. (IMPLIES (AND (LISTP Y)
                      (NOT (EQL X (CAR Y)))
                      (NOT (MEMB X (DEL X (CDR Y)))))
                 (NOT (MEMB X (DEL X Y)))),

  which simplifies, rewriting with CDR-CONS and CAR-CONS, and expanding the
  functions DEL and MEMB, to:

        T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (NOT (MEMB X (DEL X Y)))).

  This simplifies, unfolding DEL and MEMB, to:

        T.


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


[ 0.0 0.0 0.0 ]

NOT-MEMB-DEL


(DEFN COLLECT-FREE
      (EXP FLG)
      (IF (ZEROP FLG)
          (IF (VARIABLE EXP)
              (CONS EXP NIL)
              (IF (F-NOTP EXP)
                  (COLLECT-FREE (ARG EXP) 0)
                  (IF (F-ORP EXP)
                      (APPEND (COLLECT-FREE (ARG1 EXP) 0)
                              (COLLECT-FREE (ARG2 EXP) 0))
                      (IF (FORSOMEP EXP)
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0))
                          (IF (LISTP EXP)
                              (COLLECT-FREE (CDR EXP) 1)
                              NIL)))))
          (IF (LISTP EXP)
              (APPEND (COLLECT-FREE (CAR EXP) 0)
                      (COLLECT-FREE (CDR EXP) 1))
              NIL)))

     Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP,
BODY-LESSP, CDR-LESSP, and CAR-LESSP can be used to establish that the measure
(COUNT EXP) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, COLLECT-FREE is accepted under the definitional
principle.




[ 0.0 0.0 0.0 ]

COLLECT-FREE


(DEFN SENTENCE
      (EXP)
      (EQUAL (COLLECT-FREE EXP 0) NIL))

     Observe that (OR (FALSEP (SENTENCE EXP)) (TRUEP (SENTENCE EXP))) is a
theorem.




[ 0.0 0.0 0.0 ]

SENTENCE


(DEFN COVERING
      (EXP VAR FLG)
      (IF (ZEROP FLG)
          (IF (F-NOTP EXP)
              (COVERING (ARG EXP) VAR 0)
              (IF (F-ORP EXP)
                  (APPEND (COVERING (ARG1 EXP) VAR 0)
                          (COVERING (ARG2 EXP) VAR 0))
                  (IF (FORSOMEP EXP)
                      (IF (MEMB VAR (COLLECT-FREE EXP 0))
                          (CONS (BIND EXP)
                                (COVERING (BODY EXP) VAR 0))
                          NIL)
                      (IF (LISTP EXP)
                          (COVERING (CDR EXP) VAR 1)
                          NIL))))
          (IF (LISTP EXP)
              (APPEND (COVERING (CAR EXP) VAR 0)
                      (COVERING (CDR EXP) VAR 1))
              NIL)))

     Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP,
BODY-LESSP, CDR-LESSP, and CAR-LESSP can be used to show that the measure
(COUNT EXP) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, COVERING is accepted under the principle of definition.
From the definition we can conclude that:
      (OR (LITATOM (COVERING EXP VAR FLG))
          (LISTP (COVERING EXP VAR FLG)))
is a theorem.




[ 0.0 0.0 0.0 ]

COVERING


(DEFN NIL-INTERSECT
      (X Y)
      (IF (LISTP X)
          (AND (NOT (MEMB (CAR X) Y))
               (NIL-INTERSECT (CDR X) Y))
          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, NIL-INTERSECT is accepted under the principle of
definition.  From the definition we can conclude that:
      (OR (FALSEP (NIL-INTERSECT X Y))
          (TRUEP (NIL-INTERSECT X Y)))
is a theorem.




[ 0.0 0.0 0.0 ]

NIL-INTERSECT


(DEFN FREE-FOR
      (EXP VAR TERM FLG)
      (NIL-INTERSECT (COVERING EXP VAR FLG)
                     (COLLECT-FREE TERM 0)))

     From the definition we can conclude that:
      (OR (FALSEP (FREE-FOR EXP VAR TERM FLG))
          (TRUEP (FREE-FOR EXP VAR TERM FLG)))
is a theorem.




[ 0.0 0.0 0.0 ]

FREE-FOR


(DEFN F-EQUAL
      (X Y)
      (LIST (P 0 2) X Y))

     Note that (LISTP (F-EQUAL X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

F-EQUAL


(PROVE-LEMMA OR-MEMB-APPEND
             (REWRITE)
             (EQUAL (MEMB X (APPEND Y Z))
                    (OR (MEMB X Y) (MEMB X Z))))

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

Case 2. (IMPLIES (NOT (MEMB X Y))
                 (EQUAL (MEMB X (APPEND Y Z))
                        (MEMB X Z))),

  which we will name *1.

Case 1. (IMPLIES (MEMB X Y)
                 (EQUAL (MEMB X (APPEND Y Z)) T)).

  This again simplifies, trivially, to the new formula:

        (IMPLIES (MEMB X Y)
                 (MEMB X (APPEND Y Z))),

  which we would normally push and work on later by induction.  But if we must
  use induction to prove the input conjecture, we prefer to induct on the
  original formulation of the problem.  Thus we will disregard all that we
  have previously done, give the name *1 to the original input, and work on it.


     So now let us return to:

(EQUAL (MEMB X (APPEND Y Z))
       (OR (MEMB X Y) (MEMB X Z))).

We named this *1.  We will try to prove it by induction.  There are three
plausible inductions.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP Y) (p X (CDR Y) Z))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP Y)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates two new conjectures:

Case 2. (IMPLIES (AND (LISTP Y)
                      (EQUAL (MEMB X (APPEND (CDR Y) Z))
                             (OR (MEMB X (CDR Y)) (MEMB X Z))))
                 (EQUAL (MEMB X (APPEND Y Z))
                        (OR (MEMB X Y) (MEMB X Z)))),

  which simplifies, applying CDR-CONS and CAR-CONS, and unfolding OR, APPEND,
  MEMB, and EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (EQUAL (MEMB X (APPEND Y Z))
                        (OR (MEMB X Y) (MEMB X Z)))).

  This simplifies, expanding the functions APPEND, MEMB, and OR, to:

        T.


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


[ 0.0 0.0 0.0 ]

OR-MEMB-APPEND


(PROVE-LEMMA MEMB-DEL
             (REWRITE)
             (IMPLIES (NOT (EQL X Z))
                      (EQUAL (MEMB X (DEL Z Y))
                             (MEMB X Y))))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest four 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 Y)
                         (EQL Z (CAR Y))
                         (p X Z (CDR Y)))
                    (p X Z Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (EQL Z (CAR Y)))
                         (p X Z (CDR Y)))
                    (p X Z Y))
           (IMPLIES (NOT (LISTP Y)) (p X Z Y))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT Y) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates the
following three new conjectures:

Case 3. (IMPLIES (AND (LISTP Y)
                      (EQL Z (CAR Y))
                      (EQUAL (MEMB X (DEL Z (CDR Y)))
                             (MEMB X (CDR Y)))
                      (NOT (EQL X Z)))
                 (EQUAL (MEMB X (DEL Z Y))
                        (MEMB X Y))).

  This simplifies, opening up the functions DEL and MEMB, to:

        (IMPLIES (AND (LISTP Y)
                      (EQL Z (CAR Y))
                      (EQUAL (MEMB X (DEL Z (CDR Y)))
                             (MEMB X (CDR Y)))
                      (NOT (EQL X Z))
                      (EQL X (CAR Y)))
                 (EQUAL (MEMB X (CDR Y)) T)),

  which again simplifies, trivially, to:

        (IMPLIES (AND (LISTP Y)
                      (EQL Z (CAR Y))
                      (NOT (MEMB X (DEL Z (CDR Y))))
                      (NOT (EQL X Z))
                      (EQL X (CAR Y)))
                 (MEMB X (CDR Y))).

  Applying the lemma CAR-CDR-ELIM, replace Y by (CONS V W) to eliminate
  (CAR Y) and (CDR Y).  This produces the new goal:

        (IMPLIES (AND (EQL Z V)
                      (NOT (MEMB X (DEL Z W)))
                      (NOT (EQL X Z))
                      (EQL X V))
                 (MEMB X W)),

  which further simplifies, appealing to the lemma EQL-COMM, to the goal:

        (IMPLIES (AND (EQL V Z)
                      (NOT (MEMB X (DEL Z W)))
                      (NOT (EQL X Z))
                      (EQL V X))
                 (MEMB X W)).

  Call the above conjecture *1.1.

Case 2. (IMPLIES (AND (LISTP Y)
                      (NOT (EQL Z (CAR Y)))
                      (EQUAL (MEMB X (DEL Z (CDR Y)))
                             (MEMB X (CDR Y)))
                      (NOT (EQL X Z)))
                 (EQUAL (MEMB X (DEL Z Y))
                        (MEMB X Y))).

  This simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS, and
  opening up the definitions of DEL and MEMB, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Y)) (NOT (EQL X Z)))
                 (EQUAL (MEMB X (DEL Z Y))
                        (MEMB X Y))).

  This simplifies, unfolding the definitions of DEL, MEMB, and EQUAL, to:

        T.


     So let us turn our attention to:

      (IMPLIES (AND (EQL V Z)
                    (NOT (MEMB X (DEL Z W)))
                    (NOT (EQL X Z))
                    (EQL V X))
               (MEMB X W)),

which we named *1.1 above.  We will appeal to induction.  Eight 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 W)
                         (EQL Z (CAR W))
                         (p X (CDR W) V Z))
                    (p X W V Z))
           (IMPLIES (AND (LISTP W)
                         (NOT (EQL Z (CAR W)))
                         (p X (CDR W) V Z))
                    (p X W V Z))
           (IMPLIES (NOT (LISTP W))
                    (p X W V Z))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT W) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme produces five new
goals:

Case 5. (IMPLIES (AND (LISTP W)
                      (EQL Z (CAR W))
                      (MEMB X (DEL Z (CDR W)))
                      (EQL V Z)
                      (NOT (MEMB X (DEL Z W)))
                      (NOT (EQL X Z))
                      (EQL V X))
                 (MEMB X W)),

  which simplifies, opening up the definition of DEL, to:

        T.

Case 4. (IMPLIES (AND (LISTP W)
                      (EQL Z (CAR W))
                      (MEMB X (CDR W))
                      (EQL V Z)
                      (NOT (MEMB X (DEL Z W)))
                      (NOT (EQL X Z))
                      (EQL V X))
                 (MEMB X W)),

  which simplifies, opening up the functions DEL and MEMB, to:

        T.

Case 3. (IMPLIES (AND (LISTP W)
                      (NOT (EQL Z (CAR W)))
                      (MEMB X (DEL Z (CDR W)))
                      (EQL V Z)
                      (NOT (MEMB X (DEL Z W)))
                      (NOT (EQL X Z))
                      (EQL V X))
                 (MEMB X W)),

  which simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  expanding the definitions of DEL and MEMB, to:

        T.

Case 2. (IMPLIES (AND (LISTP W)
                      (NOT (EQL Z (CAR W)))
                      (MEMB X (CDR W))
                      (EQL V Z)
                      (NOT (MEMB X (DEL Z W)))
                      (NOT (EQL X Z))
                      (EQL V X))
                 (MEMB X W)),

  which simplifies, rewriting with CDR-CONS and CAR-CONS, and unfolding DEL
  and MEMB, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP W))
                      (EQL V Z)
                      (NOT (MEMB X (DEL Z W)))
                      (NOT (EQL X Z))
                      (EQL V X))
                 (MEMB X W)).

  This simplifies, opening up DEL and MEMB, to:

        (IMPLIES (AND (NOT (LISTP W))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which has an irrelevant term in it.  By eliminating the term we get:

        (IMPLIES (AND (EQL V Z) (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which we will name *1.1.1.


     Perhaps we can prove it by induction.  The recursive terms in the
conjecture suggest six inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP V)
                         (LISTP Z)
                         (p (CDR V) (CDR X) (CDR Z))
                         (p (CAR V) (CAR X) (CAR Z)))
                    (p V X Z))
           (IMPLIES (AND (LISTP V) (NOT (LISTP Z)))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V)) (LISTP Z))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (F-NOTP V)
                         (F-NOTP Z)
                         (p (ARG V) (ARG X) (ARG Z)))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (F-NOTP V)
                         (NOT (F-NOTP Z)))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (F-NOTP Z))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (NOT (F-NOTP Z))
                         (F-ORP V)
                         (F-ORP Z)
                         (p (ARG2 V) (ARG2 X) (ARG2 Z))
                         (p (ARG1 V) (ARG1 X) (ARG1 Z)))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (NOT (F-NOTP Z))
                         (F-ORP V)
                         (NOT (F-ORP Z)))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (NOT (F-NOTP Z))
                         (NOT (F-ORP V))
                         (F-ORP Z))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (NOT (F-NOTP Z))
                         (NOT (F-ORP V))
                         (NOT (F-ORP Z))
                         (FORSOMEP V)
                         (FORSOMEP Z)
                         (p (BODY V) (BODY X) (BODY Z)))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (NOT (F-NOTP Z))
                         (NOT (F-ORP V))
                         (NOT (F-ORP Z))
                         (FORSOMEP V)
                         (NOT (FORSOMEP Z)))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (NOT (F-NOTP Z))
                         (NOT (F-ORP V))
                         (NOT (F-ORP Z))
                         (NOT (FORSOMEP V))
                         (FORSOMEP Z))
                    (p V X Z))
           (IMPLIES (AND (NOT (LISTP V))
                         (NOT (LISTP Z))
                         (NOT (F-NOTP V))
                         (NOT (F-NOTP Z))
                         (NOT (F-ORP V))
                         (NOT (F-ORP Z))
                         (NOT (FORSOMEP V))
                         (NOT (FORSOMEP Z)))
                    (p V X Z))).
Linear arithmetic and the lemmas CDR-LESSP, CAR-LESSP, ARG-LESSP, ARG2-LESSP,
ARG1-LESSP, and BODY-LESSP can be used to show that the measure (COUNT V)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for X and Z.
The above induction scheme leads to 33 new formulas:

Case 33.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (NOT (EQL (CDR V) (CDR Z)))
                      (NOT (EQL (CAR V) (CAR Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the function EQL, to:

        T.

Case 32.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (EQL (CDR X) (CDR Z))
                      (NOT (EQL (CAR V) (CAR Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding EQL, to:

        T.

Case 31.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (NOT (EQL (CDR V) (CDR X)))
                      (NOT (EQL (CAR V) (CAR Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding the definition of EQL, to:

        T.

Case 30.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (NOT (EQL (CDR V) (CDR Z)))
                      (EQL (CAR X) (CAR Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding EQL, to:

        T.

Case 29.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (EQL (CDR X) (CDR Z))
                      (EQL (CAR X) (CAR Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding the definition of EQL, to:

        T.

Case 28.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (NOT (EQL (CDR V) (CDR X)))
                      (EQL (CAR X) (CAR Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding the definition of EQL, to:

        T.

Case 27.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (NOT (EQL (CDR V) (CDR Z)))
                      (NOT (EQL (CAR V) (CAR X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the definition of EQL, to:

        T.

Case 26.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (EQL (CDR X) (CDR Z))
                      (NOT (EQL (CAR V) (CAR X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 25.(IMPLIES (AND (LISTP V)
                      (LISTP Z)
                      (NOT (EQL (CDR V) (CDR X)))
                      (NOT (EQL (CAR V) (CAR X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding the function EQL, to:

        T.

Case 24.(IMPLIES (AND (LISTP V)
                      (NOT (LISTP Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the function EQL, to:

        T.

Case 23.(IMPLIES (AND (NOT (LISTP V))
                      (LISTP Z)
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the definition of EQL, to:

        T.

Case 22.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (F-NOTP V)
                      (F-NOTP Z)
                      (NOT (EQL (ARG V) (ARG Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding the definition of EQL, to:

        T.

Case 21.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (F-NOTP V)
                      (F-NOTP Z)
                      (EQL (ARG X) (ARG Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 20.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (F-NOTP V)
                      (F-NOTP Z)
                      (NOT (EQL (ARG V) (ARG X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding the definition of EQL, to:

        T.

Case 19.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (F-NOTP V)
                      (NOT (F-NOTP Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding the function EQL, to:

        T.

Case 18.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (F-NOTP Z)
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding the function EQL, to:

        T.

Case 17.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (NOT (EQL (ARG2 V) (ARG2 Z)))
                      (NOT (EQL (ARG1 V) (ARG1 Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the function EQL, to:

        T.

Case 16.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (EQL (ARG2 X) (ARG2 Z))
                      (NOT (EQL (ARG1 V) (ARG1 Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 15.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (NOT (EQL (ARG2 V) (ARG2 X)))
                      (NOT (EQL (ARG1 V) (ARG1 Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 14.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (NOT (EQL (ARG2 V) (ARG2 Z)))
                      (EQL (ARG1 X) (ARG1 Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding the function EQL, to:

        T.

Case 13.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (EQL (ARG2 X) (ARG2 Z))
                      (EQL (ARG1 X) (ARG1 Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding the definition of EQL, to:

        T.

Case 12.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (NOT (EQL (ARG2 V) (ARG2 X)))
                      (EQL (ARG1 X) (ARG1 Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the definition of EQL, to:

        T.

Case 11.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (NOT (EQL (ARG2 V) (ARG2 Z)))
                      (NOT (EQL (ARG1 V) (ARG1 X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 10.(IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (EQL (ARG2 X) (ARG2 Z))
                      (NOT (EQL (ARG1 V) (ARG1 X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding the definition of EQL, to:

        T.

Case 9. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (F-ORP Z)
                      (NOT (EQL (ARG2 V) (ARG2 X)))
                      (NOT (EQL (ARG1 V) (ARG1 X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 8. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (F-ORP V)
                      (NOT (F-ORP Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding the function EQL, to:

        T.

Case 7. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (NOT (F-ORP V))
                      (F-ORP Z)
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 6. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (NOT (F-ORP V))
                      (NOT (F-ORP Z))
                      (FORSOMEP V)
                      (FORSOMEP Z)
                      (NOT (EQL (BODY V) (BODY Z)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, expanding EQL, to:

        T.

Case 5. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (NOT (F-ORP V))
                      (NOT (F-ORP Z))
                      (FORSOMEP V)
                      (FORSOMEP Z)
                      (EQL (BODY X) (BODY Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, unfolding EQL, to:

        T.

Case 4. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (NOT (F-ORP V))
                      (NOT (F-ORP Z))
                      (FORSOMEP V)
                      (FORSOMEP Z)
                      (NOT (EQL (BODY V) (BODY X)))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the definition of EQL, to:

        T.

Case 3. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (NOT (F-ORP V))
                      (NOT (F-ORP Z))
                      (FORSOMEP V)
                      (NOT (FORSOMEP Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up the definition of EQL, to:

        T.

Case 2. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (NOT (F-ORP V))
                      (NOT (F-ORP Z))
                      (NOT (FORSOMEP V))
                      (FORSOMEP Z)
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, opening up EQL, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP V))
                      (NOT (LISTP Z))
                      (NOT (F-NOTP V))
                      (NOT (F-NOTP Z))
                      (NOT (F-ORP V))
                      (NOT (F-ORP Z))
                      (NOT (FORSOMEP V))
                      (NOT (FORSOMEP Z))
                      (EQL V Z)
                      (NOT (EQL X Z)))
                 (NOT (EQL V X))),

  which simplifies, rewriting with the lemmas NUMBERP-EQL and EQL-COMM, and
  expanding EQL, FIX1, OR, NUMBERP, FORSOMEP, F-ORP, F-NOTP, and LISTP, to:

        T.


     That finishes the proof of *1.1.1, which, in turn, finishes the proof of
*1.1, which, in turn, finishes the proof of *1.  Q.E.D.


[ 0.0 0.2 0.0 ]

MEMB-DEL


(DEFN VAR-LIST
      (LIST N)
      (IF (OR (ZEROP N) (NLISTP LIST))
          (AND (ZEROP N) (NLISTP LIST))
          (AND (VARIABLE (CAR LIST))
               (VAR-LIST (CDR LIST) (SUB1 N)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definitions of OR, NLISTP, and ZEROP inform us that the measure (COUNT LIST)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, VAR-LIST is accepted under the definitional principle.  The definition
of VAR-LIST can be justified in another way.  Linear arithmetic, the lemma
COUNT-NUMBERP, and the definitions of OR, NLISTP, and ZEROP establish that the
measure (COUNT N) decreases according to the well-founded relation LESSP in
each recursive call.  Note that:
      (OR (FALSEP (VAR-LIST LIST N))
          (TRUEP (VAR-LIST LIST N)))
is a theorem.




[ 0.0 0.0 0.0 ]

VAR-LIST


(DEFN SYMB
      (X SYMBOLS)
      (OR (EQUAL X (P 0 2))
          (MEMB X SYMBOLS)))

     Note that (OR (FALSEP (SYMB X SYMBOLS)) (TRUEP (SYMB X SYMBOLS))) is a
theorem.




[ 0.0 0.0 0.0 ]

SYMB


(DEFN TERMP
      (EXP FLG SYMBOLS)
      (IF (ZEROP FLG)
          (IF (LISTP EXP)
              (AND (FUNCTION (CAR EXP))
                   (SYMB (CAR EXP) SYMBOLS)
                   (TERMP (CDR EXP) 1 SYMBOLS)
                   (EQUAL (LENGTH (CDR EXP))
                          (DEGREE (CAR EXP))))
              (VARIABLE EXP))
          (IF (NLISTP EXP)
              T
              (AND (TERMP (CAR EXP) 0 SYMBOLS)
                   (TERMP (CDR EXP) 1 SYMBOLS)))))

     Linear arithmetic, the lemmas CDR-LESSP, CDR-LESSEQP, CAR-LESSEQP, and
CAR-LESSP, and the definitions of NLISTP and ZEROP establish that the measure
(COUNT EXP) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, TERMP is accepted under the principle of definition.
From the definition we can conclude that:
      (OR (FALSEP (TERMP EXP FLG SYMBOLS))
          (TRUEP (TERMP EXP FLG SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

TERMP


(DEFN ATOMP
      (EXP SYMBOLS)
      (AND (PREDICATE (CAR EXP))
           (SYMB (CAR EXP) SYMBOLS)
           (EQUAL (LENGTH (CDR EXP))
                  (DEGREE (CAR EXP)))
           (TERMP (CDR EXP) 1 SYMBOLS)))

     Observe that:
      (OR (FALSEP (ATOMP EXP SYMBOLS))
          (TRUEP (ATOMP EXP SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

ATOMP


(PROVE-LEMMA ATOMP-REDUC
             (REWRITE)
             (EQUAL (ATOMP (CONS X Y) SYMBOLS)
                    (AND (PREDICATE X)
                         (SYMB X SYMBOLS)
                         (EQUAL (LENGTH Y) (DEGREE X))
                         (TERMP Y 1 SYMBOLS))))

WARNING:  Note that the rewrite rule ATOMP-REDUC will be stored so as to apply
only to terms with the nonrecursive function symbol ATOMP.


This conjecture simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
and unfolding the functions SYMB, ATOMP, and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ATOMP-REDUC


(PROVE-LEMMA ATOMP-F-EQUAL
             (REWRITE)
             (EQUAL (ATOMP (F-EQUAL X Y) SYMBOLS)
                    (AND (TERMP X 0 SYMBOLS)
                         (TERMP Y 0 SYMBOLS))))

WARNING:  Note that the rewrite rule ATOMP-F-EQUAL will be stored so as to
apply only to terms with the nonrecursive function symbol ATOMP.


This conjecture can be simplified, using the abbreviation F-EQUAL, to the goal:

      (EQUAL (ATOMP (LIST (P 0 2) X Y) SYMBOLS)
             (AND (TERMP X 0 SYMBOLS)
                  (TERMP Y 0 SYMBOLS))).

This simplifies, rewriting with PREDICATE-P, CDR-CONS, DEGREE-P, CAR-CONS, and
ATOMP-REDUC, and unfolding SYMB, LENGTH, ADD1, NUMBERP, EQUAL, TERMP, LISTP,
and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ATOMP-F-EQUAL


(DEFN SUBST
      (EXP VAR TERM FLG)
      (IF (ZEROP FLG)
          (IF (VARIABLE EXP)
              (IF (EQUAL EXP VAR) TERM EXP)
              (IF (F-NOTP EXP)
                  (F-NOT (SUBST (ARG EXP) VAR TERM 0))
                  (IF (F-ORP EXP)
                      (F-OR (SUBST (ARG1 EXP) VAR TERM 0)
                            (SUBST (ARG2 EXP) VAR TERM 0))
                      (IF (FORSOMEP EXP)
                          (IF (EQL (BIND EXP) VAR)
                              EXP
                              (FORSOME (BIND EXP)
                                       (SUBST (BODY EXP) VAR TERM 0)))
                          (IF (LISTP EXP)
                              (CONS (CAR EXP)
                                    (SUBST (CDR EXP) VAR TERM 1))
                              EXP)))))
          (IF (LISTP EXP)
              (CONS (SUBST (CAR EXP) VAR TERM 0)
                    (SUBST (CDR EXP) VAR TERM 1))
              EXP)))

     Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP,
BODY-LESSP, CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, SUBST is accepted under the principle of definition.  Note that:
      (OR (OR (LISTP (SUBST EXP VAR TERM FLG))
              (F-NOTP (SUBST EXP VAR TERM FLG))
              (F-ORP (SUBST EXP VAR TERM FLG))
              (FORSOMEP (SUBST EXP VAR TERM FLG)))
          (EQUAL (SUBST EXP VAR TERM FLG) EXP)
          (EQUAL (SUBST EXP VAR TERM FLG) TERM))
is a theorem.




[ 0.0 0.0 0.0 ]

SUBST


(DEFN SUB
      (X Y)
      (IF (LISTP X)
          (AND (MEMB (CAR X) Y) (SUB (CDR X) Y))
          T))

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




[ 0.0 0.0 0.0 ]

SUB


(DEFN SUBSET
      (X Y)
      (IF (LISTP X)
          (AND (MEMBER (CAR X) Y)
               (SUBSET (CDR X) Y))
          T))

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




[ 0.0 0.0 0.0 ]

SUBSET


(PROVE-LEMMA SUB-SUBSET
             (REWRITE)
             (IMPLIES (SUBSET X Y) (SUB X Y)))


     Give the conjecture the name *1.


     We will appeal to induction.  Two inductions are suggested by terms in
the conjecture.  However, they merge into one likely candidate induction.  We
will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X) (p (CDR X) 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.  The above induction scheme produces the following three new
conjectures:

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (SUBSET (CDR X) Y))
                      (SUBSET X Y))
                 (SUB X Y)).

  This simplifies, expanding the function SUBSET, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (SUB (CDR X) Y)
                      (SUBSET X Y))
                 (SUB X Y)).

  This simplifies, opening up SUBSET and SUB, to the new formula:

        (IMPLIES (AND (LISTP X)
                      (SUB (CDR X) Y)
                      (MEMBER (CAR X) Y)
                      (SUBSET (CDR X) Y))
                 (MEMB (CAR X) Y)).

  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:

        (IMPLIES (AND (SUB Z Y)
                      (MEMBER V Y)
                      (SUBSET Z Y))
                 (MEMB V Y)),

  which we will name *1.1.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (SUBSET X Y))
                 (SUB X Y)).

  This simplifies, opening up the functions SUBSET and SUB, to:

        T.


     So let us turn our attention to:

      (IMPLIES (AND (SUB Z Y)
                    (MEMBER V Y)
                    (SUBSET Z Y))
               (MEMB V Y)),

which is formula *1.1 above.  We will appeal to induction.  The recursive
terms in the conjecture suggest four 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 Z) (p V Y (CDR Z)))
                    (p V Y Z))
           (IMPLIES (NOT (LISTP Z)) (p V Y Z))).
Linear arithmetic and the lemma CDR-LESSP 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 leads to the following three new
conjectures:

Case 3. (IMPLIES (AND (LISTP Z)
                      (NOT (SUB (CDR Z) Y))
                      (SUB Z Y)
                      (MEMBER V Y)
                      (SUBSET Z Y))
                 (MEMB V Y)).

  This simplifies, expanding SUB, to:

        T.

Case 2. (IMPLIES (AND (LISTP Z)
                      (NOT (SUBSET (CDR Z) Y))
                      (SUB Z Y)
                      (MEMBER V Y)
                      (SUBSET Z Y))
                 (MEMB V Y)).

  This simplifies, opening up the definitions of SUB and SUBSET, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Z))
                      (SUB Z Y)
                      (MEMBER V Y)
                      (SUBSET Z Y))
                 (MEMB V Y)).

  This simplifies, expanding the functions SUB and SUBSET, to:

        (IMPLIES (AND (NOT (LISTP Z)) (MEMBER V Y))
                 (MEMB V Y)),

  which has an irrelevant term in it.  By eliminating the term we get:

        (IMPLIES (MEMBER V Y) (MEMB V Y)),

  which we will name *1.1.1.


     Perhaps we can prove it by induction.  The recursive terms in the
conjecture suggest two inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP Y) (p V Y))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (EQUAL V (CAR Y)))
                    (p V Y))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (NOT (EQUAL V (CAR Y)))
                         (p V (CDR Y)))
                    (p V Y))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT Y) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces the following four new goals:

Case 4. (IMPLIES (AND (NLISTP Y) (MEMBER V Y))
                 (MEMB V Y)).

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

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Y))
                      (EQUAL V (CAR Y))
                      (MEMBER V Y))
                 (MEMB V Y)).

  This simplifies, applying the lemma EQUAL-EQL, and unfolding the definitions
  of NLISTP, MEMBER, and MEMB, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL V (CAR Y)))
                      (NOT (MEMBER V (CDR Y)))
                      (MEMBER V Y))
                 (MEMB V Y)).

  This simplifies, unfolding NLISTP and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL V (CAR Y)))
                      (MEMB V (CDR Y))
                      (MEMBER V Y))
                 (MEMB V Y)).

  This simplifies, unfolding NLISTP, MEMBER, and MEMB, to:

        T.


     That finishes the proof of *1.1.1, which also finishes the proof of *1.1,
which, in turn, also finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.2 ]

SUB-SUBSET


(PROVE-LEMMA SUBST-F-EQUAL
             (REWRITE)
             (EQUAL (SUBST (F-EQUAL X Y) VAR TERM 0)
                    (F-EQUAL (SUBST X VAR TERM 0)
                             (SUBST Y VAR TERM 0))))

This conjecture can be simplified, using the abbreviation F-EQUAL, to the
formula:

      (EQUAL (SUBST (LIST (P 0 2) X Y) VAR TERM 0)
             (LIST (P 0 2)
                   (SUBST X VAR TERM 0)
                   (SUBST Y VAR TERM 0))).

This simplifies, rewriting with CDR-CONS and CAR-CONS, and expanding the
functions VARIABLE, EQUAL, SUBST, NUMBERP, and LISTP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

SUBST-F-EQUAL


(TOGGLE G0623 F-EQUAL T)

[ 0.0 0.0 0.0 ]

G0623


(TOGGLE G0253 ATOMP T)

[ 0.0 0.0 0.0 ]

G0253


(DEFN FORMULA
      (EXP SYMBOLS)
      (IF (F-NOTP EXP)
          (FORMULA (ARG EXP) SYMBOLS)
          (IF (F-ORP EXP)
              (AND (FORMULA (ARG1 EXP) SYMBOLS)
                   (FORMULA (ARG2 EXP) SYMBOLS))
              (IF (FORSOMEP EXP)
                  (FORMULA (BODY EXP) SYMBOLS)
                  (ATOMP EXP SYMBOLS)))))

     Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, and
BODY-LESSP can be used to show that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
FORMULA is accepted under the principle of definition.  From the definition we
can conclude that:
      (OR (FALSEP (FORMULA EXP SYMBOLS))
          (TRUEP (FORMULA EXP SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

FORMULA


(PROVE-LEMMA FORMULA-F-EQUAL
             (REWRITE)
             (EQUAL (FORMULA (F-EQUAL X Y) SYMBOLS)
                    (AND (TERMP X 0 SYMBOLS)
                         (TERMP Y 0 SYMBOLS))))

This simplifies, appealing to the lemma ATOMP-F-EQUAL, and opening up the
functions FORMULA and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORMULA-F-EQUAL


(DEFN F-AND
      (X Y)
      (F-NOT (F-OR (F-NOT X) (F-NOT Y))))

     Observe that (F-NOTP (F-AND X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

F-AND


(DEFN F-IMPLIES
      (X Y)
      (F-OR (F-NOT X) Y))

     Note that (F-ORP (F-IMPLIES X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

F-IMPLIES


(DEFN FORALL
      (VAR EXP)
      (F-NOT (FORSOME VAR (F-NOT EXP))))

     Note that (F-NOTP (FORALL VAR EXP)) is a theorem.




[ 0.0 0.0 0.0 ]

FORALL


(DEFN PAIREQUALS
      (VARS1 VARS2 EXP)
      (IF (AND (LISTP VARS1) (LISTP VARS2))
          (F-IMPLIES (F-EQUAL (CAR VARS1) (CAR VARS2))
                     (PAIREQUALS (CDR VARS1)
                                 (CDR VARS2)
                                 EXP))
          EXP))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of AND inform us that the measure (COUNT VARS1) decreases according
to the well-founded relation LESSP in each recursive call.  Hence, PAIREQUALS
is accepted under the definitional principle.  The definition of PAIREQUALS
can be justified in another way.  Linear arithmetic, the lemmas CDR-LESSEQP
and CDR-LESSP, and the definition of AND inform us that the measure
(COUNT VARS2) decreases according to the well-founded relation LESSP in each
recursive call.  Observe that:
      (OR (F-ORP (PAIREQUALS VARS1 VARS2 EXP))
          (EQUAL (PAIREQUALS VARS1 VARS2 EXP)
                 EXP))
is a theorem.




[ 0.0 0.0 0.0 ]

PAIREQUALS


(DEFN SECOND (X) (CADR X))

   




[ 0.0 0.0 0.0 ]

SECOND


(DEFN THIRD (X) (CADDR X))

   




[ 0.0 0.0 0.0 ]

THIRD


(DEFN FOURTH (X) (CADDDR X))

   




[ 0.0 0.0 0.0 ]

FOURTH


(DEFN FOL-AXIOM-PROOF
 (CONC HINTS SYMBOLS)
 (IF
  (EQUAL (CAR HINTS) 1)
  (AND (FORMULA (SECOND HINTS) SYMBOLS)
       (EQL CONC
            (F-OR (F-NOT (SECOND HINTS))
                  (SECOND HINTS))))
  (IF
   (EQUAL (CAR HINTS) 2)
   (AND (FORMULA (SECOND HINTS) SYMBOLS)
        (VARIABLE (THIRD HINTS))
        (TERMP (FOURTH HINTS) 0 SYMBOLS)
        (FREE-FOR (SECOND HINTS)
                  (THIRD HINTS)
                  (FOURTH HINTS)
                  0)
        (EQL CONC
             (F-IMPLIES (SUBST (SECOND HINTS)
                               (THIRD HINTS)
                               (FOURTH HINTS)
                               0)
                        (FORSOME (THIRD HINTS)
                                 (SECOND HINTS)))))
   (IF
    (EQUAL (CAR HINTS) 3)
    (AND (TERMP (SECOND HINTS) 0 SYMBOLS)
         (EQL CONC
              (F-EQUAL (SECOND HINTS)
                       (SECOND HINTS))))
    (IF
       (EQUAL (CAR HINTS) 4)
       (AND (TERMP (THIRD HINTS) 1 SYMBOLS)
            (TERMP (FOURTH HINTS) 1 SYMBOLS)
            (FUNCTION (SECOND HINTS))
            (EQUAL (LENGTH (THIRD HINTS))
                   (DEGREE (SECOND HINTS)))
            (EQUAL (LENGTH (FOURTH HINTS))
                   (DEGREE (SECOND HINTS)))
            (EQL CONC
                 (PAIREQUALS (THIRD HINTS)
                             (FOURTH HINTS)
                             (F-EQUAL (CONS (SECOND HINTS) (THIRD HINTS))
                                      (CONS (SECOND HINTS)
                                            (FOURTH HINTS))))))
       (IF (EQUAL (CAR HINTS) 5)
           (AND (TERMP (THIRD HINTS) 1 SYMBOLS)
                (TERMP (FOURTH HINTS) 1 SYMBOLS)
                (PREDICATE (SECOND HINTS))
                (EQUAL (LENGTH (THIRD HINTS))
                       (DEGREE (SECOND HINTS)))
                (EQUAL (LENGTH (FOURTH HINTS))
                       (DEGREE (SECOND HINTS)))
                (EQL CONC
                     (PAIREQUALS (THIRD HINTS)
                                 (FOURTH HINTS)
                                 (F-IMPLIES (CONS (SECOND HINTS) (THIRD HINTS))
                                            (CONS (SECOND HINTS)
                                                  (FOURTH HINTS))))))
           F))))))

     From the definition we can conclude that:
      (OR (FALSEP (FOL-AXIOM-PROOF CONC HINTS SYMBOLS))
          (TRUEP (FOL-AXIOM-PROOF CONC HINTS SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

FOL-AXIOM-PROOF


(DEFN FOL-RULES
 (CONC HINTS SUB-GOALS SYMBOLS)
 (IF
    (EQUAL (CAR HINTS) 1)
    (AND (FORMULA (SECOND HINTS) SYMBOLS)
         (FORMULA (CAR SUB-GOALS) SYMBOLS)
         (EQL CONC
              (F-OR (SECOND HINTS)
                    (CAR SUB-GOALS))))
    (IF (EQUAL (CAR HINTS) 2)
        (AND (FORMULA (SECOND HINTS) SYMBOLS)
             (EQL SUB-GOALS
                  (LIST (F-OR (SECOND HINTS) (SECOND HINTS))))
             (EQL CONC (SECOND HINTS)))
        (IF (EQUAL (CAR HINTS) 3)
            (AND (FORMULA (SECOND HINTS) SYMBOLS)
                 (FORMULA (THIRD HINTS) SYMBOLS)
                 (FORMULA (FOURTH HINTS) SYMBOLS)
                 (EQL SUB-GOALS
                      (LIST (F-OR (SECOND HINTS)
                                  (F-OR (THIRD HINTS) (FOURTH HINTS)))))
                 (EQL CONC
                      (F-OR (F-OR (SECOND HINTS) (THIRD HINTS))
                            (FOURTH HINTS))))
            (IF (EQUAL (CAR HINTS) 4)
                (AND (FORMULA (SECOND HINTS) SYMBOLS)
                     (FORMULA (THIRD HINTS) SYMBOLS)
                     (FORMULA (FOURTH HINTS) SYMBOLS)
                     (EQL SUB-GOALS
                          (LIST (F-OR (SECOND HINTS) (THIRD HINTS))
                                (F-OR (F-NOT (SECOND HINTS))
                                      (FOURTH HINTS))))
                     (EQL CONC
                          (F-OR (THIRD HINTS) (FOURTH HINTS))))
                (IF (EQUAL (CAR HINTS) 5)
                    (AND (VARIABLE (SECOND HINTS))
                         (FORMULA (THIRD HINTS) SYMBOLS)
                         (FORMULA (FOURTH HINTS) SYMBOLS)
                         (NOT (MEMB (SECOND HINTS)
                                    (COLLECT-FREE (FOURTH HINTS) 0)))
                         (EQL SUB-GOALS
                              (LIST (F-IMPLIES (THIRD HINTS)
                                               (FOURTH HINTS))))
                         (EQL CONC
                              (F-IMPLIES (FORSOME (SECOND HINTS) (THIRD HINTS))
                                         (FOURTH HINTS))))
                    F))))))

     From the definition we can conclude that:
      (OR (FALSEP (FOL-RULES CONC HINTS SUB-GOALS SYMBOLS))
          (TRUEP (FOL-RULES CONC HINTS SUB-GOALS SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

FOL-RULES


(DEFN ISIN (X Y) (LIST (P 1 2) X Y))

     Note that (LISTP (ISIN X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

ISIN


(DEFN PHI NIL (LIST (FN 0 0)))

     Note that (LISTP (PHI)) is a theorem.




[ 0.0 0.0 0.0 ]

PHI


(DEFN Z-PAIR
      (X Y)
      (LIST (FN 1 2) X Y))

     Note that (LISTP (Z-PAIR X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

Z-PAIR


(DEFN Z-UNION
      (X Y)
      (LIST (FN 2 2) X Y))

     Note that (LISTP (Z-UNION X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

Z-UNION


(DEFN Z-INT (X) (LIST (P 2 1) X))

     From the definition we can conclude that (LISTP (Z-INT X)) is a theorem.




[ 0.0 0.0 0.0 ]

Z-INT


(DEFN Z-SUCC (X) (LIST (FN 3 1) X))

     From the definition we can conclude that (LISTP (Z-SUCC X)) is a theorem.




[ 0.0 0.0 0.0 ]

Z-SUCC


(DEFN F-IFF
      (X Y)
      (F-AND (F-IMPLIES X Y)
             (F-IMPLIES Y X)))

     Observe that (F-NOTP (F-IFF X Y)) is a theorem.




[ 0.0 0.0 0.0 ]

F-IFF


(DEFN Z2-AXIOMS
 (CONC HINTS SYMBOLS)
 (IF
  (EQUAL (CAR HINTS) 1)
  (AND (VARIABLE (FOURTH HINTS))
       (TERMP (SECOND HINTS) 0 SYMBOLS)
       (TERMP (THIRD HINTS) 0 SYMBOLS)
       (NOT (MEMB (FOURTH HINTS)
                  (COLLECT-FREE (SECOND HINTS) 0)))
       (NOT (MEMB (FOURTH HINTS)
                  (COLLECT-FREE (THIRD HINTS) 0)))
       (EQL CONC
            (F-IFF (F-EQUAL (SECOND HINTS) (THIRD HINTS))
                   (FORALL (FOURTH HINTS)
                           (F-IFF (ISIN (FOURTH HINTS) (SECOND HINTS))
                                  (ISIN (FOURTH HINTS)
                                        (THIRD HINTS)))))))
  (IF
   (EQUAL (CAR HINTS) 2)
   (AND (TERMP (SECOND HINTS) 0 SYMBOLS)
        (EQL CONC
             (F-NOT (ISIN (SECOND HINTS) (PHI)))))
   (IF
    (EQUAL (CAR HINTS) 3)
    (AND (TERMP (LIST (SECOND HINTS)
                      (THIRD HINTS)
                      (FOURTH HINTS))
                1 SYMBOLS)
         (EQL CONC
              (F-IFF (ISIN (FOURTH HINTS)
                           (Z-PAIR (SECOND HINTS) (THIRD HINTS)))
                     (F-OR (F-EQUAL (FOURTH HINTS)
                                    (SECOND HINTS))
                           (F-EQUAL (FOURTH HINTS)
                                    (THIRD HINTS))))))
    (IF
     (EQUAL (CAR HINTS) 4)
     (AND (TERMP (LIST (SECOND HINTS)
                       (THIRD HINTS)
                       (FOURTH HINTS))
                 1 SYMBOLS)
          (EQL CONC
               (F-IFF (ISIN (FOURTH HINTS)
                            (Z-UNION (SECOND HINTS)
                                     (THIRD HINTS)))
                      (F-OR (ISIN (FOURTH HINTS) (SECOND HINTS))
                            (ISIN (FOURTH HINTS)
                                  (THIRD HINTS))))))
     (IF
      (EQUAL (CAR HINTS) 5)
      (AND
        (VARIABLE (THIRD HINTS))
        (FORMULA (SECOND HINTS) SYMBOLS)
        (EQL CONC
             (F-IMPLIES (F-AND (SUBST (SECOND HINTS)
                                      (THIRD HINTS)
                                      (PHI)
                                      0)
                               (FORALL (THIRD HINTS)
                                       (F-IMPLIES (F-AND (Z-INT (THIRD HINTS))
                                                         (SECOND HINTS))
                                                  (SUBST (SECOND HINTS)
                                                         (THIRD HINTS)
                                                         (Z-SUCC (THIRD HINTS))
                                                         0))))
                        (FORALL (THIRD HINTS)
                                (F-IMPLIES (Z-INT (THIRD HINTS))
                                           (SECOND HINTS))))))
      F))))))

     Observe that:
      (OR (FALSEP (Z2-AXIOMS CONC HINTS SYMBOLS))
          (TRUEP (Z2-AXIOMS CONC HINTS SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

Z2-AXIOMS


(DEFN SET
      (X)
      (IF (LISTP X)
          (AND (NOT (MEMB (CAR X) (CDR X)))
               (SET (CDR X)))
          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, SET is accepted under the principle of definition.
From the definition we can conclude that (OR (FALSEP (SET X)) (TRUEP (SET X)))
is a theorem.




[ 0.0 0.0 0.0 ]

SET


(DEFN ASSOC
      (X Y)
      (IF (LISTP Y)
          (IF (EQL (CAAR Y) X)
              (CDAR Y)
              (ASSOC X (CDR Y)))
          0))

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




[ 0.0 0.0 0.0 ]

ASSOC


(DEFN REST-OF
      (SYM SYMBOLS)
      (IF (LISTP SYMBOLS)
          (IF (AND (EQL (CAR SYMBOLS) SYM)
                   (NOT (MEMB SYM (CDR SYMBOLS))))
              (CDR SYMBOLS)
              (REST-OF SYM (CDR SYMBOLS)))
          NIL))

     Linear arithmetic and the lemma CDR-LESSP establish that the measure
(COUNT SYMBOLS) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, REST-OF is accepted under the definitional principle.




[ 0.0 0.0 0.0 ]

REST-OF


(DEFN SYMB-DEFN-PROOF
      (CONC HINTS SUB-GOALS DEFN SYMBOLS)
      (IF (PREDICATE (CAAR HINTS))
          (AND (SET (CDAR HINTS))
               (VAR-LIST (CDAR HINTS)
                         (DEGREE (CAAR HINTS)))
               (EQL CONC (F-IFF (CAR HINTS) DEFN))
               (SUB (COLLECT-FREE DEFN 0)
                    (CDAR HINTS))
               (FORMULA DEFN
                        (REST-OF (CAAR HINTS) SYMBOLS)))
          (IF (FUNCTION (CAAR HINTS))
              (AND (SET (CONS (FOURTH HINTS)
                              (CONS (SECOND HINTS) (CDAR HINTS))))
                   (VAR-LIST (CDAR HINTS)
                             (DEGREE (CAAR HINTS)))
                   (VARIABLE (SECOND HINTS))
                   (VARIABLE (FOURTH HINTS))
                   (FORMULA (THIRD HINTS)
                            (REST-OF (CAAR HINTS) SYMBOLS))
                   (SUB (COLLECT-FREE (THIRD HINTS) 0)
                        (CONS (SECOND HINTS) (CDAR HINTS)))
                   (FREE-FOR (THIRD HINTS)
                             (SECOND HINTS)
                             (CAR HINTS)
                             0)
                   (FREE-FOR (THIRD HINTS)
                             (SECOND HINTS)
                             (FOURTH HINTS)
                             0)
                   (EQL CONC
                        (SUBST (THIRD HINTS)
                               (SECOND HINTS)
                               (CAR HINTS)
                               0))
                   (EQL CONC DEFN)
                   (EQL SUB-GOALS
                        (LIST (FORSOME (SECOND HINTS) (THIRD HINTS))
                              (F-IMPLIES (F-AND (THIRD HINTS)
                                                (SUBST (THIRD HINTS)
                                                       (SECOND HINTS)
                                                       (FOURTH HINTS)
                                                       0))
                                         (F-EQUAL (SECOND HINTS)
                                                  (FOURTH HINTS))))))
              F)))

     Note that:
      (OR (FALSEP (SYMB-DEFN-PROOF CONC HINTS SUB-GOALS DEFN SYMBOLS))
          (TRUEP (SYMB-DEFN-PROOF CONC HINTS SUB-GOALS DEFN SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

SYMB-DEFN-PROOF


(DEFN CONC
      (PF FLG)
      (IF (ZEROP FLG)
          (THIRD PF)
          (IF (LISTP PF)
              (CONS (CONC (CAR PF) 0)
                    (CONC (CDR PF) 1))
              NIL)))

     Linear arithmetic and the lemmas CDR-LESSP and CAR-LESSP can be used to
show that the measure (COUNT PF) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, CONC is accepted under the
definitional principle.




[ 0.0 0.0 0.0 ]

CONC


(DEFN PRF
 (PF GIVEN DEFNS FLG SYMBOLS)
 (IF
  (ZEROP FLG)
  (IF
     (NLISTP PF)
     F
     (IF (NOT (FORMULA (CONC PF 0) SYMBOLS))
         F
         (IF (EQUAL (CAR PF) 1)
             (FOL-AXIOM-PROOF (CONC PF 0)
                              (SECOND PF)
                              SYMBOLS)
             (IF (EQUAL (CAR PF) 2)
                 (AND (FOL-RULES (CONC PF 0)
                                 (SECOND PF)
                                 (CONC (FOURTH PF) 1)
                                 SYMBOLS)
                      (PRF (FOURTH PF)
                           GIVEN DEFNS 1 SYMBOLS))
                 (IF (EQUAL (CAR PF) 3)
                     (Z2-AXIOMS (CONC PF 0)
                                (SECOND PF)
                                SYMBOLS)
                     (IF (EQUAL (CAR PF) 4)
                         (AND (SYMB-DEFN-PROOF (CONC PF 0)
                                               (SECOND PF)
                                               (CONC (FOURTH PF) 1)
                                               (ASSOC (CAAR (SECOND PF)) DEFNS)
                                               SYMBOLS)
                              (IF (FUNCTION (CAAR (CADR PF)))
                                  (PRF (CADDDR PF)
                                       GIVEN DEFNS 1
                                       (REST-OF (CAAR (CADR PF)) SYMBOLS))
                                  T))
                         (IF (EQUAL (CAR PF) 5)
                             (MEMB (CONC PF 0) GIVEN)
                             F)))))))
  (IF (NLISTP PF)
      T
      (AND (PRF (CAR PF) GIVEN DEFNS 0 SYMBOLS)
           (PRF (CDR PF)
                GIVEN DEFNS 1 SYMBOLS)))))

     Linear arithmetic, the lemmas CAR-LESSEQP, CDR-LESSEQP, CDR-LESSP, and
CAR-LESSP, and the definitions of FOURTH, CONC, EQUAL, THIRD, NLISTP, and
ZEROP inform us that the measure (COUNT PF) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, PRF is accepted
under the definitional principle.  Note that:
      (OR (FALSEP (PRF PF GIVEN DEFNS FLG SYMBOLS))
          (TRUEP (PRF PF GIVEN DEFNS FLG SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

PRF


(DEFN PROVES
      (PF EXP GIVEN DEFNS SYMBOLS)
      (AND (EQL (CONC PF 0) EXP)
           (FORMULA EXP SYMBOLS)
           (PRF PF GIVEN DEFNS 0 SYMBOLS)))

     From the definition we can conclude that:
      (OR (FALSEP (PROVES PF EXP GIVEN DEFNS SYMBOLS))
          (TRUEP (PROVES PF EXP GIVEN DEFNS SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

PROVES


(DEFN PROP-AXIOM
      (EXP)
      (F-OR (F-NOT EXP) EXP))

     Observe that (F-ORP (PROP-AXIOM EXP)) is a theorem.




[ 0.1 0.0 0.0 ]

PROP-AXIOM


(DEFN SUBST-AXIOM
      (EXP VAR TERM)
      (F-IMPLIES (SUBST EXP VAR TERM 0)
                 (FORSOME VAR EXP)))

     From the definition we can conclude that:
      (F-ORP (SUBST-AXIOM EXP VAR TERM))
is a theorem.




[ 0.0 0.0 0.0 ]

SUBST-AXIOM


(DEFN IDENT-AXIOM
      (VAR)
      (F-EQUAL VAR VAR))

     Note that (LISTP (IDENT-AXIOM VAR)) is a theorem.




[ 0.0 0.0 0.0 ]

IDENT-AXIOM


(DEFN PROP-AXIOM-PROOF
      (EXP)
      (LIST 1
            (LIST 1 EXP)
            (PROP-AXIOM EXP)))

     Note that (LISTP (PROP-AXIOM-PROOF EXP)) is a theorem.




[ 0.0 0.0 0.0 ]

PROP-AXIOM-PROOF


(DEFN SUBST-AXIOM-PROOF
      (EXP VAR TERM)
      (LIST 1
            (LIST 2 EXP VAR TERM)
            (SUBST-AXIOM EXP VAR TERM)))

     Observe that (LISTP (SUBST-AXIOM-PROOF EXP VAR TERM)) is a theorem.




[ 0.0 0.0 0.0 ]

SUBST-AXIOM-PROOF


(DEFN IDENT-AXIOM-PROOF
      (VAR)
      (LIST 1
            (LIST 3 VAR)
            (F-EQUAL VAR VAR)))

     From the definition we can conclude that (LISTP (IDENT-AXIOM-PROOF VAR))
is a theorem.




[ 0.0 0.0 0.0 ]

IDENT-AXIOM-PROOF


(DEFN EQUAL-AXIOM1
      (VARS1 VARS2 FN)
      (PAIREQUALS VARS1 VARS2
                  (F-EQUAL (CONS FN VARS1)
                           (CONS FN VARS2))))

     From the definition we can conclude that:
      (OR (LISTP (EQUAL-AXIOM1 VARS1 VARS2 FN))
          (F-ORP (EQUAL-AXIOM1 VARS1 VARS2 FN)))
is a theorem.




[ 0.0 0.0 0.0 ]

EQUAL-AXIOM1


(DEFN EQUAL-AXIOM1-PROOF
      (FN VARS1 VARS2)
      (LIST 1
            (LIST 4 FN VARS1 VARS2)
            (EQUAL-AXIOM1 VARS1 VARS2 FN)))

     Observe that (LISTP (EQUAL-AXIOM1-PROOF FN VARS1 VARS2)) is a theorem.




[ 0.0 0.0 0.0 ]

EQUAL-AXIOM1-PROOF


(DEFN EQUAL-AXIOM2
      (VARS1 VARS2 PR)
      (PAIREQUALS VARS1 VARS2
                  (F-IMPLIES (CONS PR VARS1)
                             (CONS PR VARS2))))

     From the definition we can conclude that:
      (F-ORP (EQUAL-AXIOM2 VARS1 VARS2 PR))
is a theorem.




[ 0.0 0.0 0.0 ]

EQUAL-AXIOM2


(DEFN EQUAL-AXIOM2-PROOF
      (PR VARS1 VARS2)
      (LIST 1
            (LIST 5 PR VARS1 VARS2)
            (EQUAL-AXIOM2 VARS1 VARS2 PR)))

     Observe that (LISTP (EQUAL-AXIOM2-PROOF PR VARS1 VARS2)) is a theorem.




[ 0.0 0.0 0.0 ]

EQUAL-AXIOM2-PROOF


(PROVE-LEMMA FORMULA-F-NOT
             (REWRITE)
             (EQUAL (FORMULA (F-NOT X) SYMBOLS)
                    (FORMULA X SYMBOLS)))

This conjecture simplifies, appealing to the lemma ARG-F-NOT, and expanding
the function FORMULA, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORMULA-F-NOT


(PROVE-LEMMA FORMULA-F-OR
             (REWRITE)
             (EQUAL (FORMULA (F-OR X Y) SYMBOLS)
                    (AND (FORMULA X SYMBOLS)
                         (FORMULA Y SYMBOLS))))

This simplifies, appealing to the lemmas ARG2-F-OR and ARG1-F-OR, and opening
up the definitions of FORMULA and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORMULA-F-OR


(PROVE-LEMMA FORMULA-FORSOME
             (REWRITE)
             (EQUAL (FORMULA (FORSOME X Y) SYMBOLS)
                    (FORMULA Y SYMBOLS)))

This formula simplifies, applying the lemma BODY-FORSOME, and expanding the
definition of FORMULA, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORMULA-FORSOME


(PROVE-LEMMA PROP-AXIOM-PROVES
             (REWRITE)
             (IMPLIES (FORMULA EXP SYMBOLS)
                      (PROVES (PROP-AXIOM-PROOF EXP)
                              (F-OR (F-NOT EXP) EXP)
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule PROP-AXIOM-PROVES will be stored so as to
apply only to terms with the nonrecursive function symbol PROVES.


This conjecture simplifies, applying FORMULA-F-OR, FORMULA-F-NOT, F-ORP-EQL,
F-NOTP-EQL, EQUAL-EQL, CAR-CONS, and CDR-CONS, and expanding the functions
PROP-AXIOM, PROP-AXIOM-PROOF, PRF, SECOND, FOL-AXIOM-PROOF, CONC, EQUAL, THIRD,
and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PROP-AXIOM-PROVES


(PROVE-LEMMA SUBST-LENGTH
             (REWRITE)
             (IMPLIES (NOT (ZEROP FLG))
                      (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                             (LENGTH EXP))))

This formula can be simplified, using the abbreviations ZEROP, NOT, and
IMPLIES, to:

      (IMPLIES (AND (NOT (EQUAL FLG 0))
                    (NUMBERP FLG))
               (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                      (LENGTH EXP))),

which we will name *1.


     We will appeal to induction.  The recursive terms in the conjecture
suggest two inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR)))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG2 EXP) VAR TERM 0)
                         (p (ARG1 EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR))
                         (p (BODY EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR TERM 1))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CDR EXP) VAR TERM 1)
                         (p (CAR EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP establish that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme generates the following 17 new conjectures:

Case 17.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

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

        T.

Case 16.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, opening up the function ZEROP, to:

        T.

Case 15.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (EQUAL 0 0)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, unfolding ZEROP, to:

        T.

Case 14.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (EQUAL (LENGTH (SUBST (ARG EXP) VAR TERM 0))
                             (LENGTH (ARG EXP)))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, expanding the definition of ZEROP, to:

        T.

Case 13.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (EQUAL 0 0)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, expanding the definition of ZEROP, to:

        T.

Case 12.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (EQUAL (LENGTH (SUBST (ARG2 EXP) VAR TERM 0))
                             (LENGTH (ARG2 EXP)))
                      (EQUAL (LENGTH (SUBST (ARG1 EXP) VAR TERM 0))
                             (LENGTH (ARG1 EXP)))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, unfolding the function ZEROP, to:

        T.

Case 11.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQL (BIND EXP) VAR)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, unfolding ZEROP, to:

        T.

Case 10.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (EQUAL 0 0)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

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

        T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (EQUAL (LENGTH (SUBST (BODY EXP) VAR TERM 0))
                             (LENGTH (BODY EXP)))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, opening up ZEROP, to:

        T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (EQUAL 1 0)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, using linear arithmetic, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (EQUAL (LENGTH (SUBST (CDR EXP) VAR TERM 1))
                             (LENGTH (CDR EXP)))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, opening up ZEROP, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, unfolding the definition of ZEROP, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL 1 0)
                      (EQUAL 0 0)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, using linear arithmetic, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL (LENGTH (SUBST (CDR EXP) VAR TERM 1))
                             (LENGTH (CDR EXP)))
                      (EQUAL 0 0)
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, appealing to the lemma CDR-CONS, and unfolding the
  definitions of ZEROP, EQUAL, SUBST, and LENGTH, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL 1 0)
                      (EQUAL (LENGTH (SUBST (CAR EXP) VAR TERM 0))
                             (LENGTH (CAR EXP)))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL (LENGTH (SUBST (CDR EXP) VAR TERM 1))
                             (LENGTH (CDR EXP)))
                      (EQUAL (LENGTH (SUBST (CAR EXP) VAR TERM 0))
                             (LENGTH (CAR EXP)))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))).

  This simplifies, rewriting with CDR-CONS, and expanding the definitions of
  ZEROP, SUBST, and LENGTH, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NOT (EQUAL FLG 0))
                      (NUMBERP FLG))
                 (EQUAL (LENGTH (SUBST EXP VAR TERM FLG))
                        (LENGTH EXP))),

  which simplifies, expanding the definitions of ZEROP, SUBST, LENGTH, and
  EQUAL, to:

        T.


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


[ 0.0 0.0 0.0 ]

SUBST-LENGTH


(PROVE-LEMMA SUBST-TERMP
             (REWRITE)
             (IMPLIES (AND (TERMP EXP FLG SYMBOLS)
                           (TERMP TERM 0 SYMBOLS))
                      (TERMP (SUBST EXP VAR TERM FLG)
                             FLG SYMBOLS)))


     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 (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR)))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR TERM 0 SYMBOLS))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG1 EXP) VAR TERM 0 SYMBOLS)
                         (p (ARG2 EXP) VAR TERM 0 SYMBOLS))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR))
                         (p (BODY EXP) VAR TERM 0 SYMBOLS))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR TERM 1 SYMBOLS))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CAR EXP) VAR TERM 0 SYMBOLS)
                         (p (CDR EXP) VAR TERM 1 SYMBOLS))
                    (p EXP VAR TERM FLG SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG SYMBOLS))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP can be used to establish that the measure (COUNT EXP)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for FLG.  The
above induction scheme leads to 19 new goals:

Case 19.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)),

  which simplifies, unfolding the functions ZEROP, VARIABLE, EQUAL, TERMP, and
  SUBST, to:

        (IMPLIES (AND (NOT (NUMBERP FLG))
                      (NUMBERP VAR)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP TERM FLG SYMBOLS)).

  Eliminate the irrelevant term.  We thus obtain:

        (IMPLIES (AND (NOT (NUMBERP FLG))
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP TERM FLG SYMBOLS)),

  which we will name *1.1.

Case 18.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, unfolding the functions ZEROP, VARIABLE, EQUAL, TERMP, and
  SUBST, to:

        T.

Case 17.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (NOT (TERMP (ARG EXP) 0 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, unfolding ZEROP, VARIABLE, EQUAL, and TERMP, to:

        T.

Case 16.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (TERMP (SUBST (ARG EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, unfolding the functions ZEROP, VARIABLE, EQUAL, and TERMP,
  to:

        T.

Case 15.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (TERMP (ARG1 EXP) 0 SYMBOLS))
                      (NOT (TERMP (ARG2 EXP) 0 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, opening up the definitions of ZEROP, VARIABLE, EQUAL, and
  TERMP, to:

        T.

Case 14.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (TERMP (SUBST (ARG1 EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (NOT (TERMP (ARG2 EXP) 0 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, opening up the functions ZEROP, VARIABLE, EQUAL, and TERMP,
  to:

        T.

Case 13.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (TERMP (ARG1 EXP) 0 SYMBOLS))
                      (TERMP (SUBST (ARG2 EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, unfolding the functions ZEROP, VARIABLE, EQUAL, and TERMP,
  to:

        T.

Case 12.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (TERMP (SUBST (ARG1 EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (TERMP (SUBST (ARG2 EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, expanding the functions ZEROP, VARIABLE, EQUAL, and TERMP,
  to:

        T.

Case 11.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQL (BIND EXP) VAR)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, rewriting with NUMBERP-EQL, and unfolding the functions
  ZEROP, VARIABLE, OR, EQUAL, and TERMP, to:

        T.

Case 10.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (NOT (TERMP (BODY EXP) 0 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)),

  which simplifies, rewriting with the lemma NUMBERP-EQL, and expanding ZEROP,
  VARIABLE, OR, EQUAL, and TERMP, to:

        T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (TERMP (SUBST (BODY EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)),

  which simplifies, applying the lemma NUMBERP-EQL, and opening up the
  definitions of ZEROP, VARIABLE, OR, EQUAL, and TERMP, to:

        T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (TERMP (CDR EXP) 1 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)),

  which simplifies, expanding the functions ZEROP, VARIABLE, SYMB, EQUAL, and
  TERMP, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (TERMP (SUBST (CDR EXP) VAR TERM 1)
                             1 SYMBOLS)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)),

  which simplifies, applying SUBST-LENGTH, CDR-CONS, CAR-CONS, NOT-FUNCTION,
  and PREDICATE-P, and opening up the definitions of ZEROP, VARIABLE, SYMB,
  EQUAL, TERMP, SUBST, NLISTP, and OR, to the following two new conjectures:

  Case 7.2.
          (IMPLIES (AND (EQUAL FLG 0)
                        (LISTP EXP)
                        (TERMP (SUBST (CDR EXP) VAR TERM 1)
                               1 SYMBOLS)
                        (FUNCTION (CAR EXP))
                        (EQUAL (CAR EXP) (P 0 2))
                        (TERMP (CDR EXP) 1 SYMBOLS)
                        (EQUAL (LENGTH (CDR EXP))
                               (DEGREE (CAR EXP))))
                   (NOT (TERMP TERM 0 SYMBOLS))).

    But this again simplifies, applying PREDICATE-P and NOT-FUNCTION, and
    unfolding OR and NLISTP, to:

          T.

  Case 7.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (LISTP EXP)
                        (TERMP (SUBST (CDR EXP) VAR TERM 1)
                               1 SYMBOLS)
                        (FUNCTION (CAR EXP))
                        (EQUAL (CAR EXP) (P 0 2))
                        (TERMP (CDR EXP) 1 SYMBOLS)
                        (EQUAL (LENGTH (CDR EXP))
                               (DEGREE (CAR EXP))))
                   (NOT (TERMP TERM 0 SYMBOLS))).

    This again simplifies, applying PREDICATE-P and NOT-FUNCTION, and
    unfolding OR and NLISTP, to:

          T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, opening up ZEROP, VARIABLE, EQUAL, and TERMP, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (TERMP (CAR EXP) 0 SYMBOLS))
                      (NOT (TERMP (CDR EXP) 1 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, expanding the functions ZEROP and TERMP, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (TERMP (SUBST (CAR EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (NOT (TERMP (CDR EXP) 1 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, opening up ZEROP and TERMP, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (TERMP (CAR EXP) 0 SYMBOLS))
                      (TERMP (SUBST (CDR EXP) VAR TERM 1)
                             1 SYMBOLS)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, opening up the definitions of ZEROP and TERMP, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (TERMP (SUBST (CAR EXP) VAR TERM 0)
                             0 SYMBOLS)
                      (TERMP (SUBST (CDR EXP) VAR TERM 1)
                             1 SYMBOLS)
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  unfolding ZEROP, TERMP, and SUBST, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (TERMP EXP FLG SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP (SUBST EXP VAR TERM FLG)
                        FLG SYMBOLS)).

  This simplifies, expanding the definitions of ZEROP, TERMP, and SUBST, to:

        T.


     So let us turn our attention to:

      (IMPLIES (AND (NOT (NUMBERP FLG))
                    (TERMP TERM 0 SYMBOLS))
               (TERMP TERM FLG SYMBOLS)),

named *1.1 above.  We will appeal to induction.  Two inductions are suggested
by terms in the conjecture.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP 0)
                         (LISTP TERM)
                         (p (CDR TERM) 1 SYMBOLS))
                    (p TERM FLG SYMBOLS))
           (IMPLIES (AND (ZEROP 0) (NOT (LISTP TERM)))
                    (p TERM FLG SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 0)) (NLISTP TERM))
                    (p TERM FLG SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 0))
                         (NOT (NLISTP TERM))
                         (p (CAR TERM) 0 SYMBOLS)
                         (p (CDR TERM) 1 SYMBOLS))
                    (p TERM FLG SYMBOLS))).
Linear arithmetic, the lemmas CDR-LESSP, CDR-LESSEQP, CAR-LESSEQP, and
CAR-LESSP, and the definitions of NLISTP and ZEROP establish that the measure
(COUNT TERM) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  Note, however, the inductive instances chosen
for FLG.  The above induction scheme leads to the following four new formulas:

Case 4. (IMPLIES (AND (ZEROP 0)
                      (LISTP TERM)
                      (NOT (NUMBERP FLG))
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP TERM FLG SYMBOLS)).

  This simplifies, applying PREDICATE-P and NOT-FUNCTION, and expanding the
  functions ZEROP, TERMP, EQUAL, SYMB, OR, and NLISTP, to the conjecture:

        (IMPLIES (AND (LISTP TERM)
                      (NOT (NUMBERP FLG))
                      (FUNCTION (CAR TERM))
                      (EQUAL (CAR TERM) (P 0 2))
                      (TERMP (CDR TERM) 1 SYMBOLS))
                 (NOT (EQUAL (LENGTH (CDR TERM))
                             (DEGREE (CAR TERM))))).

  However this again simplifies, appealing to the lemmas PREDICATE-P and
  NOT-FUNCTION, and unfolding the definitions of OR and NLISTP, to:

        T.

Case 3. (IMPLIES (AND (ZEROP 0)
                      (NOT (LISTP TERM))
                      (NOT (NUMBERP FLG))
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP TERM FLG SYMBOLS)),

  which simplifies, expanding the functions ZEROP, TERMP, EQUAL, and VARIABLE,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP 0))
                      (NLISTP TERM)
                      (NOT (NUMBERP FLG))
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP TERM FLG SYMBOLS)),

  which simplifies, unfolding the definition of ZEROP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP 0))
                      (NOT (NLISTP TERM))
                      (NOT (NUMBERP FLG))
                      (TERMP TERM 0 SYMBOLS))
                 (TERMP TERM FLG SYMBOLS)),

  which simplifies, unfolding ZEROP, to:

        T.


     That finishes the proof of *1.1, which, consequently, finishes the proof
of *1.  Q.E.D.


[ 0.0 0.1 0.1 ]

SUBST-TERMP


(TOGGLE G0606 ATOMP NIL)

[ 0.0 0.0 0.0 ]

G0606


(PROVE-LEMMA SUBST-FORMULA
             (REWRITE)
             (IMPLIES (AND (FORMULA EXP SYMBOLS)
                           (TERMP TERM 0 SYMBOLS))
                      (FORMULA (SUBST EXP VAR TERM 0)
                               SYMBOLS)))


     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 (AND (ZEROP 0)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (ZEROP 0)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR)))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (ZEROP 0)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR TERM SYMBOLS))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (ZEROP 0)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG1 EXP) VAR TERM SYMBOLS)
                         (p (ARG2 EXP) VAR TERM SYMBOLS))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (ZEROP 0)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (ZEROP 0)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR))
                         (p (BODY EXP) VAR TERM SYMBOLS))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (ZEROP 0)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR TERM SYMBOLS))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (ZEROP 0)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 0))
                         (LISTP EXP)
                         (p (CAR EXP) VAR TERM SYMBOLS)
                         (p (CDR EXP) VAR TERM SYMBOLS))
                    (p EXP VAR TERM SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 0))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM SYMBOLS))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP can be used to establish that the measure (COUNT EXP)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme leads to 19 new goals:

Case 19.(IMPLIES (AND (ZEROP 0)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, rewriting with CAR-NLISTP, NOT-FUNCTION, and NOT-PREDICATE,
  and opening up the definitions of ZEROP, VARIABLE, ATOMP, OR, NLISTP, and
  FORMULA, to:

        T.

Case 18.(IMPLIES (AND (ZEROP 0)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, rewriting with NOT-PREDICATE, NOT-FUNCTION, and CAR-NLISTP,
  and opening up ZEROP, VARIABLE, FORMULA, NLISTP, OR, and ATOMP, to:

        T.

Case 17.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (NOT (FORMULA (ARG EXP) SYMBOLS))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, opening up ZEROP, VARIABLE, and FORMULA, to:

        T.

Case 16.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (FORMULA (SUBST (ARG EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, rewriting with FORMULA-F-NOT, and opening up ZEROP,
  VARIABLE, FORMULA, SUBST, and EQUAL, to:

        T.

Case 15.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (FORMULA (ARG1 EXP) SYMBOLS))
                      (NOT (FORMULA (ARG2 EXP) SYMBOLS))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, opening up the definitions of ZEROP, VARIABLE, and FORMULA,
  to:

        T.

Case 14.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (FORMULA (SUBST (ARG1 EXP) VAR TERM 0)
                               SYMBOLS)
                      (NOT (FORMULA (ARG2 EXP) SYMBOLS))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, opening up ZEROP, VARIABLE, and FORMULA, to:

        T.

Case 13.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (FORMULA (ARG1 EXP) SYMBOLS))
                      (FORMULA (SUBST (ARG2 EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, expanding ZEROP, VARIABLE, and FORMULA, to:

        T.

Case 12.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (FORMULA (SUBST (ARG1 EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA (SUBST (ARG2 EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, applying FORMULA-F-OR, and expanding the definitions of
  ZEROP, VARIABLE, FORMULA, SUBST, and EQUAL, to:

        T.

Case 11.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQL (BIND EXP) VAR)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, rewriting with NUMBERP-EQL, and unfolding ZEROP, VARIABLE,
  OR, FORMULA, SUBST, and EQUAL, to:

        T.

Case 10.(IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (NOT (FORMULA (BODY EXP) SYMBOLS))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, applying NUMBERP-EQL, and opening up ZEROP, VARIABLE, OR,
  and FORMULA, to:

        T.

Case 9. (IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (FORMULA (SUBST (BODY EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, rewriting with NUMBERP-EQL and FORMULA-FORSOME, and
  unfolding the functions ZEROP, VARIABLE, OR, FORMULA, SUBST, and EQUAL, to:

        T.

Case 8. (IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (FORMULA (CDR EXP) SYMBOLS))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, applying ATOMP-REDUC, SUBST-TERMP, SUBST-LENGTH, DEGREE-P,
  and PREDICATE-P, and unfolding the definitions of ZEROP, VARIABLE, FORMULA,
  SYMB, ATOMP, SUBST, EQUAL, and NUMBERP, to:

        (IMPLIES (AND (LISTP EXP)
                      (NOT (FORMULA (CDR EXP) SYMBOLS))
                      (PREDICATE (CAR EXP))
                      (EQUAL (CAR EXP) (P 0 2))
                      (EQUAL (LENGTH (CDR EXP))
                             (DEGREE (CAR EXP)))
                      (TERMP (CDR EXP) 1 SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (EQUAL (DEGREE (CAR EXP)) 2)).

  This again simplifies, applying PREDICATE-P and DEGREE-P, and opening up the
  definitions of NUMBERP and EQUAL, to:

        T.

Case 7. (IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (FORMULA (SUBST (CDR EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, applying ATOMP-REDUC, SUBST-TERMP, SUBST-LENGTH, DEGREE-P,
  and PREDICATE-P, and opening up ZEROP, VARIABLE, FORMULA, SYMB, ATOMP, SUBST,
  EQUAL, and NUMBERP, to:

        (IMPLIES (AND (LISTP EXP)
                      (FORMULA (SUBST (CDR EXP) VAR TERM 0)
                               SYMBOLS)
                      (PREDICATE (CAR EXP))
                      (EQUAL (CAR EXP) (P 0 2))
                      (EQUAL (LENGTH (CDR EXP))
                             (DEGREE (CAR EXP)))
                      (TERMP (CDR EXP) 1 SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (EQUAL (DEGREE (CAR EXP)) 2)).

  However this again simplifies, applying PREDICATE-P and DEGREE-P, and
  unfolding the definitions of NUMBERP and EQUAL, to:

        T.

Case 6. (IMPLIES (AND (ZEROP 0)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)).

  This simplifies, rewriting with NOT-PREDICATE, NOT-FUNCTION, and CAR-NLISTP,
  and expanding the functions ZEROP, VARIABLE, FORMULA, NLISTP, OR, and ATOMP,
  to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP 0))
                      (LISTP EXP)
                      (NOT (FORMULA (CAR EXP) SYMBOLS))
                      (NOT (FORMULA (CDR EXP) SYMBOLS))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, expanding the definition of ZEROP, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP 0))
                      (LISTP EXP)
                      (FORMULA (SUBST (CAR EXP) VAR TERM 0)
                               SYMBOLS)
                      (NOT (FORMULA (CDR EXP) SYMBOLS))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, opening up the function ZEROP, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP 0))
                      (LISTP EXP)
                      (NOT (FORMULA (CAR EXP) SYMBOLS))
                      (FORMULA (SUBST (CDR EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, unfolding the function ZEROP, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP 0))
                      (LISTP EXP)
                      (FORMULA (SUBST (CAR EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA (SUBST (CDR EXP) VAR TERM 0)
                               SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, opening up the function ZEROP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP 0))
                      (NOT (LISTP EXP))
                      (FORMULA EXP SYMBOLS)
                      (TERMP TERM 0 SYMBOLS))
                 (FORMULA (SUBST EXP VAR TERM 0)
                          SYMBOLS)),

  which simplifies, unfolding the function ZEROP, to:

        T.


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


[ 0.0 0.1 0.0 ]

SUBST-FORMULA


(TOGGLE G0607 ATOMP T)

[ 0.0 0.0 0.0 ]

G0607


(PROVE-LEMMA SUBST-AXIOM-PROVES
             (REWRITE)
             (IMPLIES (AND (EQUAL LHS (SUBST EXP VAR TERM 0))
                           (VARIABLE VAR)
                           (TERMP TERM 0 SYMBOLS)
                           (FORMULA EXP SYMBOLS)
                           (FREE-FOR EXP VAR TERM 0))
                      (PROVES (SUBST-AXIOM-PROOF EXP VAR TERM)
                              (F-IMPLIES LHS (FORSOME VAR EXP))
                              GIVEN DEFNS SYMBOLS))
             ((DISABLE FREE-FOR)))

WARNING:  Note that the rewrite rule SUBST-AXIOM-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations AND, IMPLIES,
F-IMPLIES, and VARIABLE, to:

      (IMPLIES (AND (EQUAL LHS (SUBST EXP VAR TERM 0))
                    (NUMBERP VAR)
                    (TERMP TERM 0 SYMBOLS)
                    (FORMULA EXP SYMBOLS)
                    (FREE-FOR EXP VAR TERM 0))
               (PROVES (SUBST-AXIOM-PROOF EXP VAR TERM)
                       (F-OR (F-NOT LHS) (FORSOME VAR EXP))
                       GIVEN DEFNS SYMBOLS)),

which simplifies, rewriting with FORMULA-F-OR, FORMULA-FORSOME, FORMULA-F-NOT,
SUBST-FORMULA, F-ORP-EQL, FORSOMEP-EQL, F-NOTP-EQL, EQUAL-EQL, CAR-CONS, and
CDR-CONS, and unfolding the functions SUBST-AXIOM, F-IMPLIES,
SUBST-AXIOM-PROOF, PRF, SECOND, FOURTH, VARIABLE, FOL-AXIOM-PROOF, CONC, EQUAL,
THIRD, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

SUBST-AXIOM-PROVES


(PROVE-LEMMA FORMULA-PAIREQUALS
             (REWRITE)
             (IMPLIES (AND (TERMP VARS1 1 SYMBOLS)
                           (TERMP VARS2 1 SYMBOLS)
                           (FORMULA EXP SYMBOLS))
                      (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                               SYMBOLS)))


     Give the conjecture the name *1.


     Perhaps we can prove it by induction.  There are five plausible
inductions.  They merge into three likely candidate inductions, two of which
are unflawed.  However, one of these is more likely than the other.  We will
induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP 1)
                         (LISTP VARS1)
                         (p (CDR VARS1)
                            (CDR VARS2)
                            EXP SYMBOLS))
                    (p VARS1 VARS2 EXP SYMBOLS))
           (IMPLIES (AND (ZEROP 1) (NOT (LISTP VARS1)))
                    (p VARS1 VARS2 EXP SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 1)) (NLISTP VARS1))
                    (p VARS1 VARS2 EXP SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 1))
                         (NOT (NLISTP VARS1))
                         (p (CDR VARS1)
                            (CDR VARS2)
                            EXP SYMBOLS)
                         (p (CAR VARS1) VARS2 EXP SYMBOLS))
                    (p VARS1 VARS2 EXP SYMBOLS))).
Linear arithmetic, the lemmas CDR-LESSP, CDR-LESSEQP, CAR-LESSEQP, and
CAR-LESSP, and the definitions of NLISTP and ZEROP can be used to show that
the measure (COUNT VARS1) decreases according to the well-founded relation
LESSP in each induction step of the scheme.  Note, however, the inductive
instances chosen for VARS2.  The above induction scheme generates 11 new
conjectures:

Case 11.(IMPLIES (AND (ZEROP 1)
                      (LISTP VARS1)
                      (NOT (TERMP (CDR VARS1) 1 SYMBOLS))
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, unfolding the definition of ZEROP, to:

        T.

Case 10.(IMPLIES (AND (ZEROP 1)
                      (LISTP VARS1)
                      (NOT (TERMP (CDR VARS2) 1 SYMBOLS))
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, unfolding the definition of ZEROP, to:

        T.

Case 9. (IMPLIES (AND (ZEROP 1)
                      (LISTP VARS1)
                      (FORMULA (PAIREQUALS (CDR VARS1)
                                           (CDR VARS2)
                                           EXP)
                               SYMBOLS)
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, opening up ZEROP, to:

        T.

Case 8. (IMPLIES (AND (ZEROP 1)
                      (NOT (LISTP VARS1))
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, expanding ZEROP, to:

        T.

Case 7. (IMPLIES (AND (NOT (ZEROP 1))
                      (NLISTP VARS1)
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, unfolding the functions ZEROP, NLISTP, TERMP, EQUAL,
  NUMBERP, and PAIREQUALS, to:

        T.

Case 6. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS1))
                      (NOT (TERMP (CDR VARS1) 1 SYMBOLS))
                      (NOT (TERMP (CAR VARS1) 1 SYMBOLS))
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, expanding the functions ZEROP, NLISTP, TERMP, EQUAL, and
  NUMBERP, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS1))
                      (NOT (TERMP (CDR VARS2) 1 SYMBOLS))
                      (NOT (TERMP (CAR VARS1) 1 SYMBOLS))
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, expanding the functions ZEROP, NLISTP, TERMP, EQUAL,
  NUMBERP, and PAIREQUALS, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS1))
                      (FORMULA (PAIREQUALS (CDR VARS1)
                                           (CDR VARS2)
                                           EXP)
                               SYMBOLS)
                      (NOT (TERMP (CAR VARS1) 1 SYMBOLS))
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, expanding the definitions of ZEROP, NLISTP, TERMP, EQUAL,
  NUMBERP, PAIREQUALS, and F-IMPLIES, to:

        (IMPLIES (AND (LISTP VARS1)
                      (FORMULA (PAIREQUALS (CDR VARS1)
                                           (CDR VARS2)
                                           EXP)
                               SYMBOLS)
                      (NOT (TERMP (CAR VARS1) 1 SYMBOLS))
                      (TERMP (CAR VARS1) 0 SYMBOLS)
                      (TERMP (CDR VARS1) 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (LISTP VARS2))
                 (FORMULA (F-OR (F-NOT (F-EQUAL (CAR VARS1) (CAR VARS2)))
                                (PAIREQUALS (CDR VARS1)
                                            (CDR VARS2)
                                            EXP))
                          SYMBOLS)).

  This again simplifies, applying FORMULA-F-EQUAL, FORMULA-F-NOT, and
  FORMULA-F-OR, to:

        (IMPLIES (AND (LISTP VARS1)
                      (FORMULA (PAIREQUALS (CDR VARS1)
                                           (CDR VARS2)
                                           EXP)
                               SYMBOLS)
                      (NOT (TERMP (CAR VARS1) 1 SYMBOLS))
                      (TERMP (CAR VARS1) 0 SYMBOLS)
                      (TERMP (CDR VARS1) 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (LISTP VARS2))
                 (TERMP (CAR VARS2) 0 SYMBOLS)),

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

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS1))
                      (NOT (TERMP (CDR VARS1) 1 SYMBOLS))
                      (FORMULA (PAIREQUALS (CAR VARS1) VARS2 EXP)
                               SYMBOLS)
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, opening up ZEROP, NLISTP, TERMP, EQUAL, and NUMBERP, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS1))
                      (NOT (TERMP (CDR VARS2) 1 SYMBOLS))
                      (FORMULA (PAIREQUALS (CAR VARS1) VARS2 EXP)
                               SYMBOLS)
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, expanding ZEROP, NLISTP, TERMP, EQUAL, NUMBERP, and
  PAIREQUALS, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS1))
                      (FORMULA (PAIREQUALS (CDR VARS1)
                                           (CDR VARS2)
                                           EXP)
                               SYMBOLS)
                      (FORMULA (PAIREQUALS (CAR VARS1) VARS2 EXP)
                               SYMBOLS)
                      (TERMP VARS1 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORMULA (PAIREQUALS VARS1 VARS2 EXP)
                          SYMBOLS)),

  which simplifies, opening up the functions ZEROP, NLISTP, TERMP, EQUAL,
  NUMBERP, PAIREQUALS, and F-IMPLIES, to:

        (IMPLIES (AND (LISTP VARS1)
                      (FORMULA (PAIREQUALS (CDR VARS1)
                                           (CDR VARS2)
                                           EXP)
                               SYMBOLS)
                      (FORMULA (PAIREQUALS (CAR VARS1) VARS2 EXP)
                               SYMBOLS)
                      (TERMP (CAR VARS1) 0 SYMBOLS)
                      (TERMP (CDR VARS1) 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (LISTP VARS2))
                 (FORMULA (F-OR (F-NOT (F-EQUAL (CAR VARS1) (CAR VARS2)))
                                (PAIREQUALS (CDR VARS1)
                                            (CDR VARS2)
                                            EXP))
                          SYMBOLS)).

  This again simplifies, appealing to the lemmas FORMULA-F-EQUAL,
  FORMULA-F-NOT, and FORMULA-F-OR, to the goal:

        (IMPLIES (AND (LISTP VARS1)
                      (FORMULA (PAIREQUALS (CDR VARS1)
                                           (CDR VARS2)
                                           EXP)
                               SYMBOLS)
                      (FORMULA (PAIREQUALS (CAR VARS1) VARS2 EXP)
                               SYMBOLS)
                      (TERMP (CAR VARS1) 0 SYMBOLS)
                      (TERMP (CDR VARS1) 1 SYMBOLS)
                      (TERMP VARS2 1 SYMBOLS)
                      (FORMULA EXP SYMBOLS)
                      (LISTP VARS2))
                 (TERMP (CAR VARS2) 0 SYMBOLS)).

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

        T.


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


[ 0.0 0.1 0.0 ]

FORMULA-PAIREQUALS


(PROVE-LEMMA EQUAL-AXIOM1-PROVES
             (REWRITE)
             (IMPLIES (AND (FUNCTION FN)
                           (SYMB FN SYMBOLS)
                           (EQUAL (LENGTH VARS1) (DEGREE FN))
                           (EQUAL (LENGTH VARS2) (DEGREE FN))
                           (TERMP VARS1 1 SYMBOLS)
                           (TERMP VARS2 1 SYMBOLS)
                           (EQUAL CONCL
                                  (EQUAL-AXIOM1 VARS1 VARS2 FN)))
                      (PROVES (EQUAL-AXIOM1-PROOF FN VARS1 VARS2)
                              CONCL GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule EQUAL-AXIOM1-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture simplifies, applying the lemmas DEGREE-P, NOT-FUNCTION,
PREDICATE-P, EQUAL-EQL, CAR-CONS, CDR-CONS, FORMULA-PAIREQUALS, and
FORMULA-F-EQUAL, and expanding the definitions of SYMB, NUMBERP, EQUAL-AXIOM1,
EQUAL-AXIOM1-PROOF, PRF, SECOND, NLISTP, OR, FOURTH, FOL-AXIOM-PROOF, CONC,
EQUAL, THIRD, PROVES, and TERMP, to:

      (IMPLIES (AND (FUNCTION FN)
                    (EQUAL FN (P 0 2))
                    (EQUAL (LENGTH VARS1) 2)
                    (EQUAL (LENGTH VARS2) 2)
                    (TERMP VARS1 1 SYMBOLS))
               (NOT (TERMP VARS2 1 SYMBOLS))),

which again simplifies, rewriting with PREDICATE-P and NOT-FUNCTION, and
opening up the definitions of OR and NLISTP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EQUAL-AXIOM1-PROVES


(PROVE-LEMMA EQUAL-AXIOM2-PROVES
             (REWRITE)
             (IMPLIES (AND (PREDICATE PR)
                           (SYMB PR SYMBOLS)
                           (EQUAL (LENGTH VARS1) (DEGREE PR))
                           (EQUAL (LENGTH VARS2) (DEGREE PR))
                           (TERMP VARS1 1 SYMBOLS)
                           (TERMP VARS2 1 SYMBOLS)
                           (EQUAL CONCL
                                  (EQUAL-AXIOM2 VARS1 VARS2 PR)))
                      (PROVES (EQUAL-AXIOM2-PROOF PR VARS1 VARS2)
                              CONCL GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule EQUAL-AXIOM2-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture simplifies, applying the lemmas DEGREE-P, FORMULA-PAIREQUALS,
ATOMP-REDUC, PREDICATE-P, FORMULA-F-NOT, FORMULA-F-OR, EQUAL-EQL, CAR-CONS,
and CDR-CONS, and expanding the definitions of SYMB, NUMBERP, EQUAL-AXIOM2,
F-IMPLIES, EQUAL-AXIOM2-PROOF, PRF, SECOND, FOURTH, FOL-AXIOM-PROOF, FORMULA,
CONC, EQUAL, THIRD, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EQUAL-AXIOM2-PROVES


(PROVE-LEMMA IDENT-AXIOM-PROVES
             (REWRITE)
             (IMPLIES (TERMP VAR 0 SYMBOLS)
                      (PROVES (IDENT-AXIOM-PROOF VAR)
                              (F-EQUAL VAR VAR)
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule IDENT-AXIOM-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This formula simplifies, applying FORMULA-F-EQUAL, EQUAL-EQL, CAR-CONS, and
CDR-CONS, and unfolding IDENT-AXIOM-PROOF, PRF, SECOND, FOL-AXIOM-PROOF, CONC,
EQUAL, THIRD, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

IDENT-AXIOM-PROVES


(DEFN ASSUM-PROOF
      (EXP)
      (LIST 5 NIL EXP))

     From the definition we can conclude that (LISTP (ASSUM-PROOF EXP)) is a
theorem.




[ 0.0 0.0 0.0 ]

ASSUM-PROOF


(PROVE-LEMMA ASSUM-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (MEMBER EXP GIVEN)
                           (FORMULA EXP SYMBOLS))
                      (PROVES (ASSUM-PROOF EXP)
                              EXP GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule ASSUM-PROOF-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture can be simplified, using the abbreviations AND, IMPLIES, and
ASSUM-PROOF, to:

      (IMPLIES (AND (MEMBER EXP GIVEN)
                    (FORMULA EXP SYMBOLS))
               (PROVES (LIST 5 NIL EXP)
                       EXP GIVEN DEFNS SYMBOLS)).

This simplifies, applying EQUAL-EQL, CAR-CONS, and CDR-CONS, and expanding PRF,
CONC, EQUAL, THIRD, and PROVES, to:

      (IMPLIES (AND (MEMBER EXP GIVEN)
                    (FORMULA EXP SYMBOLS))
               (MEMB EXP GIVEN)).

Give the above formula the name *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 (NLISTP GIVEN)
                    (p EXP GIVEN SYMBOLS))
           (IMPLIES (AND (NOT (NLISTP GIVEN))
                         (EQUAL EXP (CAR GIVEN)))
                    (p EXP GIVEN SYMBOLS))
           (IMPLIES (AND (NOT (NLISTP GIVEN))
                         (NOT (EQUAL EXP (CAR GIVEN)))
                         (p EXP (CDR GIVEN) SYMBOLS))
                    (p EXP GIVEN SYMBOLS))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT GIVEN) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces the following four new goals:

Case 4. (IMPLIES (AND (NLISTP GIVEN)
                      (MEMBER EXP GIVEN)
                      (FORMULA EXP SYMBOLS))
                 (MEMB EXP GIVEN)).

  This simplifies, expanding NLISTP and MEMBER, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP GIVEN))
                      (EQUAL EXP (CAR GIVEN))
                      (MEMBER EXP GIVEN)
                      (FORMULA EXP SYMBOLS))
                 (MEMB EXP GIVEN)).

  This simplifies, rewriting with the lemma EQUAL-EQL, and expanding the
  functions NLISTP, MEMBER, and MEMB, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP GIVEN))
                      (NOT (EQUAL EXP (CAR GIVEN)))
                      (NOT (MEMBER EXP (CDR GIVEN)))
                      (MEMBER EXP GIVEN)
                      (FORMULA EXP SYMBOLS))
                 (MEMB EXP GIVEN)).

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

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP GIVEN))
                      (NOT (EQUAL EXP (CAR GIVEN)))
                      (MEMB EXP (CDR GIVEN))
                      (MEMBER EXP GIVEN)
                      (FORMULA EXP SYMBOLS))
                 (MEMB EXP GIVEN)).

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

        T.


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


[ 0.0 0.0 0.0 ]

ASSUM-PROOF-PROVES


(PROVE-LEMMA MEMB-MEMBER
             (REWRITE)
             (IMPLIES (MEMBER X Y) (MEMB X Y)))


     Give the conjecture the name *1.


     We will appeal to induction.  Two inductions are suggested by terms in
the conjecture.  However, they merge into one likely candidate induction.  We
will induct according to the following scheme:
      (AND (IMPLIES (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 produces the following four new conjectures:

Case 4. (IMPLIES (AND (NLISTP Y) (MEMBER X Y))
                 (MEMB X Y)).

  This simplifies, expanding the functions NLISTP and MEMBER, to:

        T.

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

  This simplifies, rewriting with the lemma EQUAL-EQL, and opening up NLISTP,
  MEMBER, and MEMB, to:

        T.

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

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

        T.

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

  This simplifies, opening up NLISTP, MEMBER, and MEMB, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMB-MEMBER


(DEFN FUN-DEFN-PROOF
      (FN VARS X Y EXP PF1 PF2)
      (LIST 4
            (LIST (CONS FN VARS) X EXP Y)
            (SUBST EXP X (CONS FN VARS) 0)
            (LIST PF1 PF2)))

     From the definition we can conclude that:
      (LISTP (FUN-DEFN-PROOF FN VARS X Y EXP PF1 PF2))
is a theorem.




[ 0.0 0.0 0.0 ]

FUN-DEFN-PROOF


(PROVE-LEMMA FUN-DEFN-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (VAR-LIST VARS (DEGREE FN))
                           (VARIABLE X)
                           (VARIABLE Y)
                           (SET (CONS Y (CONS X VARS)))
                           (FUNCTION FN)
                           (SYMB FN SYMBOLS)
                           (FORMULA A-PRIME SYMBOLS)
                           (SUBSET (COLLECT-FREE EXP 0)
                                   (CONS X VARS))
                           (FREE-FOR EXP X (CONS FN VARS) 0)
                           (FREE-FOR EXP X Y 0)
                           (EQUAL A-PRIME (ASSOC FN DEFNS))
                           (PROVES PF1
                                   (FORSOME X EXP)
                                   GIVEN DEFNS
                                   (REST-OF FN SYMBOLS))
                           (PROVES PF2
                                   (F-IMPLIES (F-AND EXP (SUBST EXP X Y 0))
                                              (F-EQUAL X Y))
                                   GIVEN DEFNS
                                   (REST-OF FN SYMBOLS))
                           (EQUAL A-PRIME
                                  (SUBST EXP X (CONS FN VARS) 0)))
                      (PROVES (FUN-DEFN-PROOF FN VARS X Y EXP PF1 PF2)
                              A-PRIME GIVEN DEFNS SYMBOLS))
             ((DISABLE COLLECT-FREE FREE-FOR SYMB EQL SUBSET SET)))

WARNING:  Note that the rewrite rule FUN-DEFN-PROOF-PROVES will be stored so
as to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations FORMULA-F-EQUAL,
FORMULA-F-NOT, FORMULA-F-OR, FORMULA-FORSOME, PROVES, AND, IMPLIES, F-AND,
F-IMPLIES, and VARIABLE, to the new formula:

      (IMPLIES (AND (VAR-LIST VARS (DEGREE FN))
                    (NUMBERP X)
                    (NUMBERP Y)
                    (SET (CONS Y (CONS X VARS)))
                    (FUNCTION FN)
                    (SYMB FN SYMBOLS)
                    (FORMULA A-PRIME SYMBOLS)
                    (SUBSET (COLLECT-FREE EXP 0)
                            (CONS X VARS))
                    (FREE-FOR EXP X (CONS FN VARS) 0)
                    (FREE-FOR EXP X Y 0)
                    (EQUAL A-PRIME (ASSOC FN DEFNS))
                    (EQL (CONC PF1 0) (FORSOME X EXP))
                    (FORMULA EXP (REST-OF FN SYMBOLS))
                    (PRF PF1 GIVEN DEFNS 0
                         (REST-OF FN SYMBOLS))
                    (EQL (CONC PF2 0)
                         (F-OR (F-NOT (F-NOT (F-OR (F-NOT EXP)
                                                   (F-NOT (SUBST EXP X Y 0)))))
                               (F-EQUAL X Y)))
                    (FORMULA (SUBST EXP X Y 0)
                             (REST-OF FN SYMBOLS))
                    (TERMP X 0 (REST-OF FN SYMBOLS))
                    (TERMP Y 0 (REST-OF FN SYMBOLS))
                    (PRF PF2 GIVEN DEFNS 0
                         (REST-OF FN SYMBOLS))
                    (EQUAL A-PRIME
                           (SUBST EXP X (CONS FN VARS) 0)))
               (PROVES (FUN-DEFN-PROOF FN VARS X Y EXP PF1 PF2)
                       A-PRIME GIVEN DEFNS SYMBOLS)),

which simplifies, applying SUBST-FORMULA, LISTP-EQL, SUB-SUBSET, NOT-PREDICATE,
EQUAL-EQL, CAR-CONS, and CDR-CONS, and unfolding the functions THIRD, EQUAL,
CONC, VARIABLE, TERMP, FUN-DEFN-PROOF, PRF, SECOND, FOURTH, NUMBERP, LISTP,
F-IMPLIES, F-AND, NLISTP, OR, SYMB-DEFN-PROOF, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.3 0.0 ]

FUN-DEFN-PROOF-PROVES


(TOGGLE G0591 FUN-DEFN-PROOF T)

[ 0.0 0.0 0.0 ]

G0591


(DEFN PRED-DEFN-PROOF
      (PR VARS DEFN)
      (LIST 4
            (LIST (CONS PR VARS))
            (F-IFF (CONS PR VARS) DEFN)))

     From the definition we can conclude that:
      (LISTP (PRED-DEFN-PROOF PR VARS DEFN))
is a theorem.




[ 0.0 0.0 0.0 ]

PRED-DEFN-PROOF


(PROVE-LEMMA VAR-LIST-TERMP
             (REWRITE)
             (IMPLIES (VAR-LIST VARS (LENGTH VARS))
                      (TERMP VARS 1 SYMBOLS)))


     Give the conjecture the name *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 (ZEROP 1)
                         (LISTP VARS)
                         (p (CDR VARS) SYMBOLS))
                    (p VARS SYMBOLS))
           (IMPLIES (AND (ZEROP 1) (NOT (LISTP VARS)))
                    (p VARS SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 1)) (NLISTP VARS))
                    (p VARS SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP 1))
                         (NOT (NLISTP VARS))
                         (p (CAR VARS) SYMBOLS)
                         (p (CDR VARS) SYMBOLS))
                    (p VARS SYMBOLS))).
Linear arithmetic, the lemmas CDR-LESSP, CDR-LESSEQP, CAR-LESSEQP, and
CAR-LESSP, and the definitions of NLISTP and ZEROP inform us that the measure
(COUNT VARS) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates eight new
goals:

Case 8. (IMPLIES (AND (ZEROP 1)
                      (LISTP VARS)
                      (NOT (VAR-LIST (CDR VARS)
                                     (LENGTH (CDR VARS))))
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)),

  which simplifies, expanding ZEROP, to:

        T.

Case 7. (IMPLIES (AND (ZEROP 1)
                      (LISTP VARS)
                      (TERMP (CDR VARS) 1 SYMBOLS)
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)),

  which simplifies, opening up the function ZEROP, to:

        T.

Case 6. (IMPLIES (AND (ZEROP 1)
                      (NOT (LISTP VARS))
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)),

  which simplifies, opening up the definition of ZEROP, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP 1))
                      (NLISTP VARS)
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)),

  which simplifies, opening up ZEROP, NLISTP, LENGTH, EQUAL, VAR-LIST, TERMP,
  and NUMBERP, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS))
                      (NOT (VAR-LIST (CAR VARS)
                                     (LENGTH (CAR VARS))))
                      (NOT (VAR-LIST (CDR VARS)
                                     (LENGTH (CDR VARS))))
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)),

  which simplifies, appealing to the lemma SUB1-ADD1, and opening up the
  functions ZEROP, NLISTP, LENGTH, VARIABLE, and VAR-LIST, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS))
                      (TERMP (CAR VARS) 1 SYMBOLS)
                      (NOT (VAR-LIST (CDR VARS)
                                     (LENGTH (CDR VARS))))
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)),

  which simplifies, applying SUB1-ADD1, and unfolding the functions ZEROP,
  NLISTP, LENGTH, VARIABLE, and VAR-LIST, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS))
                      (NOT (VAR-LIST (CAR VARS)
                                     (LENGTH (CAR VARS))))
                      (TERMP (CDR VARS) 1 SYMBOLS)
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)).

  This simplifies, rewriting with SUB1-ADD1, and expanding ZEROP, NLISTP,
  LENGTH, VARIABLE, VAR-LIST, TERMP, EQUAL, and NUMBERP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP 1))
                      (NOT (NLISTP VARS))
                      (TERMP (CAR VARS) 1 SYMBOLS)
                      (TERMP (CDR VARS) 1 SYMBOLS)
                      (VAR-LIST VARS (LENGTH VARS)))
                 (TERMP VARS 1 SYMBOLS)),

  which simplifies, applying the lemma SUB1-ADD1, and opening up the functions
  ZEROP, NLISTP, LENGTH, VARIABLE, VAR-LIST, TERMP, EQUAL, and NUMBERP, to:

        T.


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


[ 0.0 0.0 0.0 ]

VAR-LIST-TERMP


(PROVE-LEMMA VAR-LIST-LENGTH
             (REWRITE)
             (IMPLIES (NOT (EQUAL (LENGTH VARS) (FIX N)))
                      (NOT (VAR-LIST VARS N))))

This formula simplifies, opening up the functions FIX and VAR-LIST, to the
following two new goals:

Case 2. (IMPLIES (AND (NOT (NUMBERP N))
                      (NOT (EQUAL (LENGTH VARS) 0)))
                 (LISTP VARS)).

  However this again simplifies, unfolding the functions LENGTH and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP N)
                      (NOT (EQUAL (LENGTH VARS) N)))
                 (NOT (VAR-LIST VARS N))),

  which we will name *1.


     Perhaps we can prove it by induction.  The recursive terms in the
conjecture suggest three inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP VARS)
                         (p (CDR VARS) (SUB1 N)))
                    (p VARS N))
           (IMPLIES (NOT (LISTP VARS))
                    (p VARS N))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT VARS) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  Note, however, the inductive instance chosen
for N.  The above induction scheme generates the following three new
conjectures:

Case 3. (IMPLIES (AND (LISTP VARS)
                      (EQUAL (LENGTH (CDR VARS)) (SUB1 N))
                      (NUMBERP N)
                      (NOT (EQUAL (LENGTH VARS) N)))
                 (NOT (VAR-LIST VARS N))).

  This simplifies, rewriting with the lemma ADD1-SUB1, and opening up the
  definitions of LENGTH, EQUAL, and VAR-LIST, to:

        T.

Case 2. (IMPLIES (AND (LISTP VARS)
                      (NOT (VAR-LIST (CDR VARS) (SUB1 N)))
                      (NUMBERP N)
                      (NOT (EQUAL (LENGTH VARS) N)))
                 (NOT (VAR-LIST VARS N))).

  This simplifies, opening up the definitions of LENGTH, VAR-LIST, and
  VARIABLE, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP VARS))
                      (NUMBERP N)
                      (NOT (EQUAL (LENGTH VARS) N)))
                 (NOT (VAR-LIST VARS N))).

  This simplifies, opening up the functions LENGTH and VAR-LIST, to:

        T.


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


[ 0.0 0.0 0.0 ]

VAR-LIST-LENGTH


(PROVE-LEMMA MEMB-REST-OF
             (REWRITE)
             (IMPLIES (NOT (MEMB X Z))
                      (NOT (MEMB X (REST-OF Y Z)))))


     Name the conjecture *1.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest two inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP Z) (EQL X (CAR Z)))
                    (p X Y Z))
           (IMPLIES (AND (LISTP Z)
                         (NOT (EQL X (CAR Z)))
                         (p X Y (CDR Z)))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP Z)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP can be used to show 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 the
following four new goals:

Case 4. (IMPLIES (AND (LISTP Z)
                      (EQL X (CAR Z))
                      (NOT (MEMB X Z)))
                 (NOT (MEMB X (REST-OF Y Z)))).

  This simplifies, expanding the definition of MEMB, to:

        T.

Case 3. (IMPLIES (AND (LISTP Z)
                      (NOT (EQL X (CAR Z)))
                      (MEMB X (CDR Z))
                      (NOT (MEMB X Z)))
                 (NOT (MEMB X (REST-OF Y Z)))).

  This simplifies, unfolding MEMB, to:

        T.

Case 2. (IMPLIES (AND (LISTP Z)
                      (NOT (EQL X (CAR Z)))
                      (NOT (MEMB X (REST-OF Y (CDR Z))))
                      (NOT (MEMB X Z)))
                 (NOT (MEMB X (REST-OF Y Z)))).

  This simplifies, rewriting with EQL-COMM, and expanding the definitions of
  MEMB and REST-OF, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Z)) (NOT (MEMB X Z)))
                 (NOT (MEMB X (REST-OF Y Z)))),

  which simplifies, expanding the functions MEMB, REST-OF, and LISTP, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMB-REST-OF


(PROVE-LEMMA TERMP-REST-OF
             (REWRITE)
             (IMPLIES (NOT (TERMP EXP FLG SYMBOLS))
                      (NOT (TERMP EXP FLG
                                  (REST-OF SYMB SYMBOLS)))))


     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 (ZEROP FLG)
                         (LISTP EXP)
                         (p (CDR EXP) 1 SYMB SYMBOLS))
                    (p EXP FLG SYMB SYMBOLS))
           (IMPLIES (AND (ZEROP FLG) (NOT (LISTP EXP)))
                    (p EXP FLG SYMB SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP FLG)) (NLISTP EXP))
                    (p EXP FLG SYMB SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (NLISTP EXP))
                         (p (CDR EXP) 1 SYMB SYMBOLS)
                         (p (CAR EXP) 0 SYMB SYMBOLS))
                    (p EXP FLG SYMB SYMBOLS))).
Linear arithmetic, the lemmas CDR-LESSP, CDR-LESSEQP, CAR-LESSEQP, and
CAR-LESSP, and the definitions of NLISTP and ZEROP inform us that the measure
(COUNT EXP) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  Note, however, the inductive instances chosen
for FLG.  The above induction scheme generates eight new goals:

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (LISTP EXP)
                      (TERMP (CDR EXP) 1 SYMBOLS)
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

  which simplifies, appealing to the lemma MEMB-REST-OF, and unfolding ZEROP,
  SYMB, EQUAL, and TERMP, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (LISTP EXP)
                      (NOT (TERMP (CDR EXP)
                                  1
                                  (REST-OF SYMB SYMBOLS)))
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

  which simplifies, rewriting with the lemma MEMB-REST-OF, and expanding the
  functions ZEROP, SYMB, EQUAL, and TERMP, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (LISTP EXP))
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

  which simplifies, opening up the definitions of ZEROP, VARIABLE, EQUAL, and
  TERMP, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NLISTP EXP)
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

  which simplifies, expanding ZEROP, NLISTP, and TERMP, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (TERMP (CDR EXP) 1 SYMBOLS)
                      (TERMP (CAR EXP) 0 SYMBOLS)
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

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

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (NOT (TERMP (CDR EXP)
                                  1
                                  (REST-OF SYMB SYMBOLS)))
                      (TERMP (CAR EXP) 0 SYMBOLS)
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

  which simplifies, unfolding the functions ZEROP, NLISTP, and TERMP, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (TERMP (CDR EXP) 1 SYMBOLS)
                      (NOT (TERMP (CAR EXP)
                                  0
                                  (REST-OF SYMB SYMBOLS)))
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

  which simplifies, opening up ZEROP, NLISTP, and TERMP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (NOT (TERMP (CDR EXP)
                                  1
                                  (REST-OF SYMB SYMBOLS)))
                      (NOT (TERMP (CAR EXP)
                                  0
                                  (REST-OF SYMB SYMBOLS)))
                      (NOT (TERMP EXP FLG SYMBOLS)))
                 (NOT (TERMP EXP FLG
                             (REST-OF SYMB SYMBOLS)))),

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

        T.


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


[ 0.0 0.1 0.0 ]

TERMP-REST-OF


(TOGGLE G0594 ATOMP NIL)

[ 0.0 0.0 0.0 ]

G0594


(PROVE-LEMMA FORMULA-REST-OF
             (REWRITE)
             (IMPLIES (NOT (FORMULA EXP SYMBOLS))
                      (NOT (FORMULA EXP
                                    (REST-OF SYMB SYMBOLS)))))


     Name the conjecture *1.


     Let us appeal to the induction principle.  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 (F-NOTP EXP)
                         (p (ARG EXP) SYMB SYMBOLS))
                    (p EXP SYMB SYMBOLS))
           (IMPLIES (AND (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG2 EXP) SYMB SYMBOLS)
                         (p (ARG1 EXP) SYMB SYMBOLS))
                    (p EXP SYMB SYMBOLS))
           (IMPLIES (AND (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (p (BODY EXP) SYMB SYMBOLS))
                    (p EXP SYMB SYMBOLS))
           (IMPLIES (AND (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP)))
                    (p EXP SYMB SYMBOLS))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, and
BODY-LESSP can be used to show that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  The above induction scheme leads to the following nine new goals:

Case 9. (IMPLIES (AND (F-NOTP EXP)
                      (FORMULA (ARG EXP) SYMBOLS)
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, expanding the definition of FORMULA, to:

        T.

Case 8. (IMPLIES (AND (F-NOTP EXP)
                      (NOT (FORMULA (ARG EXP)
                                    (REST-OF SYMB SYMBOLS)))
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, unfolding FORMULA, to:

        T.

Case 7. (IMPLIES (AND (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (FORMULA (ARG2 EXP) SYMBOLS)
                      (FORMULA (ARG1 EXP) SYMBOLS)
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, unfolding the definition of FORMULA, to:

        T.

Case 6. (IMPLIES (AND (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (FORMULA (ARG2 EXP)
                                    (REST-OF SYMB SYMBOLS)))
                      (FORMULA (ARG1 EXP) SYMBOLS)
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, expanding the definition of FORMULA, to:

        T.

Case 5. (IMPLIES (AND (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (FORMULA (ARG2 EXP) SYMBOLS)
                      (NOT (FORMULA (ARG1 EXP)
                                    (REST-OF SYMB SYMBOLS)))
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, expanding the definition of FORMULA, to:

        T.

Case 4. (IMPLIES (AND (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (FORMULA (ARG2 EXP)
                                    (REST-OF SYMB SYMBOLS)))
                      (NOT (FORMULA (ARG1 EXP)
                                    (REST-OF SYMB SYMBOLS)))
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, expanding the function FORMULA, to:

        T.

Case 3. (IMPLIES (AND (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (FORMULA (BODY EXP) SYMBOLS)
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

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

        T.

Case 2. (IMPLIES (AND (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (FORMULA (BODY EXP)
                                    (REST-OF SYMB SYMBOLS)))
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, unfolding the function FORMULA, to:

        T.

Case 1. (IMPLIES (AND (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (FORMULA EXP SYMBOLS)))
                 (NOT (FORMULA EXP
                               (REST-OF SYMB SYMBOLS)))).

  This simplifies, applying MEMB-REST-OF and TERMP-REST-OF, and expanding the
  definitions of FORMULA, SYMB, and ATOMP, to:

        T.


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


[ 0.0 0.1 0.0 ]

FORMULA-REST-OF


(TOGGLE G0595 ATOMP T)

[ 0.0 0.0 0.0 ]

G0595


(PROVE-LEMMA PRED-DEFN-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (VAR-LIST VARS (DEGREE PR))
                           (SET VARS)
                           (PREDICATE PR)
                           (SYMB PR SYMBOLS)
                           (EQUAL DEFN (ASSOC PR DEFNS))
                           (FORMULA DEFN (REST-OF PR SYMBOLS))
                           (SUBSET (COLLECT-FREE DEFN 0) VARS)
                           (EQUAL CONCL
                                  (F-IFF (CONS PR VARS) DEFN)))
                      (PROVES (PRED-DEFN-PROOF PR VARS DEFN)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((DISABLE COLLECT-FREE SYMB)))

WARNING:  Note that the rewrite rule PRED-DEFN-PROOF-PROVES will be stored so
as to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture simplifies, applying the lemmas SUB-SUBSET, NOT-FUNCTION,
FORMULA-F-OR, FORMULA-F-NOT, VAR-LIST-TERMP, ATOMP-REDUC, F-ORP-EQL,
F-NOTP-EQL, LISTP-EQL, EQUAL-EQL, CAR-CONS, and CDR-CONS, and opening up the
definitions of F-IFF, F-IMPLIES, F-AND, PRED-DEFN-PROOF, PRF, SECOND, CAR,
FOURTH, LISTP, NUMBERP, SYMB-DEFN-PROOF, OR, NLISTP, FORMULA, CONC, EQUAL,
THIRD, and PROVES, to the following two new conjectures:

Case 2. (IMPLIES (AND (VAR-LIST VARS (DEGREE PR))
                      (SET VARS)
                      (PREDICATE PR)
                      (SYMB PR SYMBOLS)
                      (FORMULA (ASSOC PR DEFNS)
                               (REST-OF PR SYMBOLS))
                      (SUBSET (COLLECT-FREE (ASSOC PR DEFNS) 0)
                              VARS))
                 (EQUAL (LENGTH VARS) (DEGREE PR))).

  But this again simplifies, applying VAR-LIST-LENGTH, and unfolding FIX, to:

        T.

Case 1. (IMPLIES (AND (VAR-LIST VARS (DEGREE PR))
                      (SET VARS)
                      (PREDICATE PR)
                      (SYMB PR SYMBOLS)
                      (FORMULA (ASSOC PR DEFNS)
                               (REST-OF PR SYMBOLS))
                      (SUBSET (COLLECT-FREE (ASSOC PR DEFNS) 0)
                              VARS))
                 (FORMULA (ASSOC PR DEFNS) SYMBOLS)).

  This again simplifies, applying FORMULA-REST-OF, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PRED-DEFN-PROOF-PROVES


(TOGGLE G0592 PRED-DEFN-PROOF T)

[ 0.0 0.0 0.0 ]

G0592


(DEFN EXPAN-PROOF
      (A B PF)
      (LIST 2
            (LIST 1 A)
            (F-OR A B)
            (LIST PF)))

     Note that (LISTP (EXPAN-PROOF A B PF)) is a theorem.




[ 0.0 0.0 0.0 ]

EXPAN-PROOF


(DEFN CONTRAC-PROOF
      (A PF)
      (LIST 2 (LIST 2 A) A (LIST PF)))

     Observe that (LISTP (CONTRAC-PROOF A PF)) is a theorem.




[ 0.0 0.0 0.0 ]

CONTRAC-PROOF


(DEFN ASSOC-PROOF
      (A B C PF)
      (LIST 2
            (LIST 3 A B C)
            (F-OR (F-OR A B) C)
            (LIST PF)))

     Observe that (LISTP (ASSOC-PROOF A B C PF)) is a theorem.




[ 0.0 0.0 0.0 ]

ASSOC-PROOF


(DEFN CUT-PROOF
      (A B C PF1 PF2)
      (LIST 2
            (LIST 4 A B C)
            (F-OR B C)
            (LIST PF1 PF2)))

     Note that (LISTP (CUT-PROOF A B C PF1 PF2)) is a theorem.




[ 0.0 0.0 0.0 ]

CUT-PROOF


(DEFN FORSOME-INTRO-PROOF
      (VAR A B PF)
      (LIST 2
            (LIST 5 VAR A B)
            (F-IMPLIES (FORSOME VAR A) B)
            (LIST PF)))

     Observe that (LISTP (FORSOME-INTRO-PROOF VAR A B PF)) is a theorem.




[ 0.0 0.0 0.0 ]

FORSOME-INTRO-PROOF


(TOGGLE G0624 FOL-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G0624


(TOGGLE G0625 FUN-DEFN-PROOF T)

[ 0.0 0.0 0.0 ]

G0625


(PROVE-LEMMA EXPAN-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA A SYMBOLS)
                           (PROVES PF B GIVEN DEFNS SYMBOLS))
                      (PROVES (EXPAN-PROOF A B PF)
                              (F-OR A B)
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule EXPAN-PROOF-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture can be simplified, using the abbreviations PROVES, AND, and
IMPLIES, to:

      (IMPLIES (AND (FORMULA A SYMBOLS)
                    (EQL (CONC PF 0) B)
                    (FORMULA B SYMBOLS)
                    (PRF PF GIVEN DEFNS 0 SYMBOLS))
               (PROVES (EXPAN-PROOF A B PF)
                       (F-OR A B)
                       GIVEN DEFNS SYMBOLS)).

This simplifies, rewriting with the lemmas EQL-COMM, FORMULA-F-OR, F-ORP-EQL,
EQUAL-EQL, CAR-CONS, and CDR-CONS, and opening up the functions THIRD, EQUAL,
CONC, EXPAN-PROOF, PRF, SECOND, FOURTH, NUMBERP, LISTP, FOL-RULES, and PROVES,
to:

      (IMPLIES (AND (FORMULA A SYMBOLS)
                    (EQL B (CADDR PF))
                    (FORMULA B SYMBOLS)
                    (PRF PF GIVEN DEFNS 0 SYMBOLS))
               (FORMULA (CADDR PF) SYMBOLS)),

which again simplifies, unfolding the functions CONC, THIRD, EQUAL, and PRF,
to:

      T.

Q.E.D.


[ 0.0 1.6 0.0 ]

EXPAN-PROOF-PROVES


(PROVE-LEMMA ASSOC-PROOF-PROVES
             (REWRITE)
             (IMPLIES (PROVES PF
                              (F-OR A (F-OR B C))
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (ASSOC-PROOF A B C PF)
                              (F-OR (F-OR A B) C)
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule ASSOC-PROOF-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture can be simplified, using the abbreviations FORMULA-F-OR,
PROVES, and IMPLIES, to:

      (IMPLIES (AND (EQL (CONC PF 0) (F-OR A (F-OR B C)))
                    (FORMULA A SYMBOLS)
                    (FORMULA B SYMBOLS)
                    (FORMULA C SYMBOLS)
                    (PRF PF GIVEN DEFNS 0 SYMBOLS))
               (PROVES (ASSOC-PROOF A B C PF)
                       (F-OR (F-OR A B) C)
                       GIVEN DEFNS SYMBOLS)).

This simplifies, applying the lemmas ARG2-F-OR, ARG1-F-OR, EQL-COMM, LISTP-EQL,
FORMULA-F-OR, F-ORP-EQL, EQUAL-EQL, CAR-CONS, and CDR-CONS, and opening up
THIRD, EQUAL, CONC, EQL, ASSOC-PROOF, PRF, SECOND, FOURTH, NUMBERP, LISTP,
FOL-RULES, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.9 0.0 ]

ASSOC-PROOF-PROVES


(PROVE-LEMMA CONTRAC-PROOF-PROVES
             (REWRITE)
             (IMPLIES (PROVES PF
                              (F-OR A A)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (CONTRAC-PROOF A PF)
                              A GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule CONTRAC-PROOF-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations FORMULA-F-OR, PROVES,
and IMPLIES, to:

      (IMPLIES (AND (EQL (CONC PF 0) (F-OR A A))
                    (FORMULA A SYMBOLS)
                    (PRF PF GIVEN DEFNS 0 SYMBOLS))
               (PROVES (CONTRAC-PROOF A PF)
                       A GIVEN DEFNS SYMBOLS)),

which simplifies, rewriting with ARG2-F-OR, ARG1-F-OR, EQL-COMM, LISTP-EQL,
EQUAL-EQL, CAR-CONS, and CDR-CONS, and expanding the functions THIRD, EQUAL,
CONC, EQL, CONTRAC-PROOF, PRF, SECOND, FOURTH, NUMBERP, LISTP, FOL-RULES, and
PROVES, to:

      T.

Q.E.D.


[ 0.0 0.7 0.0 ]

CONTRAC-PROOF-PROVES


(PROVE-LEMMA CUT-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF1
                                   (F-OR A B)
                                   GIVEN DEFNS SYMBOLS)
                           (PROVES PF2
                                   (F-OR (F-NOT A) C)
                                   GIVEN DEFNS SYMBOLS)
                           (FORMULA (F-OR B C) SYMBOLS))
                      (PROVES (CUT-PROOF A B C PF1 PF2)
                              (F-OR B C)
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule CUT-PROOF-PROVES will be stored so as to
apply only to terms with the nonrecursive function symbol PROVES.


This conjecture can be simplified, using the abbreviations FORMULA-F-NOT,
FORMULA-F-OR, PROVES, AND, and IMPLIES, to the goal:

      (IMPLIES (AND (EQL (CONC PF1 0) (F-OR A B))
                    (FORMULA A SYMBOLS)
                    (FORMULA B SYMBOLS)
                    (PRF PF1 GIVEN DEFNS 0 SYMBOLS)
                    (EQL (CONC PF2 0) (F-OR (F-NOT A) C))
                    (FORMULA C SYMBOLS)
                    (PRF PF2 GIVEN DEFNS 0 SYMBOLS))
               (PROVES (CUT-PROOF A B C PF1 PF2)
                       (F-OR B C)
                       GIVEN DEFNS SYMBOLS)).

This simplifies, applying ARG2-F-OR, ARG1-F-OR, EQL-COMM, ARG-F-NOT, LISTP-EQL,
FORMULA-F-OR, F-ORP-EQL, EQUAL-EQL, CAR-CONS, and CDR-CONS, and expanding the
definitions of THIRD, EQUAL, CONC, EQL, CUT-PROOF, PRF, SECOND, FOURTH,
NUMBERP, LISTP, FOL-RULES, and PROVES, to:

      T.

Q.E.D.


[ 0.0 1.5 0.0 ]

CUT-PROOF-PROVES


(PROVE-LEMMA FORSOME-INTRO-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF
                                   (F-IMPLIES A B)
                                   GIVEN DEFNS SYMBOLS)
                           (NOT (MEMB VAR (COLLECT-FREE B 0)))
                           (VARIABLE VAR)
                           (FORMULA (F-IMPLIES (FORSOME VAR A) B)
                                    SYMBOLS))
                      (PROVES (FORSOME-INTRO-PROOF VAR A B PF)
                              (F-IMPLIES (FORSOME VAR A) B)
                              GIVEN DEFNS SYMBOLS))
             ((DISABLE COLLECT-FREE FORMULA)))

WARNING:  Note that the rewrite rule FORSOME-INTRO-PROVES will be stored so as
to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations FORMULA-FORSOME, NOT,
FORMULA-F-NOT, FORMULA-F-OR, PROVES, AND, IMPLIES, VARIABLE, and F-IMPLIES, to:

      (IMPLIES (AND (EQL (CONC PF 0) (F-OR (F-NOT A) B))
                    (FORMULA A SYMBOLS)
                    (FORMULA B SYMBOLS)
                    (PRF PF GIVEN DEFNS 0 SYMBOLS)
                    (NOT (MEMB VAR (COLLECT-FREE B 0)))
                    (NUMBERP VAR))
               (PROVES (FORSOME-INTRO-PROOF VAR A B PF)
                       (F-OR (F-NOT (FORSOME VAR A)) B)
                       GIVEN DEFNS SYMBOLS)),

which simplifies, rewriting with ARG2-F-OR, ARG1-F-OR, ARG-F-NOT, EQL-COMM,
LISTP-EQL, FORMULA-F-OR, FORMULA-F-NOT, FORMULA-FORSOME, F-ORP-EQL, F-NOTP-EQL,
FORSOMEP-EQL, EQUAL-EQL, CAR-CONS, and CDR-CONS, and unfolding the functions
THIRD, EQUAL, CONC, EQL, F-IMPLIES, FORSOME-INTRO-PROOF, PRF, SECOND, FOURTH,
NUMBERP, LISTP, VARIABLE, FOL-RULES, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.7 0.0 ]

FORSOME-INTRO-PROVES


(TOGGLE G2752 PROP-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G2752


(TOGGLE G2753 SUBST-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G2753


(TOGGLE G2754 EQUAL-AXIOM1-PROOF T)

[ 0.0 0.0 0.0 ]

G2754


(TOGGLE G2755 EQUAL-AXIOM2-PROOF T)

[ 0.0 0.0 0.0 ]

G2755


(TOGGLE G2756 IDENT-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G2756


(TOGGLE G2757 ASSUM-PROOF T)

[ 0.0 0.0 0.0 ]

G2757


(TOGGLE G2758 FUN-DEFN-PROOF T)

[ 0.0 0.0 0.0 ]

G2758


(TOGGLE G2759 EXPAN-PROOF T)

[ 0.0 0.0 0.0 ]

G2759


(TOGGLE G2760 CONTRAC-PROOF T)

[ 0.0 0.0 0.0 ]

G2760


(TOGGLE G2761 ASSOC-PROOF T)

[ 0.0 0.0 0.0 ]

G2761


(TOGGLE G2762 CUT-PROOF T)

[ 0.0 0.0 0.0 ]

G2762


(TOGGLE G2763 FORSOME-INTRO-PROOF T)

[ 0.0 0.0 0.0 ]

G2763


(TOGGLE G0626 FOL-RULES T)

[ 0.0 0.0 0.0 ]

G0626


(PROVE-LEMMA NLISTP-PROVES
             (REWRITE)
             (IMPLIES (NLISTP PF)
                      (NOT (PROVES PF EXP GIVEN DEFNS SYMBOLS))))

WARNING:  Note that the rewrite rule NLISTP-PROVES will be stored so as to
apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations PROVES, NOT, NLISTP,
and IMPLIES, to:

      (IMPLIES (AND (NOT (LISTP PF))
                    (EQL (CONC PF 0) EXP)
                    (FORMULA EXP SYMBOLS))
               (NOT (PRF PF GIVEN DEFNS 0 SYMBOLS))),

which simplifies, appealing to the lemmas CDR-NLISTP and NUMBERP-EQL, and
unfolding THIRD, CDR, CAR, EQUAL, CONC, OR, NUMBERP, FORSOMEP, F-ORP, F-NOTP,
FORMULA, and PRF, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NLISTP-PROVES


(DEFN EXT-AXIOM
      (X TERMA TERMB)
      (F-IFF (F-EQUAL TERMA TERMB)
             (FORALL X
                     (F-IFF (ISIN X TERMA)
                            (ISIN X TERMB)))))

     From the definition we can conclude that:
      (F-NOTP (EXT-AXIOM X TERMA TERMB))
is a theorem.




[ 0.0 0.0 0.0 ]

EXT-AXIOM


(DEFN EXT-AXIOM-PROOF
      (X TERMA TERMB)
      (LIST 3
            (LIST 1 TERMA TERMB X)
            (EXT-AXIOM X TERMA TERMB)))

     Observe that (LISTP (EXT-AXIOM-PROOF X TERMA TERMB)) is a theorem.




[ 0.0 0.0 0.0 ]

EXT-AXIOM-PROOF


(PROVE-LEMMA EXT-AXIOM-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (NOT (MEMB X (COLLECT-FREE TERMA 0)))
                           (NOT (MEMB X (COLLECT-FREE TERMB 0)))
                           (VARIABLE X)
                           (MEMB (P 1 2) SYMBOLS)
                           (TERMP TERMA 0 SYMBOLS)
                           (TERMP TERMB 0 SYMBOLS))
                      (PROVES (EXT-AXIOM-PROOF X TERMA TERMB)
                              (F-IFF (F-EQUAL TERMA TERMB)
                                     (FORALL X
                                             (F-IFF (ISIN X TERMA)
                                                    (ISIN X TERMB))))
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule EXT-AXIOM-PROOF-PROVES will be stored so
as to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture can be simplified, using the abbreviations NOT, AND, IMPLIES,
ISIN, FORALL, and VARIABLE, to:

      (IMPLIES
       (AND (NOT (MEMB X (COLLECT-FREE TERMA 0)))
            (NOT (MEMB X (COLLECT-FREE TERMB 0)))
            (NUMBERP X)
            (MEMB (P 1 2) SYMBOLS)
            (TERMP TERMA 0 SYMBOLS)
            (TERMP TERMB 0 SYMBOLS))
       (PROVES (EXT-AXIOM-PROOF X TERMA TERMB)
               (F-IFF (F-EQUAL TERMA TERMB)
                      (F-NOT (FORSOME X
                                      (F-NOT (F-IFF (LIST (P 1 2) X TERMA)
                                                    (LIST (P 1 2) X TERMB))))))
               GIVEN DEFNS SYMBOLS)).

This simplifies, applying FORMULA-FORSOME, FORMULA-F-OR, PREDICATE-P, DEGREE-P,
VAR-LIST-TERMP, ATOMP-REDUC, FORMULA-F-NOT, FORMULA-F-EQUAL, FORSOMEP-EQL,
F-ORP-EQL, LISTP-EQL, NUMBERP-EQL, F-NOTP-EQL, EQUAL-EQL, CAR-CONS, and
CDR-CONS, and opening up EXT-AXIOM, ISIN, F-AND, F-IMPLIES, F-IFF, FORALL,
EXT-AXIOM-PROOF, PRF, SECOND, FOURTH, Z2-AXIOMS, FORMULA, SYMB, LENGTH, ADD1,
NUMBERP, TERMP, VARIABLE, LISTP, VAR-LIST, OR, CONC, EQUAL, THIRD, and PROVES,
to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

EXT-AXIOM-PROOF-PROVES


(TOGGLE G0374 EXT-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G0374


(DEFN NULL-AXIOM
      (TERM)
      (F-NOT (ISIN TERM (PHI))))

     Note that (F-NOTP (NULL-AXIOM TERM)) is a theorem.




[ 0.0 0.0 0.0 ]

NULL-AXIOM


(DEFN NULL-AXIOM-PROOF
      (TERM)
      (LIST 3
            (LIST 2 TERM)
            (NULL-AXIOM TERM)))

     Note that (LISTP (NULL-AXIOM-PROOF TERM)) is a theorem.




[ 0.0 0.0 0.0 ]

NULL-AXIOM-PROOF


(PROVE-LEMMA NULL-AXIOM-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (SUBSET (LIST (FN 0 0) (P 1 2))
                                   SYMBOLS)
                           (TERMP TERM 0 SYMBOLS))
                      (PROVES (NULL-AXIOM-PROOF TERM)
                              (F-NOT (ISIN TERM (PHI)))
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule NULL-AXIOM-PROOF-PROVES will be stored so
as to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations AND, IMPLIES, PHI, and
ISIN, to:

      (IMPLIES (AND (SUBSET (LIST (FN 0 0) (P 1 2))
                            SYMBOLS)
                    (TERMP TERM 0 SYMBOLS))
               (PROVES (NULL-AXIOM-PROOF TERM)
                       (F-NOT (LIST (P 1 2) TERM (LIST (FN 0 0))))
                       GIVEN DEFNS SYMBOLS)),

which simplifies, applying the lemmas CDR-CONS, CAR-CONS, FORMULA-F-NOT,
PREDICATE-P, MEMB-MEMBER, DEGREE-P, VAR-LIST-TERMP, DEGREE-FN, FUNCTION-FN,
ATOMP-REDUC, F-NOTP-EQL, LISTP-EQL, and EQUAL-EQL, and unfolding the
definitions of SUBSET, LISTP, NULL-AXIOM, PHI, ISIN, NULL-AXIOM-PROOF, PRF,
SECOND, Z2-AXIOMS, FORMULA, SYMB, LENGTH, ADD1, NUMBERP, TERMP, VAR-LIST, CONC,
EQUAL, THIRD, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NULL-AXIOM-PROOF-PROVES


(TOGGLE G0375 NULL-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G0375


(DEFN PAIR-AXIOM
      (X TERMA TERMB)
      (F-IFF (ISIN X (Z-PAIR TERMA TERMB))
             (F-OR (F-EQUAL X TERMA)
                   (F-EQUAL X TERMB))))

     From the definition we can conclude that:
      (F-NOTP (PAIR-AXIOM X TERMA TERMB))
is a theorem.




[ 0.0 0.0 0.0 ]

PAIR-AXIOM


(DEFN PAIR-AXIOM-PROOF
      (X TERMA TERMB)
      (LIST 3
            (LIST 3 TERMA TERMB X)
            (PAIR-AXIOM X TERMA TERMB)))

     Observe that (LISTP (PAIR-AXIOM-PROOF X TERMA TERMB)) is a theorem.




[ 0.0 0.0 0.0 ]

PAIR-AXIOM-PROOF


(PROVE-LEMMA PAIR-AXIOM-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (TERMP X 0 SYMBOLS)
                           (TERMP TERMA 0 SYMBOLS)
                           (TERMP TERMB 0 SYMBOLS)
                           (SUBSET (LIST (FN 1 2) (P 1 2))
                                   SYMBOLS))
                      (PROVES (PAIR-AXIOM-PROOF X TERMA TERMB)
                              (F-IFF (ISIN X (Z-PAIR TERMA TERMB))
                                     (F-OR (F-EQUAL X TERMA)
                                           (F-EQUAL X TERMB)))
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule PAIR-AXIOM-PROOF-PROVES will be stored so
as to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations AND, IMPLIES, Z-PAIR,
and ISIN, to the new formula:

      (IMPLIES (AND (TERMP X 0 SYMBOLS)
                    (TERMP TERMA 0 SYMBOLS)
                    (TERMP TERMB 0 SYMBOLS)
                    (SUBSET (LIST (FN 1 2) (P 1 2))
                            SYMBOLS))
               (PROVES (PAIR-AXIOM-PROOF X TERMA TERMB)
                       (F-IFF (LIST (P 1 2)
                                    X
                                    (LIST (FN 1 2) TERMA TERMB))
                              (F-OR (F-EQUAL X TERMA)
                                    (F-EQUAL X TERMB)))
                       GIVEN DEFNS SYMBOLS)),

which simplifies, rewriting with CDR-CONS, CAR-CONS, FORMULA-F-OR,
FORMULA-F-EQUAL, FORMULA-F-NOT, PREDICATE-P, MEMB-MEMBER, DEGREE-P,
VAR-LIST-TERMP, DEGREE-FN, FUNCTION-FN, ATOMP-REDUC, F-ORP-EQL, F-NOTP-EQL,
LISTP-EQL, and EQUAL-EQL, and expanding the functions SUBSET, LISTP,
PAIR-AXIOM, Z-PAIR, ISIN, F-AND, F-IMPLIES, F-IFF, PAIR-AXIOM-PROOF, PRF,
SECOND, FOURTH, Z2-AXIOMS, FORMULA, SYMB, LENGTH, ADD1, NUMBERP, TERMP,
VAR-LIST, CONC, EQUAL, THIRD, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

PAIR-AXIOM-PROOF-PROVES


(TOGGLE G0376 PAIR-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G0376


(DEFN UNION-AXIOM
      (X TERMA TERMB)
      (F-IFF (ISIN X (Z-UNION TERMA TERMB))
             (F-OR (ISIN X TERMA) (ISIN X TERMB))))

     From the definition we can conclude that:
      (F-NOTP (UNION-AXIOM X TERMA TERMB))
is a theorem.




[ 0.0 0.0 0.0 ]

UNION-AXIOM


(DEFN UNION-AXIOM-PROOF
      (X TERMA TERMB)
      (LIST 3
            (LIST 4 TERMA TERMB X)
            (UNION-AXIOM X TERMA TERMB)))

     Observe that (LISTP (UNION-AXIOM-PROOF X TERMA TERMB)) is a theorem.




[ 0.0 0.0 0.0 ]

UNION-AXIOM-PROOF


(PROVE-LEMMA UNION-AXIOM-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (TERMP X 0 SYMBOLS)
                           (TERMP TERMA 0 SYMBOLS)
                           (TERMP TERMB 0 SYMBOLS)
                           (MEMB (P 1 2) SYMBOLS)
                           (MEMB (FN 2 2) SYMBOLS))
                      (PROVES (UNION-AXIOM-PROOF X TERMA TERMB)
                              (F-IFF (ISIN X (Z-UNION TERMA TERMB))
                                     (F-OR (ISIN X TERMA) (ISIN X TERMB)))
                              GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule UNION-AXIOM-PROOF-PROVES will be stored
so as to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations AND, IMPLIES, Z-UNION,
and ISIN, to the new goal:

      (IMPLIES (AND (TERMP X 0 SYMBOLS)
                    (TERMP TERMA 0 SYMBOLS)
                    (TERMP TERMB 0 SYMBOLS)
                    (MEMB (P 1 2) SYMBOLS)
                    (MEMB (FN 2 2) SYMBOLS))
               (PROVES (UNION-AXIOM-PROOF X TERMA TERMB)
                       (F-IFF (LIST (P 1 2)
                                    X
                                    (LIST (FN 2 2) TERMA TERMB))
                              (F-OR (LIST (P 1 2) X TERMA)
                                    (LIST (P 1 2) X TERMB)))
                       GIVEN DEFNS SYMBOLS)),

which simplifies, appealing to the lemmas FORMULA-F-OR, FORMULA-F-NOT,
PREDICATE-P, DEGREE-P, VAR-LIST-TERMP, DEGREE-FN, FUNCTION-FN, ATOMP-REDUC,
F-ORP-EQL, F-NOTP-EQL, LISTP-EQL, EQUAL-EQL, CAR-CONS, and CDR-CONS, and
expanding UNION-AXIOM, Z-UNION, ISIN, F-AND, F-IMPLIES, F-IFF,
UNION-AXIOM-PROOF, PRF, SECOND, FOURTH, Z2-AXIOMS, FORMULA, SYMB, LENGTH, ADD1,
NUMBERP, TERMP, LISTP, VAR-LIST, CONC, EQUAL, THIRD, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

UNION-AXIOM-PROOF-PROVES


(TOGGLE G0377 UNION-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G0377


(DEFN IND-AXIOM
      (FORM X)
      (F-IMPLIES (F-AND (SUBST FORM X (PHI) 0)
                        (FORALL X
                                (F-IMPLIES (F-AND (Z-INT X) FORM)
                                           (SUBST FORM X (Z-SUCC X) 0))))
                 (FORALL X
                         (F-IMPLIES (Z-INT X) FORM))))

     From the definition we can conclude that (F-ORP (IND-AXIOM FORM X)) is a
theorem.




[ 0.0 0.0 0.0 ]

IND-AXIOM


(DEFN IND-AXIOM-PROOF
      (FORM X)
      (LIST 3
            (LIST 5 FORM X)
            (IND-AXIOM FORM X)))

     Observe that (LISTP (IND-AXIOM-PROOF FORM X)) is a theorem.




[ 0.0 0.0 0.0 ]

IND-AXIOM-PROOF


(TOGGLE G0627 PREDICATE NIL)

[ 0.0 0.0 0.0 ]

G0627


(PROVE-LEMMA IND-AXIOM-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA FORM SYMBOLS)
                           (VARIABLE X)
                           (SUBSET (LIST (FN 0 0) (FN 3 1) (P 2 1))
                                   SYMBOLS)
                           (EQUAL CONCL (IND-AXIOM FORM X)))
                      (PROVES (IND-AXIOM-PROOF FORM X)
                              CONCL GIVEN DEFNS SYMBOLS)))

WARNING:  Note that the rewrite rule IND-AXIOM-PROOF-PROVES will be stored so
as to apply only to terms with the nonrecursive function symbol PROVES.


This formula can be simplified, using the abbreviations AND, IMPLIES, and
VARIABLE, to:

      (IMPLIES (AND (FORMULA FORM SYMBOLS)
                    (NUMBERP X)
                    (SUBSET (LIST (FN 0 0) (FN 3 1) (P 2 1))
                            SYMBOLS)
                    (EQUAL CONCL (IND-AXIOM FORM X)))
               (PROVES (IND-AXIOM-PROOF FORM X)
                       CONCL GIVEN DEFNS SYMBOLS)),

which simplifies, applying CDR-CONS, CAR-CONS, FORMULA-FORSOME, FORMULA-F-OR,
PREDICATE-P, DEGREE-P, ATOMP-REDUC, FORMULA-F-NOT, SUBST-FORMULA, DEGREE-FN,
VAR-LIST-TERMP, MEMB-MEMBER, FUNCTION-FN, FORSOMEP-EQL, F-ORP-EQL, LISTP-EQL,
NUMBERP-EQL, F-NOTP-EQL, and EQUAL-EQL, and opening up the functions SUBSET,
LISTP, IND-AXIOM, PHI, Z-INT, F-AND, Z-SUCC, F-IMPLIES, FORALL,
IND-AXIOM-PROOF, PRF, SECOND, Z2-AXIOMS, FORMULA, ADD1, VARIABLE, SUB1,
NUMBERP, LENGTH, VAR-LIST, SYMB, TERMP, OR, CONC, EQUAL, THIRD, and PROVES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

IND-AXIOM-PROOF-PROVES


(TOGGLE G0629 PREDICATE T)

[ 0.0 0.0 0.0 ]

G0629


(TOGGLE G0378 IND-AXIOM-PROOF T)

[ 0.0 0.0 0.0 ]

G0378


(TOGGLE G0379 PRF T)

[ 0.0 0.0 0.0 ]

G0379


(PROVE-LEMMA PROVES-IS-FORMULA
             (REWRITE)
             (IMPLIES (PROVES PF EXP GIVEN DEFNS SYMBOLS)
                      (FORMULA EXP SYMBOLS)))

WARNING:  Note that PROVES-IS-FORMULA contains the free variables DEFNS, GIVEN,
and PF which will be chosen by instantiating the hypothesis:
      (PROVES PF EXP GIVEN DEFNS SYMBOLS).



This conjecture can be simplified, using the abbreviations PROVES and IMPLIES,
to the conjecture:

      T.

This simplifies, obviously, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PROVES-IS-FORMULA


(PROVE-LEMMA PROVES-IS-FORMULA-AGAIN
             (REWRITE)
             (IMPLIES (NOT (FORMULA EXP SYMBOLS))
                      (NOT (PROVES PF EXP GIVEN DEFNS SYMBOLS))))

WARNING:  Note that the rewrite rule PROVES-IS-FORMULA-AGAIN will be stored so
as to apply only to terms with the nonrecursive function symbol PROVES.


This conjecture can be simplified, using the abbreviations PROVES, NOT, and
IMPLIES, to:

      T.

This simplifies, obviously, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PROVES-IS-FORMULA-AGAIN


(TOGGLE G0380 PROVES T)

[ 0.0 0.0 0.0 ]

G0380


(DEFN COMMUT-PROOF
      (A B PF)
      (CUT-PROOF A B A PF
                 (PROP-AXIOM-PROOF A)))

     Observe that (LISTP (COMMUT-PROOF A B PF)) is a theorem.




[ 0.0 0.0 0.0 ]

COMMUT-PROOF


(PROVE-LEMMA COMMUT-PROOF-PROVES
             (REWRITE)
             (IMPLIES (PROVES PF
                              (F-OR A B)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (COMMUT-PROOF A B PF)
                              (F-OR B A)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (EXP (F-OR A B))))
              (DISABLE PROVES-IS-FORMULA)))

This simplifies, applying the lemmas FORMULA-F-OR, PROP-AXIOM-PROVES, and
CUT-PROOF-PROVES, and opening up the functions IMPLIES and COMMUT-PROOF, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COMMUT-PROOF-PROVES


(TOGGLE G2766 COMMUT-PROOF T)

[ 0.0 0.0 0.0 ]

G2766


(DEFN DETACH-PROOF
      (A B PF1 PF2)
      (CONTRAC-PROOF B
                     (CUT-PROOF A B B
                                (COMMUT-PROOF B A
                                              (EXPAN-PROOF B A PF1))
                                PF2)))

     From the definition we can conclude that:
      (LISTP (DETACH-PROOF A B PF1 PF2))
is a theorem.




[ 0.0 0.0 0.0 ]

DETACH-PROOF


(TOGGLE G0503 PROVES-IS-FORMULA T)

[ 0.0 0.0 0.0 ]

G0503


(PROVE-LEMMA DETACH-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                           (PROVES PF2
                                   (F-IMPLIES A B)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (DETACH-PROOF A B PF1 PF2)
                              B GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF2)
                                      (EXP (F-IMPLIES A B))))))

This conjecture can be simplified, using the abbreviations AND, IMPLIES, and
F-IMPLIES, to the formula:

      (IMPLIES (AND (IMPLIES (PROVES PF2
                                     (F-OR (F-NOT A) B)
                                     GIVEN DEFNS SYMBOLS)
                             (FORMULA (F-OR (F-NOT A) B) SYMBOLS))
                    (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                    (PROVES PF2
                            (F-OR (F-NOT A) B)
                            GIVEN DEFNS SYMBOLS))
               (PROVES (DETACH-PROOF A B PF1 PF2)
                       B GIVEN DEFNS SYMBOLS)).

This simplifies, rewriting with the lemmas FORMULA-F-NOT, FORMULA-F-OR,
CUT-PROOF-PROVES, EXPAN-PROOF-PROVES, COMMUT-PROOF-PROVES, and
CONTRAC-PROOF-PROVES, and unfolding the definitions of IMPLIES and
DETACH-PROOF, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DETACH-PROOF-PROVES


(TOGGLE G2767 DETACH-PROOF T)

[ 0.0 0.0 0.0 ]

G2767


(PROVE-LEMMA FORMULA-F-IMPLIES
             (REWRITE)
             (EQUAL (FORMULA (F-IMPLIES X Y) SYMBOLS)
                    (AND (FORMULA X SYMBOLS)
                         (FORMULA Y SYMBOLS))))

This conjecture can be simplified, using the abbreviation F-IMPLIES, to the
goal:

      (EQUAL (FORMULA (F-OR (F-NOT X) Y) SYMBOLS)
             (AND (FORMULA X SYMBOLS)
                  (FORMULA Y SYMBOLS))).

This simplifies, applying the lemmas FORMULA-F-NOT and FORMULA-F-OR, and
unfolding the function AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORMULA-F-IMPLIES


(PROVE-LEMMA COVERING-F-IMPLIES
             (REWRITE)
             (EQUAL (COVERING (F-IMPLIES X Y) VAR 0)
                    (APPEND (COVERING X VAR 0)
                            (COVERING Y VAR 0))))

This formula can be simplified, using the abbreviation F-IMPLIES, to:

      (EQUAL (COVERING (F-OR (F-NOT X) Y) VAR 0)
             (APPEND (COVERING X VAR 0)
                     (COVERING Y VAR 0))),

which simplifies, rewriting with ARG2-F-OR, ARG1-F-OR, and ARG-F-NOT, and
unfolding EQUAL and COVERING, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COVERING-F-IMPLIES


(PROVE-LEMMA MEMBER-APPEND
             (REWRITE)
             (EQUAL (MEMBER X (APPEND Y Z))
                    (OR (MEMBER X Y) (MEMBER X Z))))

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

Case 2. (IMPLIES (NOT (MEMBER X Y))
                 (EQUAL (MEMBER X (APPEND Y Z))
                        (MEMBER X Z))),

  which we will name *1.

Case 1. (IMPLIES (MEMBER X Y)
                 (EQUAL (MEMBER X (APPEND Y Z)) T)).

  This again simplifies, trivially, to the new formula:

        (IMPLIES (MEMBER X Y)
                 (MEMBER X (APPEND Y Z))),

  which we would normally push and work on later by induction.  But if we must
  use induction to prove the input conjecture, we prefer to induct on the
  original formulation of the problem.  Thus we will disregard all that we
  have previously done, give the name *1 to the original input, and work on it.


     So now let us return to:

(EQUAL (MEMBER X (APPEND Y Z))
       (OR (MEMBER X Y) (MEMBER X Z))).

We named this *1.  We will try to prove it by induction.  There are three
plausible inductions.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP Y) (p X (CDR Y) Z))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP Y)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates two new conjectures:

Case 2. (IMPLIES (AND (LISTP Y)
                      (EQUAL (MEMBER X (APPEND (CDR Y) Z))
                             (OR (MEMBER X (CDR Y)) (MEMBER X Z))))
                 (EQUAL (MEMBER X (APPEND Y Z))
                        (OR (MEMBER X Y) (MEMBER X Z)))),

  which simplifies, applying CDR-CONS and CAR-CONS, and unfolding OR, APPEND,
  MEMBER, and EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (EQUAL (MEMBER X (APPEND Y Z))
                        (OR (MEMBER X Y) (MEMBER X Z)))).

  This simplifies, expanding the functions APPEND, MEMBER, and OR, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMBER-APPEND


(PROVE-LEMMA COLLECT-FREE-F-IMPLIES
             (REWRITE)
             (EQUAL (COLLECT-FREE (F-IMPLIES X Y) 0)
                    (APPEND (COLLECT-FREE X 0)
                            (COLLECT-FREE Y 0))))

This conjecture can be simplified, using the abbreviation F-IMPLIES, to the
goal:

      (EQUAL (COLLECT-FREE (F-OR (F-NOT X) Y) 0)
             (APPEND (COLLECT-FREE X 0)
                     (COLLECT-FREE Y 0))).

This simplifies, rewriting with ARG2-F-OR, ARG1-F-OR, and ARG-F-NOT, and
unfolding VARIABLE, EQUAL, and COLLECT-FREE, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COLLECT-FREE-F-IMPLIES


(TOGGLE G0344 F-IMPLIES T)

[ 0.0 0.0 0.0 ]

G0344


(DEFN LIST-IMPLIES
      (LIST CONC)
      (IF (NLISTP LIST)
          CONC
          (IF (NLISTP (CDR LIST))
              (F-IMPLIES (CAR LIST) CONC)
              (F-IMPLIES (CAR LIST)
                         (LIST-IMPLIES (CDR LIST) CONC)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP establish that the measure (COUNT LIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
LIST-IMPLIES is accepted under the principle of definition.  From the
definition we can conclude that:
      (OR (F-ORP (LIST-IMPLIES LIST CONC))
          (EQUAL (LIST-IMPLIES LIST CONC) CONC))
is a theorem.




[ 0.0 0.0 0.0 ]

LIST-IMPLIES


(DEFN LIST-DETACH-PROOF
      (ALIST B PFLIST PF2)
      (IF (NLISTP ALIST)
          PF2
          (IF (NLISTP (CDR ALIST))
              (DETACH-PROOF (CAR ALIST)
                            B
                            (CAR PFLIST)
                            PF2)
              (LIST-DETACH-PROOF (CDR ALIST)
                                 B
                                 (CDR PFLIST)
                                 (DETACH-PROOF (CAR ALIST)
                                               (LIST-IMPLIES (CDR ALIST) B)
                                               (CAR PFLIST)
                                               PF2)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP establish that the measure (COUNT ALIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
LIST-DETACH-PROOF is accepted under the definitional principle.  Observe that:
      (OR (LISTP (LIST-DETACH-PROOF ALIST B PFLIST PF2))
          (EQUAL (LIST-DETACH-PROOF ALIST B PFLIST PF2)
                 PF2))
is a theorem.




[ 0.0 0.0 0.0 ]

LIST-DETACH-PROOF


(PROVE-LEMMA FORMULA-LIST-IMPLIES NIL
             (IMPLIES (AND (FORMULA (LIST-IMPLIES ALIST B)
                                    SYMBOLS)
                           (LISTP ALIST))
                      (FORMULA (LIST-IMPLIES (CDR ALIST) B)
                               SYMBOLS)))

This conjecture simplifies, unfolding the definition of LIST-IMPLIES, to two
new conjectures:

Case 2. (IMPLIES (AND (NOT (LISTP (CDR ALIST)))
                      (FORMULA (F-IMPLIES (CAR ALIST) B)
                               SYMBOLS)
                      (LISTP ALIST))
                 (FORMULA B SYMBOLS)),

  which again simplifies, rewriting with FORMULA-F-IMPLIES, to:

        T.

Case 1. (IMPLIES (AND (LISTP (CDR ALIST))
                      (FORMULA (F-IMPLIES (CAR ALIST)
                                          (LIST-IMPLIES (CDR ALIST) B))
                               SYMBOLS)
                      (LISTP ALIST))
                 (FORMULA (LIST-IMPLIES (CDR ALIST) B)
                          SYMBOLS)).

  But this again simplifies, rewriting with FORMULA-F-IMPLIES, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORMULA-LIST-IMPLIES


(DEFN PROVES-LIST
      (PFLIST EXPLIST GIVEN DEFNS SYMBOLS)
      (IF (NLISTP EXPLIST)
          (EQUAL PFLIST NIL)
          (AND (PROVES (CAR PFLIST)
                       (CAR EXPLIST)
                       GIVEN DEFNS SYMBOLS)
               (PROVES-LIST (CDR PFLIST)
                            (CDR EXPLIST)
                            GIVEN DEFNS SYMBOLS))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP establish that the measure (COUNT EXPLIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
PROVES-LIST is accepted under the principle of definition.  Note that:
      (OR (FALSEP (PROVES-LIST PFLIST EXPLIST GIVEN DEFNS SYMBOLS))
          (TRUEP (PROVES-LIST PFLIST EXPLIST GIVEN DEFNS SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

PROVES-LIST


(PROVE-LEMMA DETACH-RULE-CORR
             (REWRITE)
             (IMPLIES (AND (PROVES-LIST PFLIST ALIST GIVEN DEFNS SYMBOLS)
                           (PROVES PF2
                                   (LIST-IMPLIES ALIST B)
                                   GIVEN DEFNS SYMBOLS)
                           (FORMULA B SYMBOLS))
                      (PROVES (LIST-DETACH-PROOF ALIST B PFLIST PF2)
                              B GIVEN DEFNS SYMBOLS))
             ((INDUCT (LIST-DETACH-PROOF ALIST B PFLIST PF2))
              (USE (FORMULA-LIST-IMPLIES))))

This formula simplifies, appealing to the lemmas CDR-NLISTP and CAR-NLISTP,
and unfolding LIST-IMPLIES, AND, IMPLIES, NLISTP, NOT, PROVES-LIST,
LIST-DETACH-PROOF, OR, and LISTP, to four new conjectures:

Case 4. (IMPLIES (AND (FORMULA (LIST-IMPLIES (CDR ALIST) B)
                               SYMBOLS)
                      (LISTP ALIST)
                      (NOT (LISTP (CDR ALIST)))
                      (PROVES (CAR PFLIST)
                              (CAR ALIST)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES-LIST (CDR PFLIST)
                                   (CDR ALIST)
                                   GIVEN DEFNS SYMBOLS)
                      (PROVES PF2
                              (F-IMPLIES (CAR ALIST) B)
                              GIVEN DEFNS SYMBOLS)
                      (FORMULA B SYMBOLS))
                 (PROVES (DETACH-PROOF (CAR ALIST)
                                       B
                                       (CAR PFLIST)
                                       PF2)
                         B GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying DETACH-PROOF-PROVES, and unfolding
  LIST-IMPLIES and PROVES-LIST, to:

        T.

Case 3. (IMPLIES
          (AND (FORMULA (LIST-IMPLIES (CDR ALIST) B)
                        SYMBOLS)
               (LISTP ALIST)
               (LISTP (CDR ALIST))
               (PROVES-LIST (CDR PFLIST)
                            (CDR ALIST)
                            GIVEN DEFNS SYMBOLS)
               (NOT (PROVES (DETACH-PROOF (CAR ALIST)
                                          (LIST-IMPLIES (CDR ALIST) B)
                                          (CAR PFLIST)
                                          PF2)
                            (LIST-IMPLIES (CDR ALIST) B)
                            GIVEN DEFNS SYMBOLS))
               (PROVES (CAR PFLIST)
                       (CAR ALIST)
                       GIVEN DEFNS SYMBOLS)
               (PROVES PF2
                       (F-IMPLIES (CAR ALIST)
                                  (LIST-IMPLIES (CDR ALIST) B))
                       GIVEN DEFNS SYMBOLS)
               (FORMULA B SYMBOLS))
          (PROVES (LIST-DETACH-PROOF (CDR ALIST)
                                     B
                                     (CDR PFLIST)
                                     (DETACH-PROOF (CAR ALIST)
                                                   (LIST-IMPLIES (CDR ALIST) B)
                                                   (CAR PFLIST)
                                                   PF2))
                  B GIVEN DEFNS SYMBOLS)).

  However this again simplifies, rewriting with the lemma DETACH-PROOF-PROVES,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (LISTP (CDR ALIST)))
                      (NOT (FORMULA (F-IMPLIES (CAR ALIST) B)
                                    SYMBOLS))
                      (LISTP ALIST)
                      (PROVES (CAR PFLIST)
                              (CAR ALIST)
                              GIVEN DEFNS SYMBOLS)
                      (EQUAL (CDR PFLIST) NIL)
                      (PROVES PF2
                              (F-IMPLIES (CAR ALIST) B)
                              GIVEN DEFNS SYMBOLS)
                      (FORMULA B SYMBOLS))
                 (PROVES (DETACH-PROOF (CAR ALIST)
                                       B
                                       (CAR PFLIST)
                                       PF2)
                         B GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying FORMULA-F-IMPLIES and
  PROVES-IS-FORMULA-AGAIN, to:

        T.

Case 1. (IMPLIES
          (AND (LISTP (CDR ALIST))
               (NOT (FORMULA (F-IMPLIES (CAR ALIST)
                                        (LIST-IMPLIES (CDR ALIST) B))
                             SYMBOLS))
               (LISTP ALIST)
               (PROVES-LIST (CDR PFLIST)
                            (CDR ALIST)
                            GIVEN DEFNS SYMBOLS)
               (NOT (PROVES (DETACH-PROOF (CAR ALIST)
                                          (LIST-IMPLIES (CDR ALIST) B)
                                          (CAR PFLIST)
                                          PF2)
                            (LIST-IMPLIES (CDR ALIST) B)
                            GIVEN DEFNS SYMBOLS))
               (PROVES (CAR PFLIST)
                       (CAR ALIST)
                       GIVEN DEFNS SYMBOLS)
               (PROVES PF2
                       (F-IMPLIES (CAR ALIST)
                                  (LIST-IMPLIES (CDR ALIST) B))
                       GIVEN DEFNS SYMBOLS)
               (FORMULA B SYMBOLS))
          (PROVES (LIST-DETACH-PROOF (CDR ALIST)
                                     B
                                     (CDR PFLIST)
                                     (DETACH-PROOF (CAR ALIST)
                                                   (LIST-IMPLIES (CDR ALIST) B)
                                                   (CAR PFLIST)
                                                   PF2))
                  B GIVEN DEFNS SYMBOLS)).

  This again simplifies, applying the lemmas FORMULA-F-IMPLIES and
  DETACH-PROOF-PROVES, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

DETACH-RULE-CORR


(TOGGLE G0220 LIST-DETACH-PROOF T)

[ 0.0 0.0 0.0 ]

G0220


(DEFN RT-EXPAN-PROOF
      (A B PF)
      (COMMUT-PROOF B A
                    (EXPAN-PROOF B A PF)))

     Observe that (LISTP (RT-EXPAN-PROOF A B PF)) is a theorem.




[ 0.0 0.0 0.0 ]

RT-EXPAN-PROOF


(PROVE-LEMMA RT-EXPAN-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF A GIVEN DEFNS SYMBOLS)
                           (FORMULA B SYMBOLS))
                      (PROVES (RT-EXPAN-PROOF A B PF)
                              (F-OR A B)
                              GIVEN DEFNS SYMBOLS)))

This formula simplifies, rewriting with EXPAN-PROOF-PROVES and
COMMUT-PROOF-PROVES, and opening up the definition of RT-EXPAN-PROOF, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

RT-EXPAN-PROOF-PROVES


(TOGGLE G0227 RT-EXPAN-PROOF T)

[ 0.0 0.0 0.0 ]

G0227


(DEFN MAKE-DISJUNCT
      (FLIST)
      (IF (NLISTP FLIST)
          NIL
          (IF (NLISTP (CDR FLIST))
              (CAR FLIST)
              (F-OR (CAR FLIST)
                    (MAKE-DISJUNCT (CDR FLIST))))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP establish that the measure (COUNT FLIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
MAKE-DISJUNCT is accepted under the definitional principle.




[ 0.0 0.0 0.0 ]

MAKE-DISJUNCT


(DEFN M1-PROOF
      (EXP FLIST PF)
      (IF (NLISTP FLIST)
          NIL
          (IF (NLISTP (CDR FLIST))
              PF
              (IF (EQUAL EXP (CAR FLIST))
                  (RT-EXPAN-PROOF (CAR FLIST)
                                  (MAKE-DISJUNCT (CDR FLIST))
                                  PF)
                  (EXPAN-PROOF (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST))
                               (M1-PROOF EXP (CDR FLIST) PF))))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP inform us that the measure (COUNT FLIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
M1-PROOF is accepted under the definitional principle.  Observe that:
      (OR (OR (LITATOM (M1-PROOF EXP FLIST PF))
              (LISTP (M1-PROOF EXP FLIST PF)))
          (EQUAL (M1-PROOF EXP FLIST PF) PF))
is a theorem.




[ 0.0 0.0 0.0 ]

M1-PROOF


(PROVE-LEMMA M1-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA (MAKE-DISJUNCT FLIST)
                                    SYMBOLS)
                           (MEMBER EXP FLIST)
                           (PROVES PF EXP GIVEN DEFNS SYMBOLS))
                      (PROVES (M1-PROOF EXP FLIST PF)
                              (MAKE-DISJUNCT FLIST)
                              GIVEN DEFNS SYMBOLS))
             ((INDUCT (M1-PROOF EXP FLIST PF))))

This conjecture can be simplified, using the abbreviations IMPLIES, NLISTP,
NOT, OR, and AND, to four new formulas:

Case 4. (IMPLIES (AND (NOT (LISTP FLIST))
                      (FORMULA (MAKE-DISJUNCT FLIST)
                               SYMBOLS)
                      (MEMBER EXP FLIST)
                      (PROVES PF EXP GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP FLIST PF)
                         (MAKE-DISJUNCT FLIST)
                         GIVEN DEFNS SYMBOLS)),

  which simplifies, unfolding MAKE-DISJUNCT, FORSOMEP, F-ORP, F-NOTP, FORMULA,
  and MEMBER, to:

        T.

Case 3. (IMPLIES (AND (LISTP FLIST)
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (MAKE-DISJUNCT FLIST)
                               SYMBOLS)
                      (MEMBER EXP FLIST)
                      (PROVES PF EXP GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP FLIST PF)
                         (MAKE-DISJUNCT FLIST)
                         GIVEN DEFNS SYMBOLS)),

  which simplifies, expanding the functions MAKE-DISJUNCT, MEMBER, and
  M1-PROOF, to:

        T.

Case 2. (IMPLIES (AND (LISTP FLIST)
                      (LISTP (CDR FLIST))
                      (EQUAL EXP (CAR FLIST))
                      (FORMULA (MAKE-DISJUNCT FLIST)
                               SYMBOLS)
                      (MEMBER EXP FLIST)
                      (PROVES PF EXP GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP FLIST PF)
                         (MAKE-DISJUNCT FLIST)
                         GIVEN DEFNS SYMBOLS)),

  which simplifies, appealing to the lemmas FORMULA-F-OR and
  RT-EXPAN-PROOF-PROVES, and unfolding the functions MAKE-DISJUNCT, MEMBER,
  and M1-PROOF, to:

        T.

Case 1. (IMPLIES (AND (LISTP FLIST)
                      (LISTP (CDR FLIST))
                      (NOT (EQUAL EXP (CAR FLIST)))
                      (IMPLIES (AND (FORMULA (MAKE-DISJUNCT (CDR FLIST))
                                             SYMBOLS)
                                    (MEMBER EXP (CDR FLIST))
                                    (PROVES PF EXP GIVEN DEFNS SYMBOLS))
                               (PROVES (M1-PROOF EXP (CDR FLIST) PF)
                                       (MAKE-DISJUNCT (CDR FLIST))
                                       GIVEN DEFNS SYMBOLS))
                      (FORMULA (MAKE-DISJUNCT FLIST)
                               SYMBOLS)
                      (MEMBER EXP FLIST)
                      (PROVES PF EXP GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP FLIST PF)
                         (MAKE-DISJUNCT FLIST)
                         GIVEN DEFNS SYMBOLS)),

  which simplifies, rewriting with FORMULA-F-OR and EXPAN-PROOF-PROVES, and
  expanding the definitions of AND, IMPLIES, MAKE-DISJUNCT, MEMBER, and
  M1-PROOF, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

M1-PROOF-PROVES


(TOGGLE G0228 M1-PROOF T)

[ 0.0 0.0 0.0 ]

G0228


(PROVE-LEMMA M1-PROOF-PROVES1
             (REWRITE)
             (IMPLIES (AND (FORMULA (MAKE-DISJUNCT FLIST)
                                    SYMBOLS)
                           (MEMBER EXP FLIST)
                           (PROVES PF EXP GIVEN DEFNS SYMBOLS)
                           (EQUAL CONCL (MAKE-DISJUNCT FLIST)))
                      (PROVES (M1-PROOF EXP FLIST PF)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((USE (M1-PROOF-PROVES))))

This simplifies, applying the lemma M1-PROOF-PROVES, and unfolding AND and
IMPLIES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

M1-PROOF-PROVES1


(TOGGLE G0504 M1-PROOF-PROVES T)

[ 0.0 0.0 0.0 ]

G0504


(DEFN RT-ASSOC-PROOF
 (A B C PF)
 (COMMUT-PROOF
    (F-OR B C)
    A
    (ASSOC-PROOF B C A
                 (COMMUT-PROOF (F-OR C A)
                               B
                               (ASSOC-PROOF C A B
                                            (COMMUT-PROOF (F-OR A B) C PF))))))

     From the definition we can conclude that:
      (LISTP (RT-ASSOC-PROOF A B C PF))
is a theorem.




[ 0.0 0.0 0.0 ]

RT-ASSOC-PROOF


(PROVE-LEMMA RT-ASSOC-PROOF-PROVES
             (REWRITE)
             (IMPLIES (PROVES PF
                              (F-OR (F-OR A B) C)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (RT-ASSOC-PROOF A B C PF)
                              (F-OR A (F-OR B C))
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (EXP (F-OR (F-OR A B) C))))))

This formula simplifies, applying the lemmas FORMULA-F-OR, ASSOC-PROOF-PROVES,
and COMMUT-PROOF-PROVES, and unfolding the functions IMPLIES and
RT-ASSOC-PROOF, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

RT-ASSOC-PROOF-PROVES


(TOGGLE G0231 RT-ASSOC-PROOF T)

[ 0.0 0.0 0.0 ]

G0231


(DEFN INSERT-PROOF
      (A B C PF)
      (COMMUT-PROOF (F-OR A C)
                    B
                    (ASSOC-PROOF A C B
                                 (EXPAN-PROOF A
                                              (F-OR C B)
                                              (COMMUT-PROOF B C PF)))))

     From the definition we can conclude that (LISTP (INSERT-PROOF A B C PF))
is a theorem.




[ 0.0 0.0 0.0 ]

INSERT-PROOF


(PROVE-LEMMA INSERT-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF
                                   (F-OR B C)
                                   GIVEN DEFNS SYMBOLS)
                           (FORMULA A SYMBOLS))
                      (PROVES (INSERT-PROOF A B C PF)
                              (F-OR B (F-OR A C))
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (EXP (F-OR B C))))))

This formula simplifies, applying FORMULA-F-OR, ASSOC-PROOF-PROVES,
COMMUT-PROOF-PROVES, and EXPAN-PROOF-PROVES, and expanding the definitions of
IMPLIES and INSERT-PROOF, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INSERT-PROOF-PROVES


(TOGGLE G0232 INSERT-PROOF T)

[ 0.0 0.0 0.0 ]

G0232


(DEFN M2-PROOF-STEP
      (EXP1 EXP2 FLIST PF)
      (IF (NLISTP FLIST)
          NIL
          (IF (NLISTP (CDR FLIST))
              (IF (EQUAL EXP2 (CAR FLIST)) PF NIL)
              (IF (EQUAL EXP2 (CAR FLIST))
                  (RT-ASSOC-PROOF EXP1 EXP2
                                  (MAKE-DISJUNCT (CDR FLIST))
                                  (RT-EXPAN-PROOF (F-OR EXP1 EXP2)
                                                  (MAKE-DISJUNCT (CDR FLIST))
                                                  PF))
                  (INSERT-PROOF (CAR FLIST)
                                EXP1
                                (MAKE-DISJUNCT (CDR FLIST))
                                (M2-PROOF-STEP EXP1 EXP2
                                               (CDR FLIST)
                                               PF))))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP establish that the measure (COUNT FLIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
M2-PROOF-STEP is accepted under the definitional principle.  From the
definition we can conclude that:
      (OR (OR (LITATOM (M2-PROOF-STEP EXP1 EXP2 FLIST PF))
              (LISTP (M2-PROOF-STEP EXP1 EXP2 FLIST PF)))
          (EQUAL (M2-PROOF-STEP EXP1 EXP2 FLIST PF)
                 PF))
is a theorem.




[ 0.0 0.0 0.0 ]

M2-PROOF-STEP


(PROVE-LEMMA M2-PROOF-STEP-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA (MAKE-DISJUNCT FLIST)
                                    SYMBOLS)
                           (MEMBER EXP2 FLIST)
                           (PROVES PF
                                   (F-OR EXP1 EXP2)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (M2-PROOF-STEP EXP1 EXP2 FLIST PF)
                              (F-OR EXP1 (MAKE-DISJUNCT FLIST))
                              GIVEN DEFNS SYMBOLS))
             ((INDUCT (M2-PROOF-STEP EXP1 EXP2 FLIST PF))
              (USE (PROVES-IS-FORMULA (EXP (F-OR EXP1 EXP2))))))

This formula simplifies, applying the lemma FORMULA-F-OR, and unfolding the
functions IMPLIES, NLISTP, NOT, MAKE-DISJUNCT, MEMBER, AND, M2-PROOF-STEP, and
OR, to five new formulas:

Case 5. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (LISTP (CDR FLIST)))
                      (EQUAL EXP2 (CAR FLIST))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES PF
                         (F-OR EXP1 (CAR FLIST))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, trivially, to:

        T.

Case 4. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (LISTP (CDR FLIST)))
                      (NOT (EQUAL EXP2 (CAR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES NIL
                         (F-OR EXP1 (CAR FLIST))
                         GIVEN DEFNS SYMBOLS)).

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

        T.

Case 3. (IMPLIES
            (AND (FORMULA EXP1 SYMBOLS)
                 (FORMULA EXP2 SYMBOLS)
                 (LISTP FLIST)
                 (LISTP (CDR FLIST))
                 (EQUAL EXP2 (CAR FLIST))
                 (FORMULA (F-OR (CAR FLIST)
                                (MAKE-DISJUNCT (CDR FLIST)))
                          SYMBOLS)
                 (PROVES PF
                         (F-OR EXP1 EXP2)
                         GIVEN DEFNS SYMBOLS))
            (PROVES (RT-ASSOC-PROOF EXP1 EXP2
                                    (MAKE-DISJUNCT (CDR FLIST))
                                    (RT-EXPAN-PROOF (F-OR EXP1 EXP2)
                                                    (MAKE-DISJUNCT (CDR FLIST))
                                                    PF))
                    (F-OR EXP1
                          (F-OR (CAR FLIST)
                                (MAKE-DISJUNCT (CDR FLIST))))
                    GIVEN DEFNS SYMBOLS)),

  which again simplifies, rewriting with FORMULA-F-OR, RT-EXPAN-PROOF-PROVES,
  and RT-ASSOC-PROOF-PROVES, to:

        T.

Case 2. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (LISTP (CDR FLIST))
                      (NOT (EQUAL EXP2 (CAR FLIST)))
                      (NOT (FORMULA (MAKE-DISJUNCT (CDR FLIST))
                                    SYMBOLS))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (INSERT-PROOF (CAR FLIST)
                                       EXP1
                                       (MAKE-DISJUNCT (CDR FLIST))
                                       (M2-PROOF-STEP EXP1 EXP2
                                                      (CDR FLIST)
                                                      PF))
                         (F-OR EXP1
                               (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST))))
                         GIVEN DEFNS SYMBOLS)).

  This again simplifies, applying the lemma FORMULA-F-OR, to:

        T.

Case 1. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (LISTP (CDR FLIST))
                      (NOT (EQUAL EXP2 (CAR FLIST)))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (M2-PROOF-STEP EXP1 EXP2
                                             (CDR FLIST)
                                             PF)
                              (F-OR EXP1
                                    (MAKE-DISJUNCT (CDR FLIST)))
                              GIVEN DEFNS SYMBOLS)
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS))
                 (PROVES (INSERT-PROOF (CAR FLIST)
                                       EXP1
                                       (MAKE-DISJUNCT (CDR FLIST))
                                       (M2-PROOF-STEP EXP1 EXP2
                                                      (CDR FLIST)
                                                      PF))
                         (F-OR EXP1
                               (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST))))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying the lemmas FORMULA-F-OR and
  INSERT-PROOF-PROVES, to:

        T.

Q.E.D.


[ 0.0 0.3 0.0 ]

M2-PROOF-STEP-PROVES


(PROVE-LEMMA M2-PROOF-STEP-PROVES1
             (REWRITE)
             (IMPLIES (AND (FORMULA (MAKE-DISJUNCT FLIST)
                                    SYMBOLS)
                           (MEMBER EXP2 FLIST)
                           (PROVES PF
                                   (F-OR EXP1 EXP2)
                                   GIVEN DEFNS SYMBOLS)
                           (EQUAL CONCL
                                  (F-OR EXP1 (MAKE-DISJUNCT FLIST))))
                      (PROVES (M2-PROOF-STEP EXP1 EXP2 FLIST PF)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((USE (M2-PROOF-STEP-PROVES))))

This simplifies, applying M2-PROOF-STEP-PROVES, and expanding the functions
AND and IMPLIES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

M2-PROOF-STEP-PROVES1


(TOGGLE G0233 M2-PROOF-STEP T)

[ 0.0 0.0 0.0 ]

G0233


(TOGGLE G0234 M2-PROOF-STEP-PROVES T)

[ 0.0 0.0 0.0 ]

G0234


(DEFN M2-PROOF
      (EXP1 EXP2 FLIST PF)
      (IF (NLISTP FLIST)
          NIL
          (IF (EQUAL EXP1 EXP2)
              (M1-PROOF EXP1 FLIST
                        (CONTRAC-PROOF EXP1 PF))
              (IF (EQUAL EXP1 (CAR FLIST))
                  (M2-PROOF-STEP EXP1 EXP2
                                 (CDR FLIST)
                                 PF)
                  (IF (EQUAL EXP2 (CAR FLIST))
                      (M2-PROOF-STEP EXP2 EXP1
                                     (CDR FLIST)
                                     (COMMUT-PROOF EXP1 EXP2 PF))
                      (EXPAN-PROOF (CAR FLIST)
                                   (MAKE-DISJUNCT (CDR FLIST))
                                   (M2-PROOF EXP1 EXP2
                                             (CDR FLIST)
                                             PF)))))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP inform us that the measure (COUNT FLIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
M2-PROOF is accepted under the principle of definition.  Note that:
      (OR (OR (LITATOM (M2-PROOF EXP1 EXP2 FLIST PF))
              (LISTP (M2-PROOF EXP1 EXP2 FLIST PF)))
          (EQUAL (M2-PROOF EXP1 EXP2 FLIST PF)
                 PF))
is a theorem.




[ 0.0 0.0 0.0 ]

M2-PROOF


(PROVE-LEMMA M2-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA (MAKE-DISJUNCT FLIST)
                                    SYMBOLS)
                           (MEMBER EXP1 FLIST)
                           (MEMBER EXP2 FLIST)
                           (PROVES PF
                                   (F-OR EXP1 EXP2)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (M2-PROOF EXP1 EXP2 FLIST PF)
                              (MAKE-DISJUNCT FLIST)
                              GIVEN DEFNS SYMBOLS))
             ((INDUCT (M2-PROOF EXP1 EXP2 FLIST PF))
              (USE (PROVES-IS-FORMULA (EXP (F-OR EXP1 EXP2))))))

This formula simplifies, applying FORMULA-F-OR, and unfolding IMPLIES, NLISTP,
NOT, MAKE-DISJUNCT, MEMBER, AND, M2-PROOF, and OR, to the following 18 new
conjectures:

Case 18.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (NOT (EQUAL EXP1 (CAR FLIST)))
                      (NOT (EQUAL EXP2 (CAR FLIST)))
                      (MEMBER EXP1 (CDR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (M2-PROOF EXP1 EXP2 (CDR FLIST) PF)
                              (MAKE-DISJUNCT (CDR FLIST))
                              GIVEN DEFNS SYMBOLS)
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS))
                 (PROVES (EXPAN-PROOF (CAR FLIST)
                                      (MAKE-DISJUNCT (CDR FLIST))
                                      (M2-PROOF EXP1 EXP2 (CDR FLIST) PF))
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)).

  However this again simplifies, applying FORMULA-F-OR and EXPAN-PROOF-PROVES,
  to:

        T.

Case 17.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (NOT (EQUAL EXP1 (CAR FLIST)))
                      (NOT (EQUAL EXP2 (CAR FLIST)))
                      (MEMBER EXP1 (CDR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (M2-PROOF EXP1 EXP2 (CDR FLIST) PF)
                              (MAKE-DISJUNCT (CDR FLIST))
                              GIVEN DEFNS SYMBOLS)
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS))
                 (PROVES (EXPAN-PROOF (CAR FLIST)
                                      (MAKE-DISJUNCT (CDR FLIST))
                                      (M2-PROOF EXP1 EXP2 (CDR FLIST) PF))
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)).

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

        T.

Case 16.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (NOT (EQUAL EXP1 (CAR FLIST)))
                      (NOT (EQUAL EXP2 (CAR FLIST)))
                      (NOT (FORMULA (MAKE-DISJUNCT (CDR FLIST))
                                    SYMBOLS))
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (EXPAN-PROOF (CAR FLIST)
                                      (MAKE-DISJUNCT (CDR FLIST))
                                      (M2-PROOF EXP1 EXP2 (CDR FLIST) PF))
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, rewriting with FORMULA-F-OR, to:

        T.

Case 15.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (NOT (EQUAL EXP1 (CAR FLIST)))
                      (NOT (EQUAL EXP2 (CAR FLIST)))
                      (NOT (FORMULA (MAKE-DISJUNCT (CDR FLIST))
                                    SYMBOLS))
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (EXPAN-PROOF (CAR FLIST)
                                      (MAKE-DISJUNCT (CDR FLIST))
                                      (M2-PROOF EXP1 EXP2 (CDR FLIST) PF))
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)).

  However this again simplifies, expanding the definitions of MAKE-DISJUNCT,
  FORSOMEP, F-ORP, F-NOTP, FORMULA, and MEMBER, to:

        T.

Case 14.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (NOT (EQUAL EXP1 (CAR FLIST)))
                      (EQUAL EXP2 (CAR FLIST))
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M2-PROOF-STEP EXP2 EXP1
                                        (CDR FLIST)
                                        (COMMUT-PROOF EXP1 EXP2 PF))
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)),

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

        T.

Case 13.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (NOT (EQUAL EXP1 (CAR FLIST)))
                      (EQUAL EXP2 (CAR FLIST))
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M2-PROOF-STEP EXP2 EXP1
                                        (CDR FLIST)
                                        (COMMUT-PROOF EXP1 EXP2 PF))
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying FORMULA-F-OR, COMMUT-PROOF-PROVES, and
  M2-PROOF-STEP-PROVES1, to:

        T.

Case 12.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (EQUAL EXP1 (CAR FLIST))
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M2-PROOF-STEP EXP1 EXP2
                                        (CDR FLIST)
                                        PF)
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)).

  However this again simplifies, applying FORMULA-F-OR and
  M2-PROOF-STEP-PROVES1, to:

        T.

Case 11.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (EQUAL EXP1 (CAR FLIST))
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (EQUAL EXP2 (CAR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M2-PROOF-STEP EXP1 EXP2
                                        (CDR FLIST)
                                        PF)
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)).

  This again simplifies, clearly, to:

        T.

Case 10.(IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (EQUAL EXP1 (CAR FLIST))
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M2-PROOF-STEP EXP1 EXP2
                                        (CDR FLIST)
                                        PF)
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)).

  But this again simplifies, unfolding the function MEMBER, to:

        T.

Case 9. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (NOT (EQUAL EXP1 EXP2))
                      (EQUAL EXP1 (CAR FLIST))
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (EQUAL EXP2 (CAR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M2-PROOF-STEP EXP1 EXP2
                                        (CDR FLIST)
                                        PF)
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, obviously, to:

        T.

Case 8. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (EQUAL EXP1 (CAR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)).

  This again simplifies, expanding MEMBER, to:

        T.

Case 7. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (EQUAL EXP1 (CAR FLIST))
                      (EQUAL EXP2 (CAR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, appealing to the lemmas CONTRAC-PROOF-PROVES and
  M1-PROOF-PROVES1, and unfolding the functions MEMBER and MAKE-DISJUNCT, to:

        T.

Case 6. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)),

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

        T.

Case 5. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (NOT (LISTP (CDR FLIST)))
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (EQUAL EXP2 (CAR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (CAR FLIST)
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, opening up MEMBER, to:

        T.

Case 4. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying FORMULA-F-OR, CONTRAC-PROOF-PROVES, and
  M1-PROOF-PROVES1, and expanding MEMBER and MAKE-DISJUNCT, to:

        T.

Case 3. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (EQUAL EXP1 (CAR FLIST))
                      (MEMBER EXP2 (CDR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)).

  However this again simplifies, rewriting with the lemmas FORMULA-F-OR,
  CONTRAC-PROOF-PROVES, and M1-PROOF-PROVES1, and expanding MEMBER and
  MAKE-DISJUNCT, to:

        T.

Case 2. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (MEMBER EXP1 (CDR FLIST))
                      (EQUAL EXP2 (CAR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, appealing to the lemmas FORMULA-F-OR,
  CONTRAC-PROOF-PROVES, and M1-PROOF-PROVES1, and unfolding MEMBER and
  MAKE-DISJUNCT, to:

        T.

Case 1. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (LISTP FLIST)
                      (EQUAL EXP1 EXP2)
                      (LISTP (CDR FLIST))
                      (FORMULA (F-OR (CAR FLIST)
                                     (MAKE-DISJUNCT (CDR FLIST)))
                               SYMBOLS)
                      (EQUAL EXP1 (CAR FLIST))
                      (EQUAL EXP2 (CAR FLIST))
                      (PROVES PF
                              (F-OR EXP1 EXP2)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M1-PROOF EXP1 FLIST
                                   (CONTRAC-PROOF EXP1 PF))
                         (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying FORMULA-F-OR, CONTRAC-PROOF-PROVES, and
  M1-PROOF-PROVES1, and expanding MEMBER and MAKE-DISJUNCT, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

M2-PROOF-PROVES


(PROVE-LEMMA M2-PROOF-PROVES1
             (REWRITE)
             (IMPLIES (AND (FORMULA (MAKE-DISJUNCT FLIST)
                                    SYMBOLS)
                           (MEMBER EXP1 FLIST)
                           (MEMBER EXP2 FLIST)
                           (PROVES PF
                                   (F-OR EXP1 EXP2)
                                   GIVEN DEFNS SYMBOLS)
                           (EQUAL CONCL (MAKE-DISJUNCT FLIST)))
                      (PROVES (M2-PROOF EXP1 EXP2 FLIST PF)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((USE (M2-PROOF-PROVES))))

This simplifies, applying the lemma M2-PROOF-PROVES, and opening up the
functions AND and IMPLIES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

M2-PROOF-PROVES1


(TOGGLE G0235 M2-PROOF T)

[ 0.0 0.0 0.0 ]

G0235


(TOGGLE G0236 M2-PROOF-PROVES T)

[ 0.0 0.0 0.0 ]

G0236


(DEFN M3-PROOF
 (EXP1 EXP2 FLIST2 PF)
 (CONTRAC-PROOF
  (MAKE-DISJUNCT FLIST2)
  (CONTRAC-PROOF
   (F-OR (MAKE-DISJUNCT FLIST2)
         (MAKE-DISJUNCT FLIST2))
   (M2-PROOF
    (F-OR (MAKE-DISJUNCT FLIST2)
          (MAKE-DISJUNCT FLIST2))
    EXP1
    (CONS (F-OR (MAKE-DISJUNCT FLIST2)
                (MAKE-DISJUNCT FLIST2))
          (CONS (MAKE-DISJUNCT FLIST2) FLIST2))
    (ASSOC-PROOF
      (MAKE-DISJUNCT FLIST2)
      (MAKE-DISJUNCT FLIST2)
      EXP1
      (COMMUT-PROOF (F-OR (MAKE-DISJUNCT FLIST2) EXP1)
                    (MAKE-DISJUNCT FLIST2)
                    (M2-PROOF (F-OR (MAKE-DISJUNCT FLIST2) EXP1)
                              EXP2
                              (CONS (F-OR (MAKE-DISJUNCT FLIST2) EXP1)
                                    FLIST2)
                              (ASSOC-PROOF (MAKE-DISJUNCT FLIST2)
                                           EXP1 EXP2
                                           (COMMUT-PROOF (F-OR EXP1 EXP2)
                                                         (MAKE-DISJUNCT FLIST2)
                                                         PF)))))))))

     Observe that (LISTP (M3-PROOF EXP1 EXP2 FLIST2 PF)) is a theorem.




[ 0.0 0.0 0.0 ]

M3-PROOF


(DEFN FORM-LIST
      (FLIST SYMBOLS)
      (IF (LISTP FLIST)
          (AND (FORMULA (CAR FLIST) SYMBOLS)
               (FORM-LIST (CDR FLIST) SYMBOLS))
          T))

     Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT FLIST) decreases according to the well-founded relation LESSP in each
recursive call.  Hence, FORM-LIST is accepted under the principle of
definition.  Note that:
      (OR (FALSEP (FORM-LIST FLIST SYMBOLS))
          (TRUEP (FORM-LIST FLIST SYMBOLS)))
is a theorem.




[ 0.0 0.0 0.0 ]

FORM-LIST


(PROVE-LEMMA SUBSET-CONS
             (REWRITE)
             (IMPLIES (SUBSET X Y)
                      (SUBSET X (CONS Z Y))))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  Two inductions are suggested
by terms in the conjecture.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X) (p (CDR X) Z Y))
                    (p X Z Y))
           (IMPLIES (NOT (LISTP X)) (p X Z Y))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates three new conjectures:

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (SUBSET (CDR X) Y))
                      (SUBSET X Y))
                 (SUBSET X (CONS Z Y))),

  which simplifies, expanding the function SUBSET, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (SUBSET (CDR X) (CONS Z Y))
                      (SUBSET X Y))
                 (SUBSET X (CONS Z Y))),

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

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X)) (SUBSET X Y))
                 (SUBSET X (CONS Z Y))),

  which simplifies, opening up SUBSET, to:

        T.


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


[ 0.0 0.0 0.0 ]

SUBSET-CONS


(PROVE-LEMMA FORMLIST-FORMULA-MAKE-DISJ
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST)
                           (FORM-LIST FLIST SYMBOLS))
                      (FORMULA (MAKE-DISJUNCT FLIST)
                               SYMBOLS)))


     Name the conjecture *1.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest two inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP FLIST)
                         (p (CDR FLIST) SYMBOLS))
                    (p FLIST SYMBOLS))
           (IMPLIES (NOT (LISTP FLIST))
                    (p FLIST SYMBOLS))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT FLIST) 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 goals:

Case 3. (IMPLIES (AND (NOT (LISTP (CDR FLIST)))
                      (LISTP FLIST)
                      (FORM-LIST FLIST SYMBOLS))
                 (FORMULA (MAKE-DISJUNCT FLIST)
                          SYMBOLS)).

  This simplifies, expanding the definitions of FORM-LIST and MAKE-DISJUNCT,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (FORM-LIST (CDR FLIST) SYMBOLS))
                      (LISTP FLIST)
                      (FORM-LIST FLIST SYMBOLS))
                 (FORMULA (MAKE-DISJUNCT FLIST)
                          SYMBOLS)).

  This simplifies, unfolding FORM-LIST, to:

        T.

Case 1. (IMPLIES (AND (FORMULA (MAKE-DISJUNCT (CDR FLIST))
                               SYMBOLS)
                      (LISTP FLIST)
                      (FORM-LIST FLIST SYMBOLS))
                 (FORMULA (MAKE-DISJUNCT FLIST)
                          SYMBOLS)).

  This simplifies, unfolding the definitions of FORM-LIST and MAKE-DISJUNCT,
  to:

        (IMPLIES (AND (FORMULA (MAKE-DISJUNCT (CDR FLIST))
                               SYMBOLS)
                      (LISTP FLIST)
                      (FORMULA (CAR FLIST) SYMBOLS)
                      (FORM-LIST (CDR FLIST) SYMBOLS)
                      (LISTP (CDR FLIST)))
                 (FORMULA (F-OR (CAR FLIST)
                                (MAKE-DISJUNCT (CDR FLIST)))
                          SYMBOLS)),

  which again simplifies, applying FORMULA-F-OR, to:

        T.


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


[ 0.0 0.0 0.0 ]

FORMLIST-FORMULA-MAKE-DISJ


(PROVE-LEMMA M3-PROOF-PROVES
 (REWRITE)
 (IMPLIES (AND (PROVES PF
                       (MAKE-DISJUNCT (CONS (F-OR EXP1 EXP2) FLIST2))
                       GIVEN DEFNS SYMBOLS)
               (MEMBER EXP1 FLIST2)
               (MEMBER EXP2 FLIST2))
          (PROVES (M3-PROOF EXP1 EXP2 FLIST2 PF)
                  (MAKE-DISJUNCT FLIST2)
                  GIVEN DEFNS SYMBOLS))
 ((USE
    (PROVES-IS-FORMULA (EXP (MAKE-DISJUNCT (CONS (F-OR EXP1 EXP2) FLIST2)))))))

This formula simplifies, rewriting with the lemmas CAR-CONS and CDR-CONS, and
opening up MAKE-DISJUNCT, IMPLIES, MEMBER, and M3-PROOF, to:

      (IMPLIES
       (AND (LISTP FLIST2)
            (FORMULA (F-OR (F-OR EXP1 EXP2)
                           (MAKE-DISJUNCT FLIST2))
                     SYMBOLS)
            (PROVES PF
                    (F-OR (F-OR EXP1 EXP2)
                          (MAKE-DISJUNCT FLIST2))
                    GIVEN DEFNS SYMBOLS)
            (MEMBER EXP1 FLIST2)
            (MEMBER EXP2 FLIST2))
       (PROVES
        (CONTRAC-PROOF
         (MAKE-DISJUNCT FLIST2)
         (CONTRAC-PROOF
          (F-OR (MAKE-DISJUNCT FLIST2)
                (MAKE-DISJUNCT FLIST2))
          (M2-PROOF
           (F-OR (MAKE-DISJUNCT FLIST2)
                 (MAKE-DISJUNCT FLIST2))
           EXP1
           (CONS (F-OR (MAKE-DISJUNCT FLIST2)
                       (MAKE-DISJUNCT FLIST2))
                 (CONS (MAKE-DISJUNCT FLIST2) FLIST2))
           (ASSOC-PROOF
            (MAKE-DISJUNCT FLIST2)
            (MAKE-DISJUNCT FLIST2)
            EXP1
            (COMMUT-PROOF
                    (F-OR (MAKE-DISJUNCT FLIST2) EXP1)
                    (MAKE-DISJUNCT FLIST2)
                    (M2-PROOF (F-OR (MAKE-DISJUNCT FLIST2) EXP1)
                              EXP2
                              (CONS (F-OR (MAKE-DISJUNCT FLIST2) EXP1)
                                    FLIST2)
                              (ASSOC-PROOF (MAKE-DISJUNCT FLIST2)
                                           EXP1 EXP2
                                           (COMMUT-PROOF (F-OR EXP1 EXP2)
                                                         (MAKE-DISJUNCT FLIST2)
                                                         PF))))))))
        (MAKE-DISJUNCT FLIST2)
        GIVEN DEFNS SYMBOLS)).

However this again simplifies, rewriting with FORMULA-F-OR,
CONTRAC-PROOF-PROVES, M2-PROOF-PROVES1, COMMUT-PROOF-PROVES,
ASSOC-PROOF-PROVES, CDR-CONS, and CAR-CONS, and unfolding MEMBER and
MAKE-DISJUNCT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

M3-PROOF-PROVES


(TOGGLE G0222 M3-PROOF T)

[ 0.0 0.0 0.0 ]

G0222


(PROVE-LEMMA M3-PROOF-PROVES1
           (REWRITE)
           (IMPLIES (AND (PROVES PF
                                 (MAKE-DISJUNCT (CONS (F-OR EXP1 EXP2) FLIST2))
                                 GIVEN DEFNS SYMBOLS)
                         (MEMBER EXP1 FLIST2)
                         (MEMBER EXP2 FLIST2)
                         (EQUAL CONCL (MAKE-DISJUNCT FLIST2)))
                    (PROVES (M3-PROOF EXP1 EXP2 FLIST2 PF)
                            CONCL GIVEN DEFNS SYMBOLS))
           ((USE (M3-PROOF-PROVES))))

This simplifies, applying CAR-CONS, CDR-CONS, and M3-PROOF-PROVES, and
expanding the functions MAKE-DISJUNCT, AND, IMPLIES, and MEMBER, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

M3-PROOF-PROVES1


(TOGGLE G0229 M3-PROOF-PROVES T)

[ 0.0 0.0 0.0 ]

G0229


(DEFN M-PROOF
      (FLIST1 FLIST2 PF)
      (IF (NLISTP FLIST1)
          NIL
          (IF (NLISTP (CDR FLIST1))
              (M1-PROOF (CAR FLIST1) FLIST2 PF)
              (IF (NLISTP (CDDR FLIST1))
                  (M2-PROOF (CAR FLIST1)
                            (CADR FLIST1)
                            FLIST2 PF)
                  (M3-PROOF (CAR FLIST1)
                            (CADR FLIST1)
                            FLIST2
                            (M-PROOF (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                           (CDDR FLIST1))
                                     (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                           FLIST2)
                                     (ASSOC-PROOF (CAR FLIST1)
                                                  (CADR FLIST1)
                                                  (MAKE-DISJUNCT (CDDR FLIST1))
                                                  PF))))))
      ((LESSP (LENGTH FLIST1))))

     Linear arithmetic, the lemmas SUB1-ADD1 and CDR-CONS, and the definitions
of LESSP, LENGTH, and NLISTP establish that the measure (LENGTH FLIST1)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, M-PROOF is accepted under the principle of definition.  Observe that:
      (OR (OR (LITATOM (M-PROOF FLIST1 FLIST2 PF))
              (LISTP (M-PROOF FLIST1 FLIST2 PF)))
          (EQUAL (M-PROOF FLIST1 FLIST2 PF) PF))
is a theorem.




[ 0.0 0.0 0.0 ]

M-PROOF


(PROVE-LEMMA M-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORM-LIST FLIST2 SYMBOLS)
                           (LISTP FLIST1)
                           (LISTP FLIST2)
                           (SUBSET FLIST1 FLIST2)
                           (PROVES PF
                                   (MAKE-DISJUNCT FLIST1)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (M-PROOF FLIST1 FLIST2 PF)
                              (MAKE-DISJUNCT FLIST2)
                              GIVEN DEFNS SYMBOLS))
             ((INDUCT (M-PROOF FLIST1 FLIST2 PF))))

This conjecture can be simplified, using the abbreviations IMPLIES, NLISTP,
NOT, OR, and AND, to four new goals:

Case 4. T,

  which simplifies, clearly, to:

        T.

Case 3. (IMPLIES (AND (LISTP FLIST1)
                      (NOT (LISTP (CDR FLIST1)))
                      (FORM-LIST FLIST2 SYMBOLS)
                      (LISTP FLIST2)
                      (SUBSET FLIST1 FLIST2)
                      (PROVES PF
                              (MAKE-DISJUNCT FLIST1)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M-PROOF FLIST1 FLIST2 PF)
                         (MAKE-DISJUNCT FLIST2)
                         GIVEN DEFNS SYMBOLS)).

  This simplifies, rewriting with FORMLIST-FORMULA-MAKE-DISJ and
  M1-PROOF-PROVES1, and expanding the definitions of SUBSET, MAKE-DISJUNCT,
  and M-PROOF, to:

        T.

Case 2. (IMPLIES (AND (LISTP FLIST1)
                      (LISTP (CDR FLIST1))
                      (NOT (LISTP (CDDR FLIST1)))
                      (FORM-LIST FLIST2 SYMBOLS)
                      (LISTP FLIST2)
                      (SUBSET FLIST1 FLIST2)
                      (PROVES PF
                              (MAKE-DISJUNCT FLIST1)
                              GIVEN DEFNS SYMBOLS))
                 (PROVES (M-PROOF FLIST1 FLIST2 PF)
                         (MAKE-DISJUNCT FLIST2)
                         GIVEN DEFNS SYMBOLS)),

  which simplifies, rewriting with FORMLIST-FORMULA-MAKE-DISJ and
  M2-PROOF-PROVES1, and opening up SUBSET, MAKE-DISJUNCT, and M-PROOF, to:

        T.

Case 1. (IMPLIES
         (AND
          (LISTP FLIST1)
          (LISTP (CDR FLIST1))
          (LISTP (CDDR FLIST1))
          (IMPLIES
            (AND (FORM-LIST (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                  FLIST2)
                            SYMBOLS)
                 (LISTP (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                              (CDDR FLIST1)))
                 (LISTP (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                              FLIST2))
                 (SUBSET (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                               (CDDR FLIST1))
                         (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                               FLIST2))
                 (PROVES (ASSOC-PROOF (CAR FLIST1)
                                      (CADR FLIST1)
                                      (MAKE-DISJUNCT (CDDR FLIST1))
                                      PF)
                         (MAKE-DISJUNCT (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                              (CDDR FLIST1)))
                         GIVEN DEFNS SYMBOLS))
            (PROVES (M-PROOF (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                   (CDDR FLIST1))
                             (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                   FLIST2)
                             (ASSOC-PROOF (CAR FLIST1)
                                          (CADR FLIST1)
                                          (MAKE-DISJUNCT (CDDR FLIST1))
                                          PF))
                    (MAKE-DISJUNCT (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                         FLIST2))
                    GIVEN DEFNS SYMBOLS))
          (FORM-LIST FLIST2 SYMBOLS)
          (LISTP FLIST2)
          (SUBSET FLIST1 FLIST2)
          (PROVES PF
                  (MAKE-DISJUNCT FLIST1)
                  GIVEN DEFNS SYMBOLS))
         (PROVES (M-PROOF FLIST1 FLIST2 PF)
                 (MAKE-DISJUNCT FLIST2)
                 GIVEN DEFNS SYMBOLS)).

  This simplifies, applying CDR-CONS, FORMULA-F-OR, CAR-CONS,
  PROVES-IS-FORMULA-AGAIN, and M3-PROOF-PROVES1, and unfolding the definitions
  of FORM-LIST, MEMBER, SUBSET, MAKE-DISJUNCT, AND, IMPLIES, and M-PROOF, to
  two new conjectures:

  Case 1.2.
          (IMPLIES
           (AND (LISTP FLIST1)
                (LISTP (CDR FLIST1))
                (LISTP (CDDR FLIST1))
                (NOT (SUBSET (CDDR FLIST1)
                             (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                   FLIST2)))
                (FORM-LIST FLIST2 SYMBOLS)
                (LISTP FLIST2)
                (MEMBER (CAR FLIST1) FLIST2)
                (MEMBER (CADR FLIST1) FLIST2)
                (SUBSET (CDDR FLIST1) FLIST2)
                (PROVES PF
                        (F-OR (CAR FLIST1)
                              (F-OR (CADR FLIST1)
                                    (MAKE-DISJUNCT (CDDR FLIST1))))
                        GIVEN DEFNS SYMBOLS))
           (PROVES
                  (M3-PROOF (CAR FLIST1)
                            (CADR FLIST1)
                            FLIST2
                            (M-PROOF (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                           (CDDR FLIST1))
                                     (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                           FLIST2)
                                     (ASSOC-PROOF (CAR FLIST1)
                                                  (CADR FLIST1)
                                                  (MAKE-DISJUNCT (CDDR FLIST1))
                                                  PF)))
                  (MAKE-DISJUNCT FLIST2)
                  GIVEN DEFNS SYMBOLS)),

    which again simplifies, applying the lemma SUBSET-CONS, to:

          T.

  Case 1.1.
          (IMPLIES
           (AND (LISTP FLIST1)
                (LISTP (CDR FLIST1))
                (LISTP (CDDR FLIST1))
                (NOT (PROVES (ASSOC-PROOF (CAR FLIST1)
                                          (CADR FLIST1)
                                          (MAKE-DISJUNCT (CDDR FLIST1))
                                          PF)
                             (F-OR (F-OR (CAR FLIST1) (CADR FLIST1))
                                   (MAKE-DISJUNCT (CDDR FLIST1)))
                             GIVEN DEFNS SYMBOLS))
                (FORM-LIST FLIST2 SYMBOLS)
                (LISTP FLIST2)
                (MEMBER (CAR FLIST1) FLIST2)
                (MEMBER (CADR FLIST1) FLIST2)
                (SUBSET (CDDR FLIST1) FLIST2)
                (PROVES PF
                        (F-OR (CAR FLIST1)
                              (F-OR (CADR FLIST1)
                                    (MAKE-DISJUNCT (CDDR FLIST1))))
                        GIVEN DEFNS SYMBOLS))
           (PROVES
                  (M3-PROOF (CAR FLIST1)
                            (CADR FLIST1)
                            FLIST2
                            (M-PROOF (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                           (CDDR FLIST1))
                                     (CONS (F-OR (CAR FLIST1) (CADR FLIST1))
                                           FLIST2)
                                     (ASSOC-PROOF (CAR FLIST1)
                                                  (CADR FLIST1)
                                                  (MAKE-DISJUNCT (CDDR FLIST1))
                                                  PF)))
                  (MAKE-DISJUNCT FLIST2)
                  GIVEN DEFNS SYMBOLS)),

    which again simplifies, rewriting with the lemma ASSOC-PROOF-PROVES, to:

          T.

Q.E.D.


[ 0.0 0.0 0.0 ]

M-PROOF-PROVES


(DEFN TERMP1
      (EXP FLG)
      (IF (ZEROP FLG)
          (IF (LISTP EXP)
              (AND (FUNCTION (CAR EXP))
                   (EQUAL (LENGTH (CDR EXP))
                          (DEGREE (CAR EXP)))
                   (TERMP1 (CDR EXP) 1))
              (VARIABLE EXP))
          (IF (NLISTP EXP)
              T
              (AND (TERMP1 (CAR EXP) 0)
                   (TERMP1 (CDR EXP) 1)))))

     Linear arithmetic, the lemmas CDR-LESSP, CDR-LESSEQP, CAR-LESSEQP, and
CAR-LESSP, and the definitions of NLISTP and ZEROP can be used to establish
that the measure (COUNT EXP) decreases according to the well-founded relation
LESSP in each recursive call.  Hence, TERMP1 is accepted under the
definitional principle.  Observe that:
      (OR (FALSEP (TERMP1 EXP FLG))
          (TRUEP (TERMP1 EXP FLG)))
is a theorem.




[ 0.0 0.0 0.0 ]

TERMP1


(PROVE-LEMMA TERMP-TERMP1
             (REWRITE)
             (IMPLIES (TERMP EXP FLG SYMBOLS)
                      (TERMP1 EXP FLG)))

WARNING:  Note that TERMP-TERMP1 contains the free variable SYMBOLS which will
be chosen by instantiating the hypothesis (TERMP EXP FLG SYMBOLS).



     Call the conjecture *1.


     We will try to prove it by induction.  The recursive terms in the
conjecture suggest two inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG)
                         (LISTP EXP)
                         (p (CDR EXP) 1 SYMBOLS))
                    (p EXP FLG SYMBOLS))
           (IMPLIES (AND (ZEROP FLG) (NOT (LISTP EXP)))
                    (p EXP FLG SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP FLG)) (NLISTP EXP))
                    (p EXP FLG SYMBOLS))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (NLISTP EXP))
                         (p (CDR EXP) 1 SYMBOLS)
                         (p (CAR EXP) 0 SYMBOLS))
                    (p EXP FLG SYMBOLS))).
Linear arithmetic, the lemmas CDR-LESSP, CDR-LESSEQP, CAR-LESSEQP, and
CAR-LESSP, and the definitions of NLISTP and ZEROP can be used to establish
that the measure (COUNT EXP) decreases according to the well-founded relation
LESSP in each induction step of the scheme.  Note, however, the inductive
instances chosen for FLG.  The above induction scheme generates the following
eight new formulas:

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (LISTP EXP)
                      (NOT (TERMP (CDR EXP) 1 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)).

  This simplifies, expanding the definitions of ZEROP, SYMB, EQUAL, and TERMP,
  to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (LISTP EXP)
                      (TERMP1 (CDR EXP) 1)
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)).

  This simplifies, appealing to the lemmas NOT-FUNCTION and PREDICATE-P, and
  opening up ZEROP, SYMB, EQUAL, TERMP, TERMP1, NLISTP, and OR, to the
  following two new conjectures:

  Case 7.2.
          (IMPLIES (AND (EQUAL FLG 0)
                        (LISTP EXP)
                        (TERMP1 (CDR EXP) 1)
                        (FUNCTION (CAR EXP))
                        (EQUAL (CAR EXP) (P 0 2))
                        (TERMP (CDR EXP) 1 SYMBOLS))
                   (NOT (EQUAL (LENGTH (CDR EXP))
                               (DEGREE (CAR EXP))))).

    However this again simplifies, applying PREDICATE-P and NOT-FUNCTION, and
    unfolding the definitions of OR and NLISTP, to:

          T.

  Case 7.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (LISTP EXP)
                        (TERMP1 (CDR EXP) 1)
                        (FUNCTION (CAR EXP))
                        (EQUAL (CAR EXP) (P 0 2))
                        (TERMP (CDR EXP) 1 SYMBOLS))
                   (NOT (EQUAL (LENGTH (CDR EXP))
                               (DEGREE (CAR EXP))))).

    But this again simplifies, applying the lemmas PREDICATE-P and
    NOT-FUNCTION, and opening up OR and NLISTP, to:

          T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (LISTP EXP))
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)),

  which simplifies, expanding the definitions of ZEROP, VARIABLE, EQUAL, TERMP,
  and TERMP1, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NLISTP EXP)
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)),

  which simplifies, expanding the functions ZEROP, NLISTP, TERMP, and TERMP1,
  to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (NOT (TERMP (CDR EXP) 1 SYMBOLS))
                      (NOT (TERMP (CAR EXP) 0 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)),

  which simplifies, opening up the functions ZEROP, NLISTP, and TERMP, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (TERMP1 (CDR EXP) 1)
                      (NOT (TERMP (CAR EXP) 0 SYMBOLS))
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)),

  which simplifies, opening up ZEROP, NLISTP, and TERMP, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (NOT (TERMP (CDR EXP) 1 SYMBOLS))
                      (TERMP1 (CAR EXP) 0)
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)),

  which simplifies, expanding the functions ZEROP, NLISTP, and TERMP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (NLISTP EXP))
                      (TERMP1 (CDR EXP) 1)
                      (TERMP1 (CAR EXP) 0)
                      (TERMP EXP FLG SYMBOLS))
                 (TERMP1 EXP FLG)),

  which simplifies, expanding the definitions of ZEROP, NLISTP, TERMP, and
  TERMP1, to:

        T.


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


[ 0.0 0.0 0.0 ]

TERMP-TERMP1


(DEFN ATOMP1
      (EXP)
      (AND (PREDICATE (CAR EXP))
           (EQUAL (LENGTH (CDR EXP))
                  (DEGREE (CAR EXP)))
           (TERMP1 (CDR EXP) 1)))

     Note that (OR (FALSEP (ATOMP1 EXP)) (TRUEP (ATOMP1 EXP))) is a theorem.




[ 0.0 0.0 0.0 ]

ATOMP1


(TOGGLE G0345 ATOMP NIL)

[ 0.0 0.0 0.0 ]

G0345


(PROVE-LEMMA ATOMP-ATOMP1
             (REWRITE)
             (IMPLIES (ATOMP EXP SYMBOLS)
                      (ATOMP1 EXP)))

WARNING:  Note that the rewrite rule ATOMP-ATOMP1 will be stored so as to
apply only to terms with the nonrecursive function symbol ATOMP1.


WARNING:  Note that ATOMP-ATOMP1 contains the free variable SYMBOLS which will
be chosen by instantiating the hypothesis (ATOMP EXP SYMBOLS).


This conjecture can be simplified, using the abbreviations ATOMP and IMPLIES,
to:

      (IMPLIES (AND (PREDICATE (CAR EXP))
                    (SYMB (CAR EXP) SYMBOLS)
                    (EQUAL (LENGTH (CDR EXP))
                           (DEGREE (CAR EXP)))
                    (TERMP (CDR EXP) 1 SYMBOLS))
               (ATOMP1 EXP)).

This simplifies, rewriting with DEGREE-P, TERMP-TERMP1, and PREDICATE-P, and
expanding the definitions of SYMB, NUMBERP, EQUAL, and ATOMP1, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ATOMP-ATOMP1


(DEFN DBLE-NEG-TYPE
      (EXP)
      (AND (F-NOTP EXP) (F-NOTP (ARG EXP))))

     From the definition we can conclude that:
      (OR (FALSEP (DBLE-NEG-TYPE EXP))
          (TRUEP (DBLE-NEG-TYPE EXP)))
is a theorem.




[ 0.0 0.0 0.0 ]

DBLE-NEG-TYPE


(DEFN NEG
      (EXP1 EXP2)
      (OR (EQUAL EXP1 (F-NOT EXP2))
          (EQUAL EXP2 (F-NOT EXP1))))

     Note that (OR (FALSEP (NEG EXP1 EXP2)) (TRUEP (NEG EXP1 EXP2))) is a
theorem.




[ 0.0 0.0 0.0 ]

NEG


(DEFN NEG-LIST
      (EXP LIST)
      (IF (F-NOTP EXP)
          (MEMBER (ARG EXP) LIST)
          (MEMBER (F-NOT EXP) LIST)))

     Note that (OR (FALSEP (NEG-LIST EXP LIST)) (TRUEP (NEG-LIST EXP LIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

NEG-LIST


(DEFN ELEM-FORM
      (EXP)
      (OR (ATOMP1 EXP)
          (AND (FORSOMEP EXP)
               (EQUAL EXP
                      (FORSOME (BIND EXP) (BODY EXP))))))

     From the definition we can conclude that:
      (OR (FALSEP (ELEM-FORM EXP))
          (TRUEP (ELEM-FORM EXP)))
is a theorem.




[ 0.0 0.0 0.0 ]

ELEM-FORM


(DEFN NEG-ELEM-FORM
      (EXP)
      (AND (F-NOTP EXP)
           (ELEM-FORM (ARG EXP))))

     From the definition we can conclude that:
      (OR (FALSEP (NEG-ELEM-FORM EXP))
          (TRUEP (NEG-ELEM-FORM EXP)))
is a theorem.




[ 0.0 0.0 0.0 ]

NEG-ELEM-FORM


(DEFN PROP-ATOMP
      (EXP)
      (OR (ELEM-FORM EXP)
          (NEG-ELEM-FORM EXP)))

     Observe that (OR (FALSEP (PROP-ATOMP EXP)) (TRUEP (PROP-ATOMP EXP))) is a
theorem.




[ 0.0 0.0 0.0 ]

PROP-ATOMP


(DEFN FORM-COUNT
      (EXP)
      (IF (F-NOTP EXP)
          (ADD1 (FORM-COUNT (ARG EXP)))
          (IF (F-ORP EXP)
              (ADD1 (PLUS (FORM-COUNT (ARG1 EXP))
                          (FORM-COUNT (ARG2 EXP))))
              1)))

     Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, and ARG1-LESSP
inform us that the measure (COUNT EXP) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, FORM-COUNT is accepted under
the definitional principle.  Observe that (NUMBERP (FORM-COUNT EXP)) is a
theorem.




[ 0.0 0.0 0.0 ]

FORM-COUNT


(DEFN LIST-COUNT
      (LIST)
      (IF (LISTP LIST)
          (PLUS (FORM-COUNT (CAR LIST))
                (LIST-COUNT (CDR LIST)))
          0))

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




[ 0.0 0.0 0.0 ]

LIST-COUNT


(DEFN NOR-TYPE
      (EXP)
      (AND (F-NOTP EXP) (F-ORP (ARG EXP))))

     From the definition we can conclude that:
      (OR (FALSEP (NOR-TYPE EXP))
          (TRUEP (NOR-TYPE EXP)))
is a theorem.




[ 0.0 0.0 0.0 ]

NOR-TYPE


(PROVE-LEMMA LESSP-LIST-COUNT
             (REWRITE)
             (IMPLIES (LISTP FLIST)
                      (LESSP (LIST-COUNT (CDR FLIST))
                             (LIST-COUNT FLIST))))

WARNING:  Note that the proposed lemma LESSP-LIST-COUNT is to be stored as
zero type prescription rules, zero compound recognizer rules, one linear rule,
and zero replacement rules.


This formula simplifies, expanding the function LIST-COUNT, to the formula:

      (IMPLIES (LISTP FLIST)
               (LESSP (LIST-COUNT (CDR FLIST))
                      (PLUS (FORM-COUNT (CAR FLIST))
                            (LIST-COUNT (CDR FLIST))))).

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

      (LESSP (LIST-COUNT X)
             (PLUS (FORM-COUNT Z) (LIST-COUNT X))),

which we would usually push and work on later by induction.  But if we must
use induction to prove the input conjecture, we prefer to induct on the
original formulation of the problem.  Thus we will disregard all that we have
previously done, give the name *1 to the original input, and work on it.


     So now let us consider:

(IMPLIES (LISTP FLIST)
         (LESSP (LIST-COUNT (CDR FLIST))
                (LIST-COUNT FLIST))),

which we named *1 above.  We will appeal to induction.  There is only one
plausible induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP FLIST) (p (CDR FLIST)))
                    (p FLIST))
           (IMPLIES (NOT (LISTP FLIST))
                    (p FLIST))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure
(COUNT FLIST) 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 (AND (NOT (LISTP (CDR FLIST)))
                      (LISTP FLIST))
                 (LESSP (LIST-COUNT (CDR FLIST))
                        (LIST-COUNT FLIST))).

  This simplifies, unfolding LIST-COUNT, to the new goal:

        (IMPLIES (AND (NOT (LISTP (CDR FLIST)))
                      (LISTP FLIST))
                 (LESSP (LIST-COUNT (CDR FLIST))
                        (PLUS (FORM-COUNT (CAR FLIST))
                              (LIST-COUNT (CDR FLIST))))),

  which further simplifies, opening up the definitions of LIST-COUNT, EQUAL,
  and LESSP, to:

        (IMPLIES (AND (NOT (LISTP (CDR FLIST)))
                      (LISTP FLIST))
                 (NOT (EQUAL (PLUS (FORM-COUNT (CAR FLIST)) 0)
                             0))).

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

        (IMPLIES (NOT (LISTP X))
                 (NOT (EQUAL (PLUS (FORM-COUNT Z) 0) 0))).

  Eliminate the irrelevant term.  We would thus like to prove:

        (NOT (EQUAL (PLUS (FORM-COUNT Z) 0) 0)),

  which we will name *1.1.

Case 1. (IMPLIES (AND (LESSP (LIST-COUNT (CDDR FLIST))
                             (LIST-COUNT (CDR FLIST)))
                      (LISTP FLIST))
                 (LESSP (LIST-COUNT (CDR FLIST))
                        (LIST-COUNT FLIST))).

  This simplifies, expanding the function LIST-COUNT, to the new goal:

        (IMPLIES (AND (LESSP (LIST-COUNT (CDDR FLIST))
                             (LIST-COUNT (CDR FLIST)))
                      (LISTP FLIST))
                 (LESSP (LIST-COUNT (CDR FLIST))
                        (PLUS (FORM-COUNT (CAR FLIST))
                              (LIST-COUNT (CDR FLIST))))),

  which further simplifies, opening up the definitions of LIST-COUNT, EQUAL,
  and LESSP, to two new conjectures:

  Case 1.2.
          (IMPLIES (AND (NOT (LISTP (CDR FLIST)))
                        (LESSP (LIST-COUNT (CDDR FLIST)) 0)
                        (LISTP FLIST))
                   (NOT (EQUAL (PLUS (FORM-COUNT (CAR FLIST)) 0)
                               0))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP (CDR FLIST))
                        (LESSP (LIST-COUNT (CDDR FLIST))
                               (PLUS (FORM-COUNT (CADR FLIST))
                                     (LIST-COUNT (CDDR FLIST))))
                        (LISTP FLIST))
                   (LESSP (PLUS (FORM-COUNT (CADR FLIST))
                                (LIST-COUNT (CDDR FLIST)))
                          (PLUS (FORM-COUNT (CAR FLIST))
                                (FORM-COUNT (CADR FLIST))
                                (LIST-COUNT (CDDR FLIST))))).

    Applying the lemma CAR-CDR-ELIM, replace FLIST by (CONS Z X) to eliminate
    (CDR FLIST) and (CAR FLIST) and X by (CONS W V) to eliminate (CDR X) and
    (CAR X).  We thus obtain the new goal:

          (IMPLIES (LESSP (LIST-COUNT V)
                          (PLUS (FORM-COUNT W) (LIST-COUNT V)))
                   (LESSP (PLUS (FORM-COUNT W) (LIST-COUNT V))
                          (PLUS (FORM-COUNT Z)
                                (FORM-COUNT W)
                                (LIST-COUNT V)))),

    which we generalize by replacing (FORM-COUNT W) by Y and (LIST-COUNT V) by
    A.  We restrict the new variables by recalling the type restriction lemma
    noted when FORM-COUNT was introduced and the type restriction lemma noted
    when LIST-COUNT was introduced.  We thus obtain:

          (IMPLIES (AND (NUMBERP Y)
                        (NUMBERP A)
                        (LESSP A (PLUS Y A)))
                   (LESSP (PLUS Y A)
                          (PLUS (FORM-COUNT Z) Y A))),

    which we generalize by replacing (PLUS Y A) by U.  We restrict the new
    variable by recalling the type restriction lemma noted when PLUS was
    introduced.  We would thus like to prove the new formula:

          (IMPLIES (AND (NUMBERP U)
                        (NUMBERP Y)
                        (NUMBERP A)
                        (LESSP A U))
                   (LESSP U (PLUS (FORM-COUNT Z) U))),

    which has an irrelevant term in it.  By eliminating the term we get the
    new formula:

          (IMPLIES (AND (NUMBERP U)
                        (NUMBERP A)
                        (LESSP A U))
                   (LESSP U (PLUS (FORM-COUNT Z) U))),

    which we will finally name *1.2.


     Perhaps we can prove it by induction.  Four inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions,
both of which are unflawed.  However, one of these is more likely than the
other.  We will induct according to the following scheme:
      (AND (IMPLIES (OR (EQUAL U 0) (NOT (NUMBERP U)))
                    (p U Z A))
           (IMPLIES (AND (NOT (OR (EQUAL U 0) (NOT (NUMBERP U))))
                         (OR (EQUAL A 0) (NOT (NUMBERP A))))
                    (p U Z A))
           (IMPLIES (AND (NOT (OR (EQUAL U 0) (NOT (NUMBERP U))))
                         (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                         (p (SUB1 U) Z (SUB1 A)))
                    (p U Z A))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT establish that the measure (COUNT A) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  Note,
however, the inductive instance chosen for U.  The above induction scheme
leads to the following four new goals:

Case 4. (IMPLIES (AND (OR (EQUAL U 0) (NOT (NUMBERP U)))
                      (NUMBERP U)
                      (NUMBERP A)
                      (LESSP A U))
                 (LESSP U (PLUS (FORM-COUNT Z) U))).

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

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL U 0) (NOT (NUMBERP U))))
                      (OR (EQUAL A 0) (NOT (NUMBERP A)))
                      (NUMBERP U)
                      (NUMBERP A)
                      (LESSP A U))
                 (LESSP U (PLUS (FORM-COUNT Z) U))).

  This simplifies, unfolding the definitions of NOT, OR, NUMBERP, EQUAL, and
  LESSP, to the following two new formulas:

  Case 3.2.
          (IMPLIES (AND (NOT (EQUAL U 0))
                        (EQUAL A 0)
                        (NUMBERP U))
                   (NOT (EQUAL (PLUS (FORM-COUNT Z) U) 0))).

    However this again simplifies, using linear arithmetic, to:

          T.

  Case 3.1.
          (IMPLIES (AND (NOT (EQUAL U 0))
                        (EQUAL A 0)
                        (NUMBERP U))
                   (LESSP (SUB1 U)
                          (SUB1 (PLUS (FORM-COUNT Z) U)))),

    which again simplifies, obviously, to:

          (IMPLIES (AND (NOT (EQUAL U 0)) (NUMBERP U))
                   (LESSP (SUB1 U)
                          (SUB1 (PLUS (FORM-COUNT Z) U)))).

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

          (IMPLIES (AND (NUMBERP X)
                        (NOT (EQUAL (ADD1 X) 0)))
                   (LESSP X
                          (SUB1 (PLUS (FORM-COUNT Z) (ADD1 X))))),

    which further simplifies, clearly, to:

          (IMPLIES (NUMBERP X)
                   (LESSP X
                          (SUB1 (PLUS (FORM-COUNT Z) (ADD1 X))))),

    which we will name *1.2.1.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL U 0) (NOT (NUMBERP U))))
                      (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                      (NOT (LESSP (SUB1 A) (SUB1 U)))
                      (NUMBERP U)
                      (NUMBERP A)
                      (LESSP A U))
                 (LESSP U (PLUS (FORM-COUNT Z) U))).

  This simplifies, using linear arithmetic, to:

        (IMPLIES (AND (EQUAL A 0)
                      (NOT (OR (EQUAL U 0) (NOT (NUMBERP U))))
                      (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                      (NOT (LESSP (SUB1 A) (SUB1 U)))
                      (NUMBERP U)
                      (NUMBERP A)
                      (LESSP A U))
                 (LESSP U (PLUS (FORM-COUNT Z) U))),

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

        T.

Case 1. (IMPLIES (AND (NOT (OR (EQUAL U 0) (NOT (NUMBERP U))))
                      (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                      (LESSP (SUB1 U)
                             (PLUS (FORM-COUNT Z) (SUB1 U)))
                      (NUMBERP U)
                      (NUMBERP A)
                      (LESSP A U))
                 (LESSP U (PLUS (FORM-COUNT Z) U))),

  which simplifies, using linear arithmetic, to:

        (IMPLIES (AND (EQUAL U 0)
                      (NOT (OR (EQUAL U 0) (NOT (NUMBERP U))))
                      (NOT (OR (EQUAL A 0) (NOT (NUMBERP A))))
                      (LESSP (SUB1 U)
                             (PLUS (FORM-COUNT Z) (SUB1 U)))
                      (NUMBERP U)
                      (NUMBERP A)
                      (LESSP A U))
                 (LESSP U (PLUS (FORM-COUNT Z) U))).

  This again simplifies, using linear arithmetic, to:

        T.


     So next consider:

      (IMPLIES (NUMBERP X)
               (LESSP X
                      (SUB1 (PLUS (FORM-COUNT Z) (ADD1 X))))),

which we named *1.2.1 above.  Let us appeal to the induction principle.  There
are two plausible inductions, both of which are unflawed.  However, one of
these is more likely than the other.  We will induct according to the
following scheme:
      (AND (IMPLIES (AND (F-NOTP Z) (p X (ARG Z)))
                    (p X Z))
           (IMPLIES (AND (NOT (F-NOTP Z))
                         (F-ORP Z)
                         (p X (ARG2 Z))
                         (p X (ARG1 Z)))
                    (p X Z))
           (IMPLIES (AND (NOT (F-NOTP Z)) (NOT (F-ORP Z)))
                    (p X Z))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, and ARG1-LESSP 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 three new formulas:

Case 3. (IMPLIES (AND (F-NOTP Z)
                      (LESSP X
                             (SUB1 (PLUS (FORM-COUNT (ARG Z)) (ADD1 X))))
                      (NUMBERP X))
                 (LESSP X
                        (SUB1 (PLUS (FORM-COUNT Z) (ADD1 X))))),

  which simplifies, applying SUB1-ADD1, and opening up the functions
  FORM-COUNT and PLUS, to the new formula:

        (IMPLIES (AND (F-NOTP Z)
                      (LESSP X
                             (SUB1 (PLUS (FORM-COUNT (ARG Z)) (ADD1 X))))
                      (NUMBERP X))
                 (LESSP X
                        (PLUS (FORM-COUNT (ARG Z))
                              (ADD1 X)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (NOT (F-NOTP Z))
                      (F-ORP Z)
                      (LESSP X
                             (SUB1 (PLUS (FORM-COUNT (ARG2 Z))
                                         (ADD1 X))))
                      (LESSP X
                             (SUB1 (PLUS (FORM-COUNT (ARG1 Z))
                                         (ADD1 X))))
                      (NUMBERP X))
                 (LESSP X
                        (SUB1 (PLUS (FORM-COUNT Z) (ADD1 X))))),

  which simplifies, rewriting with SUB1-ADD1, and unfolding FORM-COUNT and
  PLUS, to:

        (IMPLIES (AND (F-ORP Z)
                      (LESSP X
                             (SUB1 (PLUS (FORM-COUNT (ARG2 Z))
                                         (ADD1 X))))
                      (LESSP X
                             (SUB1 (PLUS (FORM-COUNT (ARG1 Z))
                                         (ADD1 X))))
                      (NUMBERP X))
                 (LESSP X
                        (PLUS (PLUS (FORM-COUNT (ARG1 Z))
                                    (FORM-COUNT (ARG2 Z)))
                              (ADD1 X)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (F-NOTP Z))
                      (NOT (F-ORP Z))
                      (NUMBERP X))
                 (LESSP X
                        (SUB1 (PLUS (FORM-COUNT Z) (ADD1 X))))),

  which simplifies, unfolding the function FORM-COUNT, to:

        (IMPLIES (AND (NOT (F-NOTP Z))
                      (NOT (F-ORP Z))
                      (NUMBERP X))
                 (LESSP X (SUB1 (PLUS 1 (ADD1 X))))).

  This again simplifies, using linear arithmetic, to:

        T.


     That finishes the proof of *1.2.1, which, in turn, finishes the proof of
*1.2.


     So we now return to:

      (NOT (EQUAL (PLUS (FORM-COUNT Z) 0) 0)),

which we named *1.1 above.  Let us appeal to the induction principle.  There
is only one suggested induction.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (F-NOTP Z) (p (ARG Z)))
                    (p Z))
           (IMPLIES (AND (NOT (F-NOTP Z))
                         (F-ORP Z)
                         (p (ARG2 Z))
                         (p (ARG1 Z)))
                    (p Z))
           (IMPLIES (AND (NOT (F-NOTP Z)) (NOT (F-ORP Z)))
                    (p Z))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, and ARG1-LESSP can be
used to show 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 the following three new formulas:

Case 3. (IMPLIES (AND (F-NOTP Z)
                      (NOT (EQUAL (PLUS (FORM-COUNT (ARG Z)) 0)
                                  0)))
                 (NOT (EQUAL (PLUS (FORM-COUNT Z) 0) 0))).

  This simplifies, rewriting with the lemma SUB1-ADD1, and unfolding the
  functions FORM-COUNT and PLUS, to:

        T.

Case 2. (IMPLIES (AND (NOT (F-NOTP Z))
                      (F-ORP Z)
                      (NOT (EQUAL (PLUS (FORM-COUNT (ARG2 Z)) 0)
                                  0))
                      (NOT (EQUAL (PLUS (FORM-COUNT (ARG1 Z)) 0)
                                  0)))
                 (NOT (EQUAL (PLUS (FORM-COUNT Z) 0) 0))).

  This simplifies, applying SUB1-ADD1, and unfolding FORM-COUNT and PLUS, to:

        T.

Case 1. (IMPLIES (AND (NOT (F-NOTP Z)) (NOT (F-ORP Z)))
                 (NOT (EQUAL (PLUS (FORM-COUNT Z) 0) 0))),

  which simplifies, expanding the functions FORM-COUNT, PLUS, and EQUAL, to:

        T.


     That finishes the proof of *1.1, which finishes the proof of *1.  Q.E.D.


[ 0.0 0.1 0.1 ]

LESSP-LIST-COUNT


(PROVE-LEMMA F-ORP-LIST-COUNT
             (REWRITE)
             (IMPLIES (AND (F-ORP (CAR FLIST))
                           (LISTP FLIST))
                      (LESSP (LIST-COUNT (CONS (ARG1 (CAR FLIST))
                                               (CONS (ARG2 (CAR FLIST))
                                                     (CDR FLIST))))
                             (LIST-COUNT FLIST))))

WARNING:  Note that the proposed lemma F-ORP-LIST-COUNT is to be stored as
zero type prescription rules, zero compound recognizer rules, one linear rule,
and zero replacement rules.


This simplifies, rewriting with CDR-CONS, CAR-CONS, and SUB1-ADD1, and
expanding the functions LIST-COUNT, PLUS, FORM-COUNT, and LESSP, to:

      (IMPLIES (AND (F-ORP (CAR FLIST))
                    (LISTP FLIST)
                    (NOT (EQUAL (PLUS (FORM-COUNT (ARG1 (CAR FLIST)))
                                      (FORM-COUNT (ARG2 (CAR FLIST)))
                                      (LIST-COUNT (CDR FLIST)))
                                0)))
               (LESSP (SUB1 (PLUS (FORM-COUNT (ARG1 (CAR FLIST)))
                                  (FORM-COUNT (ARG2 (CAR FLIST)))
                                  (LIST-COUNT (CDR FLIST))))
                      (PLUS (PLUS (FORM-COUNT (ARG1 (CAR FLIST)))
                                  (FORM-COUNT (ARG2 (CAR FLIST))))
                            (LIST-COUNT (CDR FLIST))))).

But this again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

F-ORP-LIST-COUNT


(PROVE-LEMMA NOR-TYPE-LIST-COUNT1
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST)
                           (NOR-TYPE (CAR FLIST)))
                      (LESSP (LIST-COUNT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST)))
                             (LIST-COUNT FLIST))))

WARNING:  Note that the proposed lemma NOR-TYPE-LIST-COUNT1 is to be stored as
zero type prescription rules, zero compound recognizer rules, one linear rule,
and zero replacement rules.


This conjecture can be simplified, using the abbreviations NOR-TYPE, AND, and
IMPLIES, to:

      (IMPLIES (AND (LISTP FLIST)
                    (F-NOTP (CAR FLIST))
                    (F-ORP (ARG (CAR FLIST))))
               (LESSP (LIST-COUNT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                        (CDR FLIST)))
                      (LIST-COUNT FLIST))).

This simplifies, applying the lemmas SUB1-ADD1, CDR-CONS, ARG-F-NOT, and
CAR-CONS, and opening up PLUS, FORM-COUNT, LIST-COUNT, and LESSP, to:

      (IMPLIES (AND (LISTP FLIST)
                    (F-NOTP (CAR FLIST))
                    (F-ORP (ARG (CAR FLIST))))
               (LESSP (PLUS (FORM-COUNT (ARG1 (ARG (CAR FLIST))))
                            (LIST-COUNT (CDR FLIST)))
                      (PLUS (FORM-COUNT (ARG (CAR FLIST)))
                            (LIST-COUNT (CDR FLIST))))).

Applying the lemmas CAR-CDR-ELIM, ARG-ELIM, and ARG1-ARG2-ELIM, replace FLIST
by (CONS X Z) to eliminate (CAR FLIST) and (CDR FLIST), X by (F-NOT V) to
eliminate (ARG X), and V by (F-OR X W) to eliminate (ARG1 V) and (ARG2 V).  We
would thus like to prove the new goal:

      (LESSP (PLUS (FORM-COUNT X) (LIST-COUNT Z))
             (PLUS (FORM-COUNT (F-OR X W))
                   (LIST-COUNT Z))),

which further simplifies, rewriting with the lemmas ARG2-F-OR, ARG1-F-OR, and
SUB1-ADD1, and expanding the functions FORM-COUNT, PLUS, and LESSP, to the
goal:

      (IMPLIES (NOT (EQUAL (PLUS (FORM-COUNT X) (LIST-COUNT Z))
                           0))
               (LESSP (SUB1 (PLUS (FORM-COUNT X) (LIST-COUNT Z)))
                      (PLUS (PLUS (FORM-COUNT X) (FORM-COUNT W))
                            (LIST-COUNT Z)))).

This again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NOR-TYPE-LIST-COUNT1


(PROVE-LEMMA NOR-TYPE-LIST-COUNT2
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST)
                           (NOR-TYPE (CAR FLIST)))
                      (LESSP (LIST-COUNT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST)))
                             (LIST-COUNT FLIST))))

WARNING:  Note that the proposed lemma NOR-TYPE-LIST-COUNT2 is to be stored as
zero type prescription rules, zero compound recognizer rules, one linear rule,
and zero replacement rules.


This conjecture can be simplified, using the abbreviations NOR-TYPE, AND, and
IMPLIES, to:

      (IMPLIES (AND (LISTP FLIST)
                    (F-NOTP (CAR FLIST))
                    (F-ORP (ARG (CAR FLIST))))
               (LESSP (LIST-COUNT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                        (CDR FLIST)))
                      (LIST-COUNT FLIST))).

This simplifies, applying the lemmas SUB1-ADD1, CDR-CONS, ARG-F-NOT, and
CAR-CONS, and opening up PLUS, FORM-COUNT, LIST-COUNT, and LESSP, to:

      (IMPLIES (AND (LISTP FLIST)
                    (F-NOTP (CAR FLIST))
                    (F-ORP (ARG (CAR FLIST))))
               (LESSP (PLUS (FORM-COUNT (ARG2 (ARG (CAR FLIST))))
                            (LIST-COUNT (CDR FLIST)))
                      (PLUS (FORM-COUNT (ARG (CAR FLIST)))
                            (LIST-COUNT (CDR FLIST))))).

Applying the lemmas CAR-CDR-ELIM, ARG-ELIM, and ARG1-ARG2-ELIM, replace FLIST
by (CONS X Z) to eliminate (CAR FLIST) and (CDR FLIST), X by (F-NOT V) to
eliminate (ARG X), and V by (F-OR W X) to eliminate (ARG2 V) and (ARG1 V).  We
would thus like to prove the new goal:

      (LESSP (PLUS (FORM-COUNT X) (LIST-COUNT Z))
             (PLUS (FORM-COUNT (F-OR W X))
                   (LIST-COUNT Z))),

which further simplifies, rewriting with the lemmas ARG2-F-OR, ARG1-F-OR, and
SUB1-ADD1, and expanding the functions FORM-COUNT, PLUS, and LESSP, to the
goal:

      (IMPLIES (NOT (EQUAL (PLUS (FORM-COUNT X) (LIST-COUNT Z))
                           0))
               (LESSP (SUB1 (PLUS (FORM-COUNT X) (LIST-COUNT Z)))
                      (PLUS (PLUS (FORM-COUNT W) (FORM-COUNT X))
                            (LIST-COUNT Z)))).

This again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NOR-TYPE-LIST-COUNT2


(PROVE-LEMMA DBLE-NEG-LIST-COUNT
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST)
                           (DBLE-NEG-TYPE (CAR FLIST)))
                      (LESSP (LIST-COUNT (CONS (ARG (ARG (CAR FLIST)))
                                               (CDR FLIST)))
                             (LIST-COUNT FLIST))))

WARNING:  Note that the proposed lemma DBLE-NEG-LIST-COUNT is to be stored as
zero type prescription rules, zero compound recognizer rules, one linear rule,
and zero replacement rules.


This conjecture can be simplified, using the abbreviations DBLE-NEG-TYPE, AND,
and IMPLIES, to the formula:

      (IMPLIES (AND (LISTP FLIST)
                    (F-NOTP (CAR FLIST))
                    (F-NOTP (ARG (CAR FLIST))))
               (LESSP (LIST-COUNT (CONS (ARG (ARG (CAR FLIST)))
                                        (CDR FLIST)))
                      (LIST-COUNT FLIST))).

This simplifies, rewriting with CDR-CONS, CAR-CONS, and SUB1-ADD1, and
expanding the functions LIST-COUNT, PLUS, FORM-COUNT, and LESSP, to:

      (IMPLIES
              (AND (LISTP FLIST)
                   (F-NOTP (CAR FLIST))
                   (F-NOTP (ARG (CAR FLIST)))
                   (NOT (EQUAL (PLUS (FORM-COUNT (ARG (ARG (CAR FLIST))))
                                     (LIST-COUNT (CDR FLIST)))
                               0))
                   (NOT (EQUAL (SUB1 (PLUS (FORM-COUNT (ARG (ARG (CAR FLIST))))
                                           (LIST-COUNT (CDR FLIST))))
                               0)))
              (LESSP (SUB1 (SUB1 (PLUS (FORM-COUNT (ARG (ARG (CAR FLIST))))
                                       (LIST-COUNT (CDR FLIST)))))
                     (PLUS (FORM-COUNT (ARG (ARG (CAR FLIST))))
                           (LIST-COUNT (CDR FLIST))))).

But this again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DBLE-NEG-LIST-COUNT


(TOGGLE G0240 LIST-COUNT T)

[ 0.0 0.0 0.0 ]

G0240


(DEFN TAUTOLOGYP1
      (FLIST AUXLIST)
      (IF (LISTP FLIST)
          (IF (F-ORP (CAR FLIST))
              (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                 (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                           AUXLIST)
              (IF (NOR-TYPE (CAR FLIST))
                  (AND (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                          (CDR FLIST))
                                    AUXLIST)
                       (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                          (CDR FLIST))
                                    AUXLIST))
                  (IF (DBLE-NEG-TYPE (CAR FLIST))
                      (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                         (CDR FLIST))
                                   AUXLIST)
                      (OR (NEG-LIST (CAR FLIST) AUXLIST)
                          (TAUTOLOGYP1 (CDR FLIST)
                                       (CONS (CAR FLIST) AUXLIST))))))
          F)
      ((LESSP (LIST-COUNT FLIST))))

     Linear arithmetic and the lemmas F-ORP-LIST-COUNT, NOR-TYPE-LIST-COUNT2,
NOR-TYPE-LIST-COUNT1, DBLE-NEG-LIST-COUNT, and LESSP-LIST-COUNT establish that
the measure (LIST-COUNT FLIST) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, TAUTOLOGYP1 is accepted under
the principle of definition.  From the definition we can conclude that:
      (OR (FALSEP (TAUTOLOGYP1 FLIST AUXLIST))
          (TRUEP (TAUTOLOGYP1 FLIST AUXLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

TAUTOLOGYP1


(PROVE-LEMMA FORM-LIST-APPEND
             (REWRITE)
             (IMPLIES (AND (FORM-LIST X SYMBOLS)
                           (FORM-LIST Y SYMBOLS))
                      (FORM-LIST (APPEND X Y) SYMBOLS))
             ((INDUCT (APPEND X Y))
              (DISABLE FORMULA)))

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

Case 2. (IMPLIES (AND (LISTP X)
                      (IMPLIES (AND (FORM-LIST (CDR X) SYMBOLS)
                                    (FORM-LIST Y SYMBOLS))
                               (FORM-LIST (APPEND (CDR X) Y)
                                          SYMBOLS))
                      (FORM-LIST X SYMBOLS)
                      (FORM-LIST Y SYMBOLS))
                 (FORM-LIST (APPEND X Y) SYMBOLS)),

  which simplifies, applying the lemmas CDR-CONS and CAR-CONS, and unfolding
  AND, IMPLIES, FORM-LIST, and APPEND, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (FORM-LIST X SYMBOLS)
                      (FORM-LIST Y SYMBOLS))
                 (FORM-LIST (APPEND X Y) SYMBOLS)),

  which simplifies, opening up the functions FORM-LIST and APPEND, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORM-LIST-APPEND


(DEFN NEG-PROOF
      (EXP1 EXP2)
      (IF (EQUAL EXP1 (F-NOT EXP2))
          (PROP-AXIOM-PROOF EXP2)
          (COMMUT-PROOF EXP2 EXP1
                        (PROP-AXIOM-PROOF EXP1))))

     From the definition we can conclude that (LISTP (NEG-PROOF EXP1 EXP2)) is
a theorem.




[ 0.0 0.0 0.0 ]

NEG-PROOF


(PROVE-LEMMA NEG-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                           (FORMULA EXP2 SYMBOLS)
                           (NEG EXP1 EXP2)
                           (EQUAL CONCL (F-OR EXP1 EXP2)))
                      (PROVES (NEG-PROOF EXP1 EXP2)
                              CONCL GIVEN DEFNS SYMBOLS)))

This conjecture simplifies, opening up NEG and NEG-PROOF, to three new goals:

Case 3. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (EQUAL EXP1 (F-NOT EXP2)))
                 (PROVES (PROP-AXIOM-PROOF EXP2)
                         (F-OR EXP1 EXP2)
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, appealing to the lemmas FORMULA-F-NOT and
  PROP-AXIOM-PROVES, to:

        T.

Case 2. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (EQUAL EXP2 (F-NOT EXP1))
                      (NOT (EQUAL EXP1 (F-NOT EXP2))))
                 (PROVES (COMMUT-PROOF EXP2 EXP1
                                       (PROP-AXIOM-PROOF EXP1))
                         (F-OR EXP1 EXP2)
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying the lemmas FORMULA-F-NOT, PROP-AXIOM-PROVES,
  and COMMUT-PROOF-PROVES, to:

        T.

Case 1. (IMPLIES (AND (FORMULA EXP1 SYMBOLS)
                      (FORMULA EXP2 SYMBOLS)
                      (EQUAL EXP2 (F-NOT EXP1))
                      (EQUAL EXP1 (F-NOT EXP2)))
                 (PROVES (PROP-AXIOM-PROOF EXP2)
                         (F-OR EXP1 EXP2)
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, rewriting with FORMULA-F-NOT, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NEG-PROOF-PROVES


(DEFN NEG-LIST-PROOF
      (EXP FLIST)
      (IF (MEMBER (F-NOT EXP) FLIST)
          (M2-PROOF EXP
                    (F-NOT EXP)
                    (CONS EXP FLIST)
                    (NEG-PROOF EXP (F-NOT EXP)))
          (M2-PROOF EXP
                    (ARG EXP)
                    (CONS EXP FLIST)
                    (NEG-PROOF EXP (ARG EXP)))))

     From the definition we can conclude that:
      (OR (LITATOM (NEG-LIST-PROOF EXP FLIST))
          (LISTP (NEG-LIST-PROOF EXP FLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

NEG-LIST-PROOF


(PROVE-LEMMA NEG-LIST-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA EXP SYMBOLS)
                           (FORM-LIST FLIST SYMBOLS)
                           (NEG-LIST EXP FLIST)
                           (EQUAL CONCL
                                  (MAKE-DISJUNCT (CONS EXP FLIST))))
                      (PROVES (NEG-LIST-PROOF EXP FLIST)
                              CONCL GIVEN DEFNS SYMBOLS)))

This conjecture simplifies, appealing to the lemmas CAR-CONS, CDR-CONS, and
F-NOT-ARG, and expanding NEG-LIST, NEG-PROOF, NEG-LIST-PROOF, and
MAKE-DISJUNCT, to six new formulas:

Case 6. (IMPLIES (AND (FORMULA EXP SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (NOT (F-NOTP EXP))
                      (MEMBER (F-NOT EXP) FLIST)
                      (NOT (LISTP FLIST)))
                 (PROVES (M2-PROOF EXP
                                   (F-NOT EXP)
                                   (CONS EXP FLIST)
                                   (COMMUT-PROOF (F-NOT EXP)
                                                 EXP
                                                 (PROP-AXIOM-PROOF EXP)))
                         EXP GIVEN DEFNS SYMBOLS)),

  which again simplifies, unfolding the functions FORM-LIST and MEMBER, to:

        T.

Case 5. (IMPLIES (AND (FORMULA EXP SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (NOT (F-NOTP EXP))
                      (MEMBER (F-NOT EXP) FLIST)
                      (LISTP FLIST))
                 (PROVES (M2-PROOF EXP
                                   (F-NOT EXP)
                                   (CONS EXP FLIST)
                                   (COMMUT-PROOF (F-NOT EXP)
                                                 EXP
                                                 (PROP-AXIOM-PROOF EXP)))
                         (F-OR EXP (MAKE-DISJUNCT FLIST))
                         GIVEN DEFNS SYMBOLS)),

  which again simplifies, applying COMMUT-PROOF-PROVES, PROP-AXIOM-PROVES,
  FORMULA-F-OR, FORMLIST-FORMULA-MAKE-DISJ, CDR-CONS, CAR-CONS, and
  M2-PROOF-PROVES1, and unfolding the functions MEMBER and MAKE-DISJUNCT, to:

        T.

Case 4. (IMPLIES (AND (FORMULA EXP SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (F-NOTP EXP)
                      (MEMBER (ARG EXP) FLIST)
                      (NOT (LISTP FLIST))
                      (NOT (MEMBER (F-NOT EXP) FLIST)))
                 (PROVES (M2-PROOF EXP
                                   (ARG EXP)
                                   (CONS EXP FLIST)
                                   (PROP-AXIOM-PROOF (ARG EXP)))
                         EXP GIVEN DEFNS SYMBOLS)).

  But this again simplifies, expanding FORM-LIST and MEMBER, to:

        T.

Case 3. (IMPLIES (AND (FORMULA EXP SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (F-NOTP EXP)
                      (MEMBER (ARG EXP) FLIST)
                      (NOT (LISTP FLIST))
                      (MEMBER (F-NOT EXP) FLIST))
                 (PROVES (M2-PROOF EXP
                                   (F-NOT EXP)
                                   (CONS EXP FLIST)
                                   (COMMUT-PROOF (F-NOT EXP)
                                                 EXP
                                                 (PROP-AXIOM-PROOF EXP)))
                         EXP GIVEN DEFNS SYMBOLS)),

  which again simplifies, expanding FORM-LIST and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (FORMULA EXP SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (F-NOTP EXP)
                      (MEMBER (ARG EXP) FLIST)
                      (LISTP FLIST)
                      (NOT (MEMBER (F-NOT EXP) FLIST)))
                 (PROVES (M2-PROOF EXP
                                   (ARG EXP)
                                   (CONS EXP FLIST)
                                   (PROP-AXIOM-PROOF (ARG EXP)))
                         (F-OR EXP (MAKE-DISJUNCT FLIST))
                         GIVEN DEFNS SYMBOLS)).

  Applying the lemma ARG-ELIM, replace EXP by (F-NOT X) to eliminate (ARG EXP).
  This produces:

        (IMPLIES (AND (FORMULA (F-NOT X) SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (MEMBER X FLIST)
                      (LISTP FLIST)
                      (NOT (MEMBER (F-NOT (F-NOT X)) FLIST)))
                 (PROVES (M2-PROOF (F-NOT X)
                                   X
                                   (CONS (F-NOT X) FLIST)
                                   (PROP-AXIOM-PROOF X))
                         (F-OR (F-NOT X) (MAKE-DISJUNCT FLIST))
                         GIVEN DEFNS SYMBOLS)),

  which further simplifies, applying FORMULA-F-NOT, PROP-AXIOM-PROVES,
  FORMULA-F-OR, FORMLIST-FORMULA-MAKE-DISJ, CDR-CONS, CAR-CONS, and
  M2-PROOF-PROVES1, and opening up the definitions of MEMBER and MAKE-DISJUNCT,
  to:

        T.

Case 1. (IMPLIES (AND (FORMULA EXP SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (F-NOTP EXP)
                      (MEMBER (ARG EXP) FLIST)
                      (LISTP FLIST)
                      (MEMBER (F-NOT EXP) FLIST))
                 (PROVES (M2-PROOF EXP
                                   (F-NOT EXP)
                                   (CONS EXP FLIST)
                                   (COMMUT-PROOF (F-NOT EXP)
                                                 EXP
                                                 (PROP-AXIOM-PROOF EXP)))
                         (F-OR EXP (MAKE-DISJUNCT FLIST))
                         GIVEN DEFNS SYMBOLS)).

  However this again simplifies, applying the lemmas COMMUT-PROOF-PROVES,
  PROP-AXIOM-PROVES, FORMULA-F-OR, FORMLIST-FORMULA-MAKE-DISJ, CDR-CONS,
  CAR-CONS, and M2-PROOF-PROVES1, and unfolding MEMBER and MAKE-DISJUNCT, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NEG-LIST-PROOF-PROVES


(PROVE-LEMMA SUBSET-IDENT
             (REWRITE)
             (SUBSET X X))


     Give the conjecture the name *1.


     Perhaps we can prove it by induction.  There is only one plausible
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X) (p (CDR X)))
                    (p X))
           (IMPLIES (NOT (LISTP X)) (p X))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates the following two new
formulas:

Case 2. (IMPLIES (AND (LISTP X)
                      (SUBSET (CDR X) (CDR X)))
                 (SUBSET X X)).

  This simplifies, expanding the functions SUBSET and MEMBER, to the new goal:

        (IMPLIES (AND (LISTP X)
                      (SUBSET (CDR X) (CDR X)))
                 (SUBSET (CDR X) X)).

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

        (IMPLIES (SUBSET Z Z)
                 (SUBSET Z (CONS V Z))),

  which further simplifies, rewriting with SUBSET-CONS, to:

        T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (SUBSET X X)).

  This simplifies, unfolding the function SUBSET, to:

        T.


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


[ 0.0 0.0 0.0 ]

SUBSET-IDENT


(PROVE-LEMMA SUBSET-CAR
             (REWRITE)
             (SUBSET X (CONS Y X)))

This formula simplifies, applying SUBSET-IDENT and SUBSET-CONS, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

SUBSET-CAR


(PROVE-LEMMA SUBSET-APPEND
             (REWRITE)
             (SUBSET (CONS EXP LIST2)
                     (APPEND (CONS EXP LIST1) LIST2)))

This formula simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
expanding the definitions of APPEND, MEMBER, and SUBSET, to the formula:

      (SUBSET LIST2
              (CONS EXP (APPEND LIST1 LIST2))).

Name the above subgoal *1.


     Perhaps we can prove it by induction.  The recursive terms in the
conjecture suggest two inductions.  However, only one is unflawed.  We will
induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP LIST1)
                         (p LIST2 EXP (CDR LIST1)))
                    (p LIST2 EXP LIST1))
           (IMPLIES (NOT (LISTP LIST1))
                    (p LIST2 EXP LIST1))).
Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT LIST1) decreases according to the well-founded relation LESSP
in each induction step of the scheme.  The above induction scheme produces two
new formulas:

Case 2. (IMPLIES (AND (LISTP LIST1)
                      (SUBSET LIST2
                              (CONS EXP
                                    (APPEND (CDR LIST1) LIST2))))
                 (SUBSET LIST2
                         (CONS EXP (APPEND LIST1 LIST2)))),

  which simplifies, opening up APPEND, to the goal:

        (IMPLIES (AND (LISTP LIST1)
                      (SUBSET LIST2
                              (CONS EXP
                                    (APPEND (CDR LIST1) LIST2))))
                 (SUBSET LIST2
                         (CONS EXP
                               (CONS (CAR LIST1)
                                     (APPEND (CDR LIST1) LIST2))))).

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

        (IMPLIES (SUBSET LIST2
                         (CONS EXP (APPEND X LIST2)))
                 (SUBSET LIST2
                         (CONS EXP
                               (CONS Z (APPEND X LIST2))))).

  We will try to prove the above formula by generalizing it, replacing
  (APPEND X LIST2) by Y.  The result is:

        (IMPLIES (SUBSET LIST2 (CONS EXP Y))
                 (SUBSET LIST2 (CONS EXP (CONS Z Y)))).

  Give the above formula the name *1.1.

Case 1. (IMPLIES (NOT (LISTP LIST1))
                 (SUBSET LIST2
                         (CONS EXP (APPEND LIST1 LIST2)))).

  This simplifies, appealing to the lemma SUBSET-CAR, and opening up the
  definition of APPEND, to:

        T.


     So let us turn our attention to:

      (IMPLIES (SUBSET LIST2 (CONS EXP Y))
               (SUBSET LIST2 (CONS EXP (CONS Z Y)))),

which we named *1.1 above.  Perhaps we can prove it by induction.  The
recursive terms in the conjecture suggest two inductions.  However, they merge
into one likely candidate induction.  We will induct according to the
following scheme:
      (AND (IMPLIES (AND (LISTP LIST2)
                         (p (CDR LIST2) EXP Z Y))
                    (p LIST2 EXP Z Y))
           (IMPLIES (NOT (LISTP LIST2))
                    (p LIST2 EXP Z Y))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure
(COUNT LIST2) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates the
following three new conjectures:

Case 3. (IMPLIES (AND (LISTP LIST2)
                      (NOT (SUBSET (CDR LIST2) (CONS EXP Y)))
                      (SUBSET LIST2 (CONS EXP Y)))
                 (SUBSET LIST2 (CONS EXP (CONS Z Y)))).

  This simplifies, rewriting with CDR-CONS and CAR-CONS, and expanding SUBSET
  and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (LISTP LIST2)
                      (SUBSET (CDR LIST2)
                              (CONS EXP (CONS Z Y)))
                      (SUBSET LIST2 (CONS EXP Y)))
                 (SUBSET LIST2 (CONS EXP (CONS Z Y)))),

  which simplifies, applying CDR-CONS and CAR-CONS, and expanding SUBSET and
  MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP LIST2))
                      (SUBSET LIST2 (CONS EXP Y)))
                 (SUBSET LIST2 (CONS EXP (CONS Z Y)))).

  This simplifies, rewriting with SUBSET-CONS, and opening up SUBSET, to:

        T.


     That finishes the proof of *1.1, which, consequently, finishes the proof
of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBSET-APPEND


(PROVE-LEMMA M-PROOF-PROVES1
             (REWRITE)
             (IMPLIES (AND (FORM-LIST FLIST2 SYMBOLS)
                           (SUBSET FLIST1 FLIST2)
                           (PROVES PF
                                   (MAKE-DISJUNCT FLIST1)
                                   GIVEN DEFNS SYMBOLS)
                           (EQUAL CONCL (MAKE-DISJUNCT FLIST2)))
                      (PROVES (M-PROOF FLIST1 FLIST2 PF)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((USE (M-PROOF-PROVES))))

This formula simplifies, rewriting with NOT-PREDICATE, NOT-FUNCTION, and
PROVES-IS-FORMULA-AGAIN, and expanding AND, IMPLIES, SUBSET, MAKE-DISJUNCT,
FORMULA, F-NOTP, F-ORP, FORSOMEP, NLISTP, OR, CAR, ATOMP, FORM-LIST, and
MEMBER, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

M-PROOF-PROVES1


(TOGGLE G0505 M-PROOF-PROVES T)

[ 0.0 0.0 0.0 ]

G0505


(TOGGLE G0256 NEG-LIST-PROOF T)

[ 0.0 0.0 0.0 ]

G0256


(DEFN PROP-ATOM-PROOF1
      (FLIST1 FLIST2)
      (M-PROOF (CONS (CAR FLIST1) FLIST2)
               (APPEND FLIST1 FLIST2)
               (NEG-LIST-PROOF (CAR FLIST1) FLIST2)))

     From the definition we can conclude that:
      (OR (LITATOM (PROP-ATOM-PROOF1 FLIST1 FLIST2))
          (LISTP (PROP-ATOM-PROOF1 FLIST1 FLIST2)))
is a theorem.




[ 0.0 0.0 0.0 ]

PROP-ATOM-PROOF1


(PROVE-LEMMA PROP-ATOM-PROOF1-PROVES
             (REWRITE)
             (IMPLIES (AND (FORM-LIST FLIST1 SYMBOLS)
                           (LISTP FLIST1)
                           (FORM-LIST FLIST2 SYMBOLS)
                           (NEG-LIST (CAR FLIST1) FLIST2)
                           (EQUAL CONCL
                                  (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))))
                      (PROVES (PROP-ATOM-PROOF1 FLIST1 FLIST2)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((USE (SUBSET-APPEND (EXP (CAR FLIST1))
                                  (LIST1 (CDR FLIST1))
                                  (LIST2 FLIST2)))))

This conjecture simplifies, applying the lemmas CONS-CAR-CDR, CDR-CONS,
CAR-CONS, NEG-LIST-PROOF-PROVES, FORM-LIST-APPEND, and M-PROOF-PROVES1, and
expanding the definitions of APPEND, MEMBER, SUBSET, FORM-LIST, NEG-LIST,
PROP-ATOM-PROOF1, and MAKE-DISJUNCT, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PROP-ATOM-PROOF1-PROVES


(TOGGLE G0259 PROP-ATOM-PROOF1 T)

[ 0.0 0.0 0.0 ]

G0259


(PROVE-LEMMA SUBSET-APPEND-CAR
             (REWRITE)
             (SUBSET (APPEND LIST1 (CONS EXP LIST2))
                     (APPEND (CONS EXP LIST1) LIST2)))

This simplifies, rewriting with CDR-CONS and CAR-CONS, and expanding APPEND,
to the conjecture:

      (SUBSET (APPEND LIST1 (CONS EXP LIST2))
              (CONS EXP (APPEND LIST1 LIST2))).

Give the above formula the name *1.


     Perhaps we can prove it by induction.  There are two plausible inductions.
However, they merge into one likely candidate induction.  We will induct
according to the following scheme:
      (AND (IMPLIES (AND (LISTP LIST1)
                         (p (CDR LIST1) EXP LIST2))
                    (p LIST1 EXP LIST2))
           (IMPLIES (NOT (LISTP LIST1))
                    (p LIST1 EXP LIST2))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure
(COUNT LIST1) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme produces the
following two new conjectures:

Case 2. (IMPLIES (AND (LISTP LIST1)
                      (SUBSET (APPEND (CDR LIST1) (CONS EXP LIST2))
                              (CONS EXP
                                    (APPEND (CDR LIST1) LIST2))))
                 (SUBSET (APPEND LIST1 (CONS EXP LIST2))
                         (CONS EXP (APPEND LIST1 LIST2)))).

  This simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  expanding the functions APPEND, MEMBER, and SUBSET, to the new goal:

        (IMPLIES (AND (LISTP LIST1)
                      (SUBSET (APPEND (CDR LIST1) (CONS EXP LIST2))
                              (CONS EXP
                                    (APPEND (CDR LIST1) LIST2))))
                 (SUBSET (APPEND (CDR LIST1) (CONS EXP LIST2))
                         (CONS EXP
                               (CONS (CAR LIST1)
                                     (APPEND (CDR LIST1) LIST2))))).

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

        (IMPLIES (SUBSET (APPEND X (CONS EXP LIST2))
                         (CONS EXP (APPEND X LIST2)))
                 (SUBSET (APPEND X (CONS EXP LIST2))
                         (CONS EXP
                               (CONS Z (APPEND X LIST2))))),

  which we generalize by replacing (APPEND X LIST2) by Y and:
        (APPEND X (CONS EXP LIST2))
  by A.  We restrict the new variables by recalling the type restriction lemma
  noted when APPEND was introduced.  We thus obtain:

        (IMPLIES (AND (LISTP A)
                      (SUBSET A (CONS EXP Y)))
                 (SUBSET A (CONS EXP (CONS Z Y)))),

  which we will name *1.1.

Case 1. (IMPLIES (NOT (LISTP LIST1))
                 (SUBSET (APPEND LIST1 (CONS EXP LIST2))
                         (CONS EXP (APPEND LIST1 LIST2)))).

  This simplifies, applying SUBSET-IDENT, and opening up APPEND, to:

        T.


     So let us turn our attention to:

      (IMPLIES (AND (LISTP A)
                    (SUBSET A (CONS EXP Y)))
               (SUBSET A (CONS EXP (CONS Z Y)))),

which we named *1.1 above.  Let us appeal to the induction principle.  The
recursive terms in the conjecture suggest two inductions.  However, they merge
into one likely candidate induction.  We will induct according to the
following scheme:
      (AND (IMPLIES (AND (LISTP A) (p (CDR A) EXP Z Y))
                    (p A EXP Z Y))
           (IMPLIES (NOT (LISTP A))
                    (p A EXP Z Y))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT A)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates three new conjectures:

Case 3. (IMPLIES (AND (NOT (LISTP (CDR A)))
                      (LISTP A)
                      (SUBSET A (CONS EXP Y)))
                 (SUBSET A (CONS EXP (CONS Z Y)))),

  which simplifies, applying CDR-CONS, CAR-CONS, and SUBSET-CONS, and
  unfolding SUBSET and MEMBER, to:

        (IMPLIES (AND (NOT (LISTP (CDR A)))
                      (LISTP A)
                      (EQUAL (CAR A) EXP)
                      (SUBSET (CDR A) (CONS EXP Y)))
                 (SUBSET (CDR A)
                         (CONS EXP (CONS Z Y)))),

  which again simplifies, appealing to the lemma SUBSET-CONS, and opening up
  the definition of SUBSET, to:

        T.

Case 2. (IMPLIES (AND (NOT (SUBSET (CDR A) (CONS EXP Y)))
                      (LISTP A)
                      (SUBSET A (CONS EXP Y)))
                 (SUBSET A (CONS EXP (CONS Z Y)))),

  which simplifies, applying CDR-CONS and CAR-CONS, and unfolding SUBSET and
  MEMBER, to:

        T.

Case 1. (IMPLIES (AND (SUBSET (CDR A) (CONS EXP (CONS Z Y)))
                      (LISTP A)
                      (SUBSET A (CONS EXP Y)))
                 (SUBSET A (CONS EXP (CONS Z Y)))).

  This simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  expanding the definitions of SUBSET and MEMBER, to:

        T.


     That finishes the proof of *1.1, which, consequently, also finishes the
proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

SUBSET-APPEND-CAR


(PROVE-LEMMA FORM-LIST-APPEND-CAR
             (REWRITE)
             (IMPLIES (AND (FORM-LIST (CONS EXP LIST1) SYMBOLS)
                           (OR (EQUAL LIST2 NIL)
                               (FORM-LIST LIST2 SYMBOLS)))
                      (FORM-LIST (APPEND LIST1 (CONS EXP LIST2))
                                 SYMBOLS)))

This simplifies, applying CDR-CONS, CAR-CONS, and FORM-LIST-APPEND, and
expanding the definitions of FORM-LIST, OR, and LISTP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORM-LIST-APPEND-CAR


(DEFN PROP-ATOM-PROOF2
      (FLIST1 FLIST2 PF)
      (M-PROOF (APPEND (CDR FLIST1)
                       (CONS (CAR FLIST1) FLIST2))
               (APPEND FLIST1 FLIST2)
               PF))

     Note that:
      (OR (OR (LITATOM (PROP-ATOM-PROOF2 FLIST1 FLIST2 PF))
              (LISTP (PROP-ATOM-PROOF2 FLIST1 FLIST2 PF)))
          (EQUAL (PROP-ATOM-PROOF2 FLIST1 FLIST2 PF)
                 PF))
is a theorem.




[ 0.0 0.0 0.0 ]

PROP-ATOM-PROOF2


(PROVE-LEMMA PROP-ATOM-PROOF2-PROVES
      (REWRITE)
      (IMPLIES (AND (FORM-LIST FLIST1 SYMBOLS)
                    (LISTP FLIST1)
                    (FORM-LIST FLIST2 SYMBOLS)
                    (PROVES PF
                            (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                   (CONS (CAR FLIST1) FLIST2)))
                            GIVEN DEFNS SYMBOLS)
                    (EQUAL CONCL
                           (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))))
               (PROVES (PROP-ATOM-PROOF2 FLIST1 FLIST2 PF)
                       CONCL GIVEN DEFNS SYMBOLS))
      ((USE (SUBSET-APPEND-CAR (LIST1 (CDR FLIST1))
                               (EXP (CAR FLIST1))
                               (LIST2 FLIST2)))))

This simplifies, appealing to the lemmas CONS-CAR-CDR, CAR-CONS, CDR-CONS,
FORM-LIST-APPEND, and M-PROOF-PROVES1, and unfolding the definitions of APPEND,
FORM-LIST, PROP-ATOM-PROOF2, and MAKE-DISJUNCT, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PROP-ATOM-PROOF2-PROVES


(TOGGLE G0258 PROP-ATOM-PROOF2 T)

[ 0.0 0.0 0.0 ]

G0258


(DEFN CANCEL-PROOF
      (A B PF1 PF2)
      (CONTRAC-PROOF B
                     (CUT-PROOF A B B PF2
                                (RT-EXPAN-PROOF (F-NOT A) B PF1))))

     From the definition we can conclude that:
      (LISTP (CANCEL-PROOF A B PF1 PF2))
is a theorem.




[ 0.0 0.0 0.0 ]

CANCEL-PROOF


(PROVE-LEMMA CANCEL-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF1
                                   (F-NOT A)
                                   GIVEN DEFNS SYMBOLS)
                           (PROVES PF2
                                   (F-OR A B)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (CANCEL-PROOF A B PF1 PF2)
                              B GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (EXP (F-OR A B))
                                      (PF PF2)))))

This conjecture simplifies, applying FORMULA-F-OR, CUT-PROOF-PROVES,
RT-EXPAN-PROOF-PROVES, and CONTRAC-PROOF-PROVES, and opening up the
definitions of IMPLIES and CANCEL-PROOF, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

CANCEL-PROOF-PROVES


(TOGGLE G0255 CANCEL-PROOF T)

[ 0.0 0.0 0.0 ]

G0255


(DEFN NLISTP-NOR-TYPE-PROOF
      (A B PF1 PF2)
      (CANCEL-PROOF B
                    (F-NOT (F-OR A B))
                    PF2
                    (CANCEL-PROOF A
                                  (F-OR B (F-NOT (F-OR A B)))
                                  PF1
                                  (M-PROOF (LIST (F-NOT (F-OR A B)) A B)
                                           (LIST A B (F-NOT (F-OR A B)))
                                           (PROP-AXIOM-PROOF (F-OR A B))))))

     Note that (LISTP (NLISTP-NOR-TYPE-PROOF A B PF1 PF2)) is a theorem.




[ 0.0 0.0 0.0 ]

NLISTP-NOR-TYPE-PROOF


(DEFN LISTP-NOR-TYPE-PROOF
 (A B C PF1 PF2)
 (M-PROOF
  (LIST (F-NOT (F-OR A B)) C C)
  (LIST (F-NOT (F-OR A B)) C)
  (RT-ASSOC-PROOF
   (F-NOT (F-OR A B))
   C C
   (CUT-PROOF B
             (F-OR (F-NOT (F-OR A B)) C)
             C
             (RT-ASSOC-PROOF B
                             (F-NOT (F-OR A B))
                             C
                             (CUT-PROOF A
                                        (F-OR B (F-NOT (F-OR A B)))
                                        C
                                        (M-PROOF (LIST (F-NOT (F-OR A B)) A B)
                                                 (LIST A B (F-NOT (F-OR A B)))
                                                 (PROP-AXIOM-PROOF (F-OR A B)))
                                        PF1))
             PF2))))

     From the definition we can conclude that:
      (OR (LITATOM (LISTP-NOR-TYPE-PROOF A B C PF1 PF2))
          (LISTP (LISTP-NOR-TYPE-PROOF A B C PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

LISTP-NOR-TYPE-PROOF


(DEFN NOR-PROOF
      (A B CLIST PF1 PF2)
      (IF (NLISTP CLIST)
          (NLISTP-NOR-TYPE-PROOF A B PF1 PF2)
          (LISTP-NOR-TYPE-PROOF A B
                                (MAKE-DISJUNCT CLIST)
                                PF1 PF2)))

     From the definition we can conclude that:
      (OR (LITATOM (NOR-PROOF A B CLIST PF1 PF2))
          (LISTP (NOR-PROOF A B CLIST PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

NOR-PROOF


(DEFN NLISTP-DBLE-NEG-PROOF
      (A PF)
      (CONTRAC-PROOF (F-NOT (F-NOT A))
                     (CUT-PROOF A
                                (F-NOT (F-NOT A))
                                (F-NOT (F-NOT A))
                                (RT-EXPAN-PROOF A
                                                (F-NOT (F-NOT A))
                                                PF)
                                (COMMUT-PROOF (F-NOT (F-NOT A))
                                              (F-NOT A)
                                              (PROP-AXIOM-PROOF (F-NOT A))))))

     Observe that (LISTP (NLISTP-DBLE-NEG-PROOF A PF)) is a theorem.




[ 0.0 0.0 0.0 ]

NLISTP-DBLE-NEG-PROOF


(DEFN LISTP-DBLE-NEG-PROOF
      (A C PF)
      (COMMUT-PROOF C
                    (F-NOT (F-NOT A))
                    (CUT-PROOF A C
                               (F-NOT (F-NOT A))
                               PF
                               (COMMUT-PROOF (F-NOT (F-NOT A))
                                             (F-NOT A)
                                             (PROP-AXIOM-PROOF (F-NOT A))))))

     From the definition we can conclude that:
      (LISTP (LISTP-DBLE-NEG-PROOF A C PF))
is a theorem.




[ 0.0 0.0 0.0 ]

LISTP-DBLE-NEG-PROOF


(DEFN DBLE-NEG-PROOF
      (A CLIST PF)
      (IF (NLISTP CLIST)
          (NLISTP-DBLE-NEG-PROOF A PF)
          (LISTP-DBLE-NEG-PROOF A
                                (MAKE-DISJUNCT CLIST)
                                PF)))

     Note that (LISTP (DBLE-NEG-PROOF A CLIST PF)) is a theorem.




[ 0.0 0.0 0.0 ]

DBLE-NEG-PROOF


(DEFN F-ORP-PROOF
      (A B CLIST PF)
      (IF (NLISTP CLIST)
          PF
          (ASSOC-PROOF A B
                       (MAKE-DISJUNCT CLIST)
                       PF)))

     Observe that:
      (OR (LISTP (F-ORP-PROOF A B CLIST PF))
          (EQUAL (F-ORP-PROOF A B CLIST PF) PF))
is a theorem.




[ 0.0 0.0 0.0 ]

F-ORP-PROOF


(DEFN TAUT-PROOF1
 (FLIST AUXLIST)
 (IF
  (LISTP FLIST)
  (IF
    (F-ORP (CAR FLIST))
    (F-ORP-PROOF (ARG1 (CAR FLIST))
                 (ARG2 (CAR FLIST))
                 (APPEND (CDR FLIST) AUXLIST)
                 (TAUT-PROOF1 (CONS (ARG1 (CAR FLIST))
                                    (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                              AUXLIST))
    (IF (NOR-TYPE (CAR FLIST))
        (NOR-PROOF (ARG1 (ARG (CAR FLIST)))
                   (ARG2 (ARG (CAR FLIST)))
                   (APPEND (CDR FLIST) AUXLIST)
                   (TAUT-PROOF1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                      (CDR FLIST))
                                AUXLIST)
                   (TAUT-PROOF1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                      (CDR FLIST))
                                AUXLIST))
        (IF (DBLE-NEG-TYPE (CAR FLIST))
            (DBLE-NEG-PROOF (ARG (ARG (CAR FLIST)))
                            (APPEND (CDR FLIST) AUXLIST)
                            (TAUT-PROOF1 (CONS (ARG (ARG (CAR FLIST)))
                                               (CDR FLIST))
                                         AUXLIST))
            (IF (NEG-LIST (CAR FLIST) AUXLIST)
                (PROP-ATOM-PROOF1 FLIST AUXLIST)
                (PROP-ATOM-PROOF2 FLIST AUXLIST
                                  (TAUT-PROOF1 (CDR FLIST)
                                               (CONS (CAR FLIST) AUXLIST)))))))
  NIL)
 ((LESSP (LIST-COUNT FLIST))))

     Linear arithmetic and the lemmas F-ORP-LIST-COUNT, NOR-TYPE-LIST-COUNT2,
NOR-TYPE-LIST-COUNT1, DBLE-NEG-LIST-COUNT, and LESSP-LIST-COUNT can be used to
prove that the measure (LIST-COUNT FLIST) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, TAUT-PROOF1 is
accepted under the principle of definition.  From the definition we can
conclude that:
      (OR (LITATOM (TAUT-PROOF1 FLIST AUXLIST))
          (LISTP (TAUT-PROOF1 FLIST AUXLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

TAUT-PROOF1


(PROVE-LEMMA TAUT-THM1
             (REWRITE)
             (IMPLIES (AND (FORM-LIST FLIST SYMBOLS)
                           (FORM-LIST AUXLIST SYMBOLS)
                           (TAUTOLOGYP1 FLIST AUXLIST))
                      (PROVES (TAUT-PROOF1 FLIST AUXLIST)
                              (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                              GIVEN DEFNS SYMBOLS))
             ((INDUCT (TAUTOLOGYP1 FLIST AUXLIST))))

This formula can be simplified, using the abbreviations DBLE-NEG-TYPE,
NOR-TYPE, IMPLIES, NOT, OR, and AND, to the following five new formulas:

Case 5. (IMPLIES
         (AND
          (LISTP FLIST)
          (F-ORP (CAR FLIST))
          (IMPLIES
           (AND (FORM-LIST (CONS (ARG1 (CAR FLIST))
                                 (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                           SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                   (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                             AUXLIST))
           (PROVES
            (TAUT-PROOF1 (CONS (ARG1 (CAR FLIST))
                               (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                         AUXLIST)
            (MAKE-DISJUNCT (APPEND (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST))
            GIVEN DEFNS SYMBOLS))
          (FORM-LIST FLIST SYMBOLS)
          (FORM-LIST AUXLIST SYMBOLS)
          (TAUTOLOGYP1 FLIST AUXLIST))
         (PROVES (TAUT-PROOF1 FLIST AUXLIST)
                 (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                 GIVEN DEFNS SYMBOLS)).

  This simplifies, rewriting with CDR-CONS and CAR-CONS, and unfolding the
  definitions of FORM-LIST, AND, APPEND, MAKE-DISJUNCT, IMPLIES, FORMULA,
  TAUTOLOGYP1, F-ORP-PROOF, and TAUT-PROOF1, to two new formulas:

  Case 5.2.
          (IMPLIES
           (AND
              (LISTP FLIST)
              (F-ORP (CAR FLIST))
              (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
              (PROVES (TAUT-PROOF1 (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)
                      (F-OR (ARG1 (CAR FLIST))
                            (ARG2 (CAR FLIST)))
                      GIVEN DEFNS SYMBOLS)
              (FORMULA (ARG1 (CAR FLIST)) SYMBOLS)
              (FORMULA (ARG2 (CAR FLIST)) SYMBOLS)
              (FORM-LIST (CDR FLIST) SYMBOLS)
              (FORM-LIST AUXLIST SYMBOLS)
              (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                 (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                           AUXLIST))
           (PROVES (TAUT-PROOF1 (CONS (ARG1 (CAR FLIST))
                                      (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                AUXLIST)
                   (CAR FLIST)
                   GIVEN DEFNS SYMBOLS)),

    which again simplifies, appealing to the lemma F-OR-ARG1-ARG2, to:

          T.

  Case 5.1.
          (IMPLIES
           (AND
             (LISTP FLIST)
             (F-ORP (CAR FLIST))
             (LISTP (APPEND (CDR FLIST) AUXLIST))
             (PROVES (TAUT-PROOF1 (CONS (ARG1 (CAR FLIST))
                                        (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                  AUXLIST)
                     (F-OR (ARG1 (CAR FLIST))
                           (F-OR (ARG2 (CAR FLIST))
                                 (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))))
                     GIVEN DEFNS SYMBOLS)
             (FORMULA (ARG1 (CAR FLIST)) SYMBOLS)
             (FORMULA (ARG2 (CAR FLIST)) SYMBOLS)
             (FORM-LIST (CDR FLIST) SYMBOLS)
             (FORM-LIST AUXLIST SYMBOLS)
             (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                          AUXLIST))
           (PROVES
            (ASSOC-PROOF
                      (ARG1 (CAR FLIST))
                      (ARG2 (CAR FLIST))
                      (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                      (TAUT-PROOF1 (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST))
            (F-OR (CAR FLIST)
                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
            GIVEN DEFNS SYMBOLS)).

    Applying the lemmas CAR-CDR-ELIM and ARG1-ARG2-ELIM, replace FLIST by
    (CONS X Z) to eliminate (CAR FLIST) and (CDR FLIST) and X by (F-OR V W) to
    eliminate (ARG1 X) and (ARG2 X).  We thus obtain:

          (IMPLIES
                  (AND (LISTP (APPEND Z AUXLIST))
                       (PROVES (TAUT-PROOF1 (CONS V (CONS W Z))
                                            AUXLIST)
                               (F-OR V
                                     (F-OR W
                                           (MAKE-DISJUNCT (APPEND Z AUXLIST))))
                               GIVEN DEFNS SYMBOLS)
                       (FORMULA V SYMBOLS)
                       (FORMULA W SYMBOLS)
                       (FORM-LIST Z SYMBOLS)
                       (FORM-LIST AUXLIST SYMBOLS)
                       (TAUTOLOGYP1 (CONS V (CONS W Z))
                                    AUXLIST))
                  (PROVES (ASSOC-PROOF V W
                                       (MAKE-DISJUNCT (APPEND Z AUXLIST))
                                       (TAUT-PROOF1 (CONS V (CONS W Z))
                                                    AUXLIST))
                          (F-OR (F-OR V W)
                                (MAKE-DISJUNCT (APPEND Z AUXLIST)))
                          GIVEN DEFNS SYMBOLS)),

    which further simplifies, applying ASSOC-PROOF-PROVES, to:

          T.

Case 4. (IMPLIES
         (AND
          (LISTP FLIST)
          (NOT (F-ORP (CAR FLIST)))
          (F-NOTP (CAR FLIST))
          (F-ORP (ARG (CAR FLIST)))
          (IMPLIES
           (AND (FORM-LIST (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                 (CDR FLIST))
                           SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                   (CDR FLIST))
                             AUXLIST))
           (PROVES
                  (TAUT-PROOF1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                     (CDR FLIST))
                               AUXLIST)
                  (MAKE-DISJUNCT (APPEND (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))
                  GIVEN DEFNS SYMBOLS))
          (IMPLIES
           (AND (FORM-LIST (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                 (CDR FLIST))
                           SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                   (CDR FLIST))
                             AUXLIST))
           (PROVES
                  (TAUT-PROOF1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                     (CDR FLIST))
                               AUXLIST)
                  (MAKE-DISJUNCT (APPEND (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))
                  GIVEN DEFNS SYMBOLS))
          (FORM-LIST FLIST SYMBOLS)
          (FORM-LIST AUXLIST SYMBOLS)
          (TAUTOLOGYP1 FLIST AUXLIST))
         (PROVES (TAUT-PROOF1 FLIST AUXLIST)
                 (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                 GIVEN DEFNS SYMBOLS)).

  This simplifies, applying the lemmas CDR-CONS, FORMULA-F-NOT, CAR-CONS,
  F-NOT-ARG, and F-OR-ARG1-ARG2, and opening up FORM-LIST, AND, APPEND,
  MAKE-DISJUNCT, IMPLIES, FORMULA, NOR-TYPE, TAUTOLOGYP1, NOR-PROOF,
  NLISTP-NOR-TYPE-PROOF, TAUT-PROOF1, and LISTP-NOR-TYPE-PROOF, to the
  following two new goals:

  Case 4.2.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                (PROVES (TAUT-PROOF1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                           (CDR FLIST))
                                     AUXLIST)
                        (F-NOT (ARG2 (ARG (CAR FLIST))))
                        GIVEN DEFNS SYMBOLS)
                (PROVES (TAUT-PROOF1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                           (CDR FLIST))
                                     AUXLIST)
                        (F-NOT (ARG1 (ARG (CAR FLIST))))
                        GIVEN DEFNS SYMBOLS)
                (FORMULA (ARG1 (ARG (CAR FLIST)))
                         SYMBOLS)
                (FORMULA (ARG2 (ARG (CAR FLIST)))
                         SYMBOLS)
                (FORM-LIST (CDR FLIST) SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                   (CDR FLIST))
                             AUXLIST)
                (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                   (CDR FLIST))
                             AUXLIST))
           (PROVES
            (CANCEL-PROOF
              (ARG2 (ARG (CAR FLIST)))
              (CAR FLIST)
              (TAUT-PROOF1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                 (CDR FLIST))
                           AUXLIST)
              (CANCEL-PROOF (ARG1 (ARG (CAR FLIST)))
                            (F-OR (ARG2 (ARG (CAR FLIST)))
                                  (CAR FLIST))
                            (TAUT-PROOF1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)
                            (M-PROOF (LIST (CAR FLIST)
                                           (ARG1 (ARG (CAR FLIST)))
                                           (ARG2 (ARG (CAR FLIST))))
                                     (LIST (ARG1 (ARG (CAR FLIST)))
                                           (ARG2 (ARG (CAR FLIST)))
                                           (CAR FLIST))
                                     (PROP-AXIOM-PROOF (ARG (CAR FLIST))))))
            (CAR FLIST)
            GIVEN DEFNS SYMBOLS)).

    Appealing to the lemmas CAR-CDR-ELIM, ARG-ELIM, and ARG1-ARG2-ELIM, we now
    replace FLIST by (CONS X Z) to eliminate (CAR FLIST) and (CDR FLIST), X by
    (F-NOT V) to eliminate (ARG X), and V by (F-OR W X) to eliminate (ARG2 V)
    and (ARG1 V).  We must thus prove the formula:

          (IMPLIES
           (AND (NOT (LISTP (APPEND Z AUXLIST)))
                (PROVES (TAUT-PROOF1 (CONS (F-NOT X) Z)
                                     AUXLIST)
                        (F-NOT X)
                        GIVEN DEFNS SYMBOLS)
                (PROVES (TAUT-PROOF1 (CONS (F-NOT W) Z)
                                     AUXLIST)
                        (F-NOT W)
                        GIVEN DEFNS SYMBOLS)
                (FORMULA W SYMBOLS)
                (FORMULA X SYMBOLS)
                (FORM-LIST Z SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (F-NOT W) Z)
                             AUXLIST)
                (TAUTOLOGYP1 (CONS (F-NOT X) Z)
                             AUXLIST))
           (PROVES
            (CANCEL-PROOF X
                        (F-NOT (F-OR W X))
                        (TAUT-PROOF1 (CONS (F-NOT X) Z)
                                     AUXLIST)
                        (CANCEL-PROOF W
                                      (F-OR X (F-NOT (F-OR W X)))
                                      (TAUT-PROOF1 (CONS (F-NOT W) Z)
                                                   AUXLIST)
                                      (M-PROOF (LIST (F-NOT (F-OR W X)) W X)
                                               (LIST W X (F-NOT (F-OR W X)))
                                               (PROP-AXIOM-PROOF (F-OR W X)))))
            (F-NOT (F-OR W X))
            GIVEN DEFNS SYMBOLS)).

    This further simplifies, rewriting with CANCEL-PROOF-PROVES,
    PROP-AXIOM-PROVES, SUBSET-CONS, SUBSET-CAR, FORMULA-F-OR, FORMULA-F-NOT,
    CAR-CONS, CDR-CONS, and M-PROOF-PROVES1, and opening up the definitions of
    MAKE-DISJUNCT, SUBSET, MEMBER, LISTP, and FORM-LIST, to:

          T.

  Case 4.1.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (LISTP (APPEND (CDR FLIST) AUXLIST))
                (PROVES (TAUT-PROOF1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                           (CDR FLIST))
                                     AUXLIST)
                        (F-OR (F-NOT (ARG2 (ARG (CAR FLIST))))
                              (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                        GIVEN DEFNS SYMBOLS)
                (PROVES (TAUT-PROOF1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                           (CDR FLIST))
                                     AUXLIST)
                        (F-OR (F-NOT (ARG1 (ARG (CAR FLIST))))
                              (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                        GIVEN DEFNS SYMBOLS)
                (FORMULA (ARG1 (ARG (CAR FLIST)))
                         SYMBOLS)
                (FORMULA (ARG2 (ARG (CAR FLIST)))
                         SYMBOLS)
                (FORM-LIST (CDR FLIST) SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                   (CDR FLIST))
                             AUXLIST)
                (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                   (CDR FLIST))
                             AUXLIST))
           (PROVES
            (M-PROOF
             (LIST (CAR FLIST)
                   (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                   (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
             (LIST (CAR FLIST)
                   (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
             (RT-ASSOC-PROOF
              (CAR FLIST)
              (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
              (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
              (CUT-PROOF
               (ARG2 (ARG (CAR FLIST)))
               (F-OR (CAR FLIST)
                     (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
               (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
               (RT-ASSOC-PROOF
                 (ARG2 (ARG (CAR FLIST)))
                 (CAR FLIST)
                 (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                 (CUT-PROOF (ARG1 (ARG (CAR FLIST)))
                            (F-OR (ARG2 (ARG (CAR FLIST)))
                                  (CAR FLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                            (M-PROOF (LIST (CAR FLIST)
                                           (ARG1 (ARG (CAR FLIST)))
                                           (ARG2 (ARG (CAR FLIST))))
                                     (LIST (ARG1 (ARG (CAR FLIST)))
                                           (ARG2 (ARG (CAR FLIST)))
                                           (CAR FLIST))
                                     (PROP-AXIOM-PROOF (ARG (CAR FLIST))))
                            (TAUT-PROOF1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
               (TAUT-PROOF1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                  (CDR FLIST))
                            AUXLIST))))
            (F-OR (CAR FLIST)
                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
            GIVEN DEFNS SYMBOLS)).

    Appealing to the lemmas CAR-CDR-ELIM, ARG-ELIM, and ARG1-ARG2-ELIM, we now
    replace FLIST by (CONS X Z) to eliminate (CAR FLIST) and (CDR FLIST), X by
    (F-NOT V) to eliminate (ARG X), and V by (F-OR W X) to eliminate (ARG2 V)
    and (ARG1 V).  We must thus prove:

          (IMPLIES
           (AND (LISTP (APPEND Z AUXLIST))
                (PROVES (TAUT-PROOF1 (CONS (F-NOT X) Z)
                                     AUXLIST)
                        (F-OR (F-NOT X)
                              (MAKE-DISJUNCT (APPEND Z AUXLIST)))
                        GIVEN DEFNS SYMBOLS)
                (PROVES (TAUT-PROOF1 (CONS (F-NOT W) Z)
                                     AUXLIST)
                        (F-OR (F-NOT W)
                              (MAKE-DISJUNCT (APPEND Z AUXLIST)))
                        GIVEN DEFNS SYMBOLS)
                (FORMULA W SYMBOLS)
                (FORMULA X SYMBOLS)
                (FORM-LIST Z SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (F-NOT W) Z)
                             AUXLIST)
                (TAUTOLOGYP1 (CONS (F-NOT X) Z)
                             AUXLIST))
           (PROVES
            (M-PROOF
             (LIST (F-NOT (F-OR W X))
                   (MAKE-DISJUNCT (APPEND Z AUXLIST))
                   (MAKE-DISJUNCT (APPEND Z AUXLIST)))
             (LIST (F-NOT (F-OR W X))
                   (MAKE-DISJUNCT (APPEND Z AUXLIST)))
             (RT-ASSOC-PROOF
              (F-NOT (F-OR W X))
              (MAKE-DISJUNCT (APPEND Z AUXLIST))
              (MAKE-DISJUNCT (APPEND Z AUXLIST))
              (CUT-PROOF X
               (F-OR (F-NOT (F-OR W X))
                     (MAKE-DISJUNCT (APPEND Z AUXLIST)))
               (MAKE-DISJUNCT (APPEND Z AUXLIST))
               (RT-ASSOC-PROOF X
                             (F-NOT (F-OR W X))
                             (MAKE-DISJUNCT (APPEND Z AUXLIST))
                             (CUT-PROOF W
                                        (F-OR X (F-NOT (F-OR W X)))
                                        (MAKE-DISJUNCT (APPEND Z AUXLIST))
                                        (M-PROOF (LIST (F-NOT (F-OR W X)) W X)
                                                 (LIST W X (F-NOT (F-OR W X)))
                                                 (PROP-AXIOM-PROOF (F-OR W X)))
                                        (TAUT-PROOF1 (CONS (F-NOT W) Z)
                                                     AUXLIST)))
               (TAUT-PROOF1 (CONS (F-NOT X) Z)
                            AUXLIST))))
            (F-OR (F-NOT (F-OR W X))
                  (MAKE-DISJUNCT (APPEND Z AUXLIST)))
            GIVEN DEFNS SYMBOLS)).

    This further simplifies, applying RT-ASSOC-PROOF-PROVES, M-PROOF-PROVES1,
    SUBSET-CAR, PROP-AXIOM-PROVES, CUT-PROOF-PROVES, SUBSET-CONS, SUBSET-IDENT,
    FORM-LIST-APPEND, FORMLIST-FORMULA-MAKE-DISJ, CAR-CONS, FORMULA-F-OR,
    FORMULA-F-NOT, and CDR-CONS, and unfolding the definitions of
    MAKE-DISJUNCT, SUBSET, MEMBER, LISTP, and FORM-LIST, to:

          T.

Case 3. (IMPLIES
         (AND
          (LISTP FLIST)
          (NOT (F-ORP (CAR FLIST)))
          (NOT (NOR-TYPE (CAR FLIST)))
          (F-NOTP (CAR FLIST))
          (F-NOTP (ARG (CAR FLIST)))
          (IMPLIES (AND (FORM-LIST (CONS (ARG (ARG (CAR FLIST)))
                                         (CDR FLIST))
                                   SYMBOLS)
                        (FORM-LIST AUXLIST SYMBOLS)
                        (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                           (CDR FLIST))
                                     AUXLIST))
                   (PROVES (TAUT-PROOF1 (CONS (ARG (ARG (CAR FLIST)))
                                              (CDR FLIST))
                                        AUXLIST)
                           (MAKE-DISJUNCT (APPEND (CONS (ARG (ARG (CAR FLIST)))
                                                        (CDR FLIST))
                                                  AUXLIST))
                           GIVEN DEFNS SYMBOLS))
          (FORM-LIST FLIST SYMBOLS)
          (FORM-LIST AUXLIST SYMBOLS)
          (TAUTOLOGYP1 FLIST AUXLIST))
         (PROVES (TAUT-PROOF1 FLIST AUXLIST)
                 (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                 GIVEN DEFNS SYMBOLS)).

  This simplifies, appealing to the lemmas CDR-CONS, CAR-CONS, and F-NOT-ARG,
  and expanding the functions NOR-TYPE, FORM-LIST, AND, APPEND, MAKE-DISJUNCT,
  IMPLIES, FORMULA, DBLE-NEG-TYPE, TAUTOLOGYP1, DBLE-NEG-PROOF,
  NLISTP-DBLE-NEG-PROOF, TAUT-PROOF1, and LISTP-DBLE-NEG-PROOF, to the
  following two new conjectures:

  Case 3.2.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-NOTP (ARG (CAR FLIST)))
                (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                (PROVES (TAUT-PROOF1 (CONS (ARG (ARG (CAR FLIST)))
                                           (CDR FLIST))
                                     AUXLIST)
                        (ARG (ARG (CAR FLIST)))
                        GIVEN DEFNS SYMBOLS)
                (FORMULA (ARG (ARG (CAR FLIST)))
                         SYMBOLS)
                (FORM-LIST (CDR FLIST) SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                   (CDR FLIST))
                             AUXLIST))
           (PROVES
            (CONTRAC-PROOF
             (CAR FLIST)
             (CUT-PROOF
                     (ARG (ARG (CAR FLIST)))
                     (CAR FLIST)
                     (CAR FLIST)
                     (RT-EXPAN-PROOF (ARG (ARG (CAR FLIST)))
                                     (CAR FLIST)
                                     (TAUT-PROOF1 (CONS (ARG (ARG (CAR FLIST)))
                                                        (CDR FLIST))
                                                  AUXLIST))
                     (COMMUT-PROOF (CAR FLIST)
                                   (ARG (CAR FLIST))
                                   (PROP-AXIOM-PROOF (ARG (CAR FLIST))))))
            (CAR FLIST)
            GIVEN DEFNS SYMBOLS)).

    Appealing to the lemmas CAR-CDR-ELIM and ARG-ELIM, we now replace FLIST by
    (CONS X Z) to eliminate (CAR FLIST) and (CDR FLIST), X by (F-NOT V) to
    eliminate (ARG X), and V by (F-NOT X) to eliminate (ARG V).  This
    generates:

          (IMPLIES
           (AND (NOT (LISTP (APPEND Z AUXLIST)))
                (PROVES (TAUT-PROOF1 (CONS X Z) AUXLIST)
                        X GIVEN DEFNS SYMBOLS)
                (FORMULA X SYMBOLS)
                (FORM-LIST Z SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS X Z) AUXLIST))
           (PROVES
            (CONTRAC-PROOF
                   (F-NOT (F-NOT X))
                   (CUT-PROOF X
                              (F-NOT (F-NOT X))
                              (F-NOT (F-NOT X))
                              (RT-EXPAN-PROOF X
                                              (F-NOT (F-NOT X))
                                              (TAUT-PROOF1 (CONS X Z) AUXLIST))
                              (COMMUT-PROOF (F-NOT (F-NOT X))
                                            (F-NOT X)
                                            (PROP-AXIOM-PROOF (F-NOT X)))))
            (F-NOT (F-NOT X))
            GIVEN DEFNS SYMBOLS)).

    But this further simplifies, applying CUT-PROOF-PROVES, FORMULA-F-NOT,
    RT-EXPAN-PROOF-PROVES, PROP-AXIOM-PROVES, COMMUT-PROOF-PROVES,
    FORMULA-F-OR, and CONTRAC-PROOF-PROVES, to:

          T.

  Case 3.1.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-NOTP (ARG (CAR FLIST)))
                (LISTP (APPEND (CDR FLIST) AUXLIST))
                (PROVES (TAUT-PROOF1 (CONS (ARG (ARG (CAR FLIST)))
                                           (CDR FLIST))
                                     AUXLIST)
                        (F-OR (ARG (ARG (CAR FLIST)))
                              (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                        GIVEN DEFNS SYMBOLS)
                (FORMULA (ARG (ARG (CAR FLIST)))
                         SYMBOLS)
                (FORM-LIST (CDR FLIST) SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                   (CDR FLIST))
                             AUXLIST))
           (PROVES
            (COMMUT-PROOF
               (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
               (CAR FLIST)
               (CUT-PROOF (ARG (ARG (CAR FLIST)))
                          (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                          (CAR FLIST)
                          (TAUT-PROOF1 (CONS (ARG (ARG (CAR FLIST)))
                                             (CDR FLIST))
                                       AUXLIST)
                          (COMMUT-PROOF (CAR FLIST)
                                        (ARG (CAR FLIST))
                                        (PROP-AXIOM-PROOF (ARG (CAR FLIST))))))
            (F-OR (CAR FLIST)
                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
            GIVEN DEFNS SYMBOLS)).

    Appealing to the lemmas CAR-CDR-ELIM and ARG-ELIM, we now replace FLIST by
    (CONS X Z) to eliminate (CAR FLIST) and (CDR FLIST), X by (F-NOT V) to
    eliminate (ARG X), and V by (F-NOT X) to eliminate (ARG V).  This
    generates:

          (IMPLIES
           (AND (LISTP (APPEND Z AUXLIST))
                (PROVES (TAUT-PROOF1 (CONS X Z) AUXLIST)
                        (F-OR X
                              (MAKE-DISJUNCT (APPEND Z AUXLIST)))
                        GIVEN DEFNS SYMBOLS)
                (FORMULA X SYMBOLS)
                (FORM-LIST Z SYMBOLS)
                (FORM-LIST AUXLIST SYMBOLS)
                (TAUTOLOGYP1 (CONS X Z) AUXLIST))
           (PROVES
            (COMMUT-PROOF
                       (MAKE-DISJUNCT (APPEND Z AUXLIST))
                       (F-NOT (F-NOT X))
                       (CUT-PROOF X
                                  (MAKE-DISJUNCT (APPEND Z AUXLIST))
                                  (F-NOT (F-NOT X))
                                  (TAUT-PROOF1 (CONS X Z) AUXLIST)
                                  (COMMUT-PROOF (F-NOT (F-NOT X))
                                                (F-NOT X)
                                                (PROP-AXIOM-PROOF (F-NOT X)))))
            (F-OR (F-NOT (F-NOT X))
                  (MAKE-DISJUNCT (APPEND Z AUXLIST)))
            GIVEN DEFNS SYMBOLS)).

    However this further simplifies, rewriting with CUT-PROOF-PROVES,
    PROP-AXIOM-PROVES, FORMULA-F-NOT, COMMUT-PROOF-PROVES, FORM-LIST-APPEND,
    FORMLIST-FORMULA-MAKE-DISJ, and FORMULA-F-OR, to:

          T.

Case 2. (IMPLIES
         (AND
           (LISTP FLIST)
           (NOT (F-ORP (CAR FLIST)))
           (NOT (NOR-TYPE (CAR FLIST)))
           (NOT (DBLE-NEG-TYPE (CAR FLIST)))
           (IMPLIES (AND (FORM-LIST (CDR FLIST) SYMBOLS)
                         (FORM-LIST (CONS (CAR FLIST) AUXLIST)
                                    SYMBOLS)
                         (TAUTOLOGYP1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST)))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS))
           (FORM-LIST FLIST SYMBOLS)
           (FORM-LIST AUXLIST SYMBOLS)
           (TAUTOLOGYP1 FLIST AUXLIST))
         (PROVES (TAUT-PROOF1 FLIST AUXLIST)
                 (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                 GIVEN DEFNS SYMBOLS)).

  This simplifies, rewriting with CDR-CONS, CAR-CONS, and
  PROP-ATOM-PROOF1-PROVES, and expanding the definitions of NOR-TYPE,
  DBLE-NEG-TYPE, FORM-LIST, AND, IMPLIES, NEG-LIST, TAUTOLOGYP1, TAUT-PROOF1,
  APPEND, and MAKE-DISJUNCT, to 16 new formulas:

  Case 2.16.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-NOTP (CAR FLIST)))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (CAR FLIST)
                    GIVEN DEFNS SYMBOLS)),

    which again simplifies, applying CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF2-PROVES, and unfolding the definitions of MAKE-DISJUNCT,
    APPEND, and FORM-LIST, to:

          T.

  Case 2.15.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-NOTP (CAR FLIST)))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                    (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (CAR FLIST)
                       GIVEN DEFNS SYMBOLS)).

    However this again simplifies, appealing to the lemmas CDR-CONS, CAR-CONS,
    and PROP-ATOM-PROOF1-PROVES, and unfolding MAKE-DISJUNCT, APPEND, NEG-LIST,
    and FORM-LIST, to:

          T.

  Case 2.14.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-NOTP (CAR FLIST)))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (F-OR (CAR FLIST)
                          (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                    GIVEN DEFNS SYMBOLS)),

    which again simplifies, rewriting with the lemmas CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF2-PROVES, and expanding the definitions of MAKE-DISJUNCT,
    APPEND, and FORM-LIST, to:

          T.

  Case 2.13.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-NOTP (CAR FLIST)))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (LISTP (APPEND (CDR FLIST) AUXLIST))
                    (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (F-OR (CAR FLIST)
                             (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                       GIVEN DEFNS SYMBOLS)),

    which again simplifies, applying CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF1-PROVES, and unfolding the functions MAKE-DISJUNCT, APPEND,
    NEG-LIST, and FORM-LIST, to:

          T.

  Case 2.12.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (CAR FLIST)))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (CAR FLIST)
                    GIVEN DEFNS SYMBOLS)).

    However this again simplifies, applying the lemmas ARG-NF-NOTP, CDR-CONS,
    CAR-CONS, and PROP-ATOM-PROOF2-PROVES, and unfolding the definitions of
    F-ORP, MAKE-DISJUNCT, APPEND, and FORM-LIST, to:

          T.

  Case 2.11.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-ORP (ARG (CAR FLIST))))
                    (NOT (F-NOTP (CAR FLIST)))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                    (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (CAR FLIST)
                       GIVEN DEFNS SYMBOLS)),

    which again simplifies, applying the lemmas ARG-NF-NOTP, CDR-CONS,
    CAR-CONS, and PROP-ATOM-PROOF1-PROVES, and opening up the definitions of
    F-ORP, MAKE-DISJUNCT, APPEND, NEG-LIST, and FORM-LIST, to:

          T.

  Case 2.10.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (CAR FLIST)))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (F-OR (CAR FLIST)
                          (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                    GIVEN DEFNS SYMBOLS)),

    which again simplifies, applying ARG-NF-NOTP, CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF2-PROVES, and opening up the definitions of F-ORP,
    MAKE-DISJUNCT, APPEND, and FORM-LIST, to:

          T.

  Case 2.9.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-ORP (ARG (CAR FLIST))))
                    (NOT (F-NOTP (CAR FLIST)))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (LISTP (APPEND (CDR FLIST) AUXLIST))
                    (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (F-OR (CAR FLIST)
                             (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                       GIVEN DEFNS SYMBOLS)).

    However this again simplifies, appealing to the lemmas ARG-NF-NOTP,
    CDR-CONS, CAR-CONS, and PROP-ATOM-PROOF1-PROVES, and opening up the
    definitions of F-ORP, MAKE-DISJUNCT, APPEND, NEG-LIST, and FORM-LIST, to:

          T.

  Case 2.8.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                 (F-NOTP (CAR FLIST))
                 (NOT (MEMBER (ARG (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (CAR FLIST)
                    GIVEN DEFNS SYMBOLS)),

    which again simplifies, rewriting with CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF2-PROVES, and unfolding the definitions of MAKE-DISJUNCT,
    APPEND, and FORM-LIST, to:

          T.

  Case 2.7.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (CAR FLIST)
                    GIVEN DEFNS SYMBOLS)).

    This again simplifies, rewriting with ARG-NF-NOTP, CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF2-PROVES, and unfolding the definitions of F-ORP, F-NOTP,
    MAKE-DISJUNCT, APPEND, and FORM-LIST, to:

          T.

  Case 2.6.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-ORP (ARG (CAR FLIST))))
                    (NOT (F-NOTP (ARG (CAR FLIST))))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                    (F-NOTP (CAR FLIST))
                    (MEMBER (ARG (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (CAR FLIST)
                       GIVEN DEFNS SYMBOLS)).

    However this again simplifies, appealing to the lemmas CDR-CONS, CAR-CONS,
    and PROP-ATOM-PROOF1-PROVES, and expanding the functions MAKE-DISJUNCT,
    APPEND, NEG-LIST, and FORM-LIST, to:

          T.

  Case 2.5.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-ORP (ARG (CAR FLIST))))
                    (NOT (F-NOTP (ARG (CAR FLIST))))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                    (NOT (F-NOTP (CAR FLIST)))
                    (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (CAR FLIST)
                       GIVEN DEFNS SYMBOLS)),

    which again simplifies, applying ARG-NF-NOTP, CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF1-PROVES, and opening up the functions F-ORP, F-NOTP,
    MAKE-DISJUNCT, APPEND, NEG-LIST, and FORM-LIST, to:

          T.

  Case 2.4.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (F-NOTP (CAR FLIST))
                 (NOT (MEMBER (ARG (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (F-OR (CAR FLIST)
                          (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                    GIVEN DEFNS SYMBOLS)).

    But this again simplifies, rewriting with CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF2-PROVES, and unfolding MAKE-DISJUNCT, APPEND, and
    FORM-LIST, to:

          T.

  Case 2.3.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (PROVES (TAUT-PROOF1 (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST))
                         (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))
                         GIVEN DEFNS SYMBOLS)
                 (FORMULA (CAR FLIST) SYMBOLS)
                 (FORM-LIST (CDR FLIST) SYMBOLS)
                 (FORM-LIST AUXLIST SYMBOLS)
                 (TAUTOLOGYP1 (CDR FLIST)
                              (CONS (CAR FLIST) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST)))
            (PROVES (PROP-ATOM-PROOF2 FLIST AUXLIST
                                      (TAUT-PROOF1 (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                    (F-OR (CAR FLIST)
                          (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                    GIVEN DEFNS SYMBOLS)).

    But this again simplifies, rewriting with ARG-NF-NOTP, CDR-CONS, CAR-CONS,
    and PROP-ATOM-PROOF2-PROVES, and unfolding the functions F-ORP, F-NOTP,
    MAKE-DISJUNCT, APPEND, and FORM-LIST, to:

          T.

  Case 2.2.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-ORP (ARG (CAR FLIST))))
                    (NOT (F-NOTP (ARG (CAR FLIST))))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (LISTP (APPEND (CDR FLIST) AUXLIST))
                    (F-NOTP (CAR FLIST))
                    (MEMBER (ARG (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (F-OR (CAR FLIST)
                             (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                       GIVEN DEFNS SYMBOLS)).

    This again simplifies, applying CDR-CONS, CAR-CONS, and
    PROP-ATOM-PROOF1-PROVES, and unfolding MAKE-DISJUNCT, APPEND, NEG-LIST,
    and FORM-LIST, to:

          T.

  Case 2.1.
          (IMPLIES
               (AND (LISTP FLIST)
                    (NOT (F-ORP (CAR FLIST)))
                    (NOT (F-ORP (ARG (CAR FLIST))))
                    (NOT (F-NOTP (ARG (CAR FLIST))))
                    (PROVES (TAUT-PROOF1 (CDR FLIST)
                                         (CONS (CAR FLIST) AUXLIST))
                            (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            GIVEN DEFNS SYMBOLS)
                    (FORMULA (CAR FLIST) SYMBOLS)
                    (FORM-LIST (CDR FLIST) SYMBOLS)
                    (FORM-LIST AUXLIST SYMBOLS)
                    (TAUTOLOGYP1 (CDR FLIST)
                                 (CONS (CAR FLIST) AUXLIST))
                    (LISTP (APPEND (CDR FLIST) AUXLIST))
                    (NOT (F-NOTP (CAR FLIST)))
                    (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
               (PROVES (PROP-ATOM-PROOF1 FLIST AUXLIST)
                       (F-OR (CAR FLIST)
                             (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                       GIVEN DEFNS SYMBOLS)).

    However this again simplifies, applying the lemmas ARG-NF-NOTP, CDR-CONS,
    CAR-CONS, and PROP-ATOM-PROOF1-PROVES, and expanding the functions F-ORP,
    F-NOTP, MAKE-DISJUNCT, APPEND, NEG-LIST, and FORM-LIST, to:

          T.

Case 1. (IMPLIES (AND (NOT (LISTP FLIST))
                      (FORM-LIST FLIST SYMBOLS)
                      (FORM-LIST AUXLIST SYMBOLS)
                      (TAUTOLOGYP1 FLIST AUXLIST))
                 (PROVES (TAUT-PROOF1 FLIST AUXLIST)
                         (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                         GIVEN DEFNS SYMBOLS)),

  which simplifies, expanding FORM-LIST and TAUTOLOGYP1, to:

        T.

Q.E.D.


[ 0.0 3.7 0.1 ]

TAUT-THM1


(TOGGLE G0275 TAUT-PROOF1 T)

[ 0.0 0.0 0.0 ]

G0275


(PROVE-LEMMA TAUT-THM2
            (REWRITE)
            (IMPLIES (AND (FORM-LIST FLIST SYMBOLS)
                          (FORM-LIST AUXLIST SYMBOLS)
                          (TAUTOLOGYP1 FLIST AUXLIST)
                          (EQUAL CONCL
                                 (MAKE-DISJUNCT (APPEND FLIST AUXLIST))))
                     (PROVES (TAUT-PROOF1 FLIST AUXLIST)
                             CONCL GIVEN DEFNS SYMBOLS))
            ((USE (TAUT-THM1 (CONCL (MAKE-DISJUNCT (APPEND FLIST AUXLIST)))))))

This formula simplifies, rewriting with the lemma TAUT-THM1, and opening up
AND and IMPLIES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TAUT-THM2


(DEFN EVAL
      (EXP ALIST)
      (IF (F-NOTP EXP)
          (NOT (EVAL (ARG EXP) ALIST))
          (IF (F-ORP EXP)
              (OR (EVAL (ARG1 EXP) ALIST)
                  (EVAL (ARG2 EXP) ALIST))
              (MEMBER EXP ALIST))))

     Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, and ARG1-LESSP
inform us that the measure (COUNT EXP) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, EVAL is accepted under the
principle of definition.  Observe that:
      (OR (FALSEP (EVAL EXP ALIST))
          (TRUEP (EVAL EXP ALIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

EVAL


(PROVE-LEMMA MEMBER-EVAL
             (REWRITE)
             (IMPLIES (AND (MEMBER EXP FLIST)
                           (EVAL EXP ALIST))
                      (EVAL (MAKE-DISJUNCT FLIST) ALIST)))

WARNING:  Note that MEMBER-EVAL contains the free variable EXP which will be
chosen by instantiating the hypothesis (MEMBER EXP FLIST).



     Give the conjecture the name *1.


     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 (NLISTP FLIST)
                    (p FLIST ALIST EXP))
           (IMPLIES (AND (NOT (NLISTP FLIST))
                         (EQUAL EXP (CAR FLIST)))
                    (p FLIST ALIST EXP))
           (IMPLIES (AND (NOT (NLISTP FLIST))
                         (NOT (EQUAL EXP (CAR FLIST)))
                         (p (CDR FLIST) ALIST EXP))
                    (p FLIST ALIST EXP))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT FLIST) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces the following four new formulas:

Case 4. (IMPLIES (AND (NLISTP FLIST)
                      (MEMBER EXP FLIST)
                      (EVAL EXP ALIST))
                 (EVAL (MAKE-DISJUNCT FLIST) ALIST)).

  This simplifies, opening up NLISTP and MEMBER, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (EQUAL EXP (CAR FLIST))
                      (MEMBER EXP FLIST)
                      (EVAL EXP ALIST))
                 (EVAL (MAKE-DISJUNCT FLIST) ALIST)).

  This simplifies, opening up the definitions of NLISTP, MEMBER, and
  MAKE-DISJUNCT, to:

        (IMPLIES (AND (LISTP FLIST)
                      (EVAL (CAR FLIST) ALIST)
                      (LISTP (CDR FLIST)))
                 (EVAL (F-OR (CAR FLIST)
                             (MAKE-DISJUNCT (CDR FLIST)))
                       ALIST)),

  which again simplifies, applying ARG1-F-OR, and opening up EVAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (EQUAL EXP (CAR FLIST)))
                      (NOT (MEMBER EXP (CDR FLIST)))
                      (MEMBER EXP FLIST)
                      (EVAL EXP ALIST))
                 (EVAL (MAKE-DISJUNCT FLIST) ALIST)).

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

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (EQUAL EXP (CAR FLIST)))
                      (EVAL (MAKE-DISJUNCT (CDR FLIST))
                            ALIST)
                      (MEMBER EXP FLIST)
                      (EVAL EXP ALIST))
                 (EVAL (MAKE-DISJUNCT FLIST) ALIST)).

  This simplifies, opening up NLISTP, MEMBER, and MAKE-DISJUNCT, to the
  following two new goals:

  Case 1.2.
          (IMPLIES (AND (LISTP FLIST)
                        (NOT (EQUAL EXP (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (MEMBER EXP (CDR FLIST))
                        (EVAL EXP ALIST)
                        (NOT (LISTP (CDR FLIST))))
                   (EVAL (CAR FLIST) ALIST)).

    But this further simplifies, opening up the functions MAKE-DISJUNCT, F-ORP,
    F-NOTP, EVAL, and MEMBER, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP FLIST)
                        (NOT (EQUAL EXP (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (MEMBER EXP (CDR FLIST))
                        (EVAL EXP ALIST)
                        (LISTP (CDR FLIST)))
                   (EVAL (F-OR (CAR FLIST)
                               (MAKE-DISJUNCT (CDR FLIST)))
                         ALIST)),

    which again simplifies, rewriting with the lemmas ARG2-F-OR and ARG1-F-OR,
    and opening up the function EVAL, to:

          T.


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


[ 0.0 0.0 0.0 ]

MEMBER-EVAL


(PROVE-LEMMA EVAL-MAKE-DISJUNCT
             (REWRITE)
             (IMPLIES (AND (LISTP LIST1) (LISTP LIST2))
                      (EQUAL (EVAL (MAKE-DISJUNCT (APPEND LIST1 LIST2))
                                   ALIST)
                             (OR (EVAL (MAKE-DISJUNCT LIST1) ALIST)
                                 (EVAL (MAKE-DISJUNCT LIST2) ALIST)))))

This formula simplifies, unfolding the function OR, to two new goals:

Case 2. (IMPLIES (AND (LISTP LIST1)
                      (LISTP LIST2)
                      (NOT (EVAL (MAKE-DISJUNCT LIST1) ALIST)))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND LIST1 LIST2))
                              ALIST)
                        (EVAL (MAKE-DISJUNCT LIST2) ALIST))),

  which we will name *1.

Case 1. (IMPLIES (AND (LISTP LIST1)
                      (LISTP LIST2)
                      (EVAL (MAKE-DISJUNCT LIST1) ALIST))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND LIST1 LIST2))
                              ALIST)
                        T)).

  This again simplifies, obviously, to:

        (IMPLIES (AND (LISTP LIST1)
                      (LISTP LIST2)
                      (EVAL (MAKE-DISJUNCT LIST1) ALIST))
                 (EVAL (MAKE-DISJUNCT (APPEND LIST1 LIST2))
                       ALIST)),

  which we would normally push and work on later by induction.  But if we must
  use induction to prove the input conjecture, we prefer to induct on the
  original formulation of the problem.  Thus we will disregard all that we
  have previously done, give the name *1 to the original input, and work on it.


     So now let us return to:

(IMPLIES (AND (LISTP LIST1) (LISTP LIST2))
         (EQUAL (EVAL (MAKE-DISJUNCT (APPEND LIST1 LIST2))
                      ALIST)
                (OR (EVAL (MAKE-DISJUNCT LIST1) ALIST)
                    (EVAL (MAKE-DISJUNCT LIST2) ALIST)))),

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.  However, only one is unflawed.  We will induct according to the
following scheme:
      (AND (IMPLIES (AND (LISTP LIST1)
                         (p (CDR LIST1) LIST2 ALIST))
                    (p LIST1 LIST2 ALIST))
           (IMPLIES (NOT (LISTP LIST1))
                    (p LIST1 LIST2 ALIST))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT LIST1) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme produces two new
goals:

Case 2. (IMPLIES (AND (NOT (LISTP (CDR LIST1)))
                      (LISTP LIST1)
                      (LISTP LIST2))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND LIST1 LIST2))
                              ALIST)
                        (OR (EVAL (MAKE-DISJUNCT LIST1) ALIST)
                            (EVAL (MAKE-DISJUNCT LIST2) ALIST)))),

  which simplifies, rewriting with CAR-CONS, CDR-CONS, ARG2-F-OR, and
  ARG1-F-OR, and expanding the definitions of APPEND, MAKE-DISJUNCT, EVAL, and
  OR, to:

        (IMPLIES (AND (NOT (LISTP (CDR LIST1)))
                      (LISTP LIST1)
                      (LISTP LIST2)
                      (NOT (EVAL (CAR LIST1) ALIST)))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR LIST1) LIST2))
                              ALIST)
                        (EVAL (MAKE-DISJUNCT LIST2) ALIST))),

  which further simplifies, opening up the function APPEND, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR LIST1) LIST2))
                                   ALIST)
                             (OR (EVAL (MAKE-DISJUNCT (CDR LIST1))
                                       ALIST)
                                 (EVAL (MAKE-DISJUNCT LIST2) ALIST)))
                      (LISTP LIST1)
                      (LISTP LIST2))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND LIST1 LIST2))
                              ALIST)
                        (OR (EVAL (MAKE-DISJUNCT LIST1) ALIST)
                            (EVAL (MAKE-DISJUNCT LIST2) ALIST)))),

  which simplifies, rewriting with CAR-CONS, CDR-CONS, ARG2-F-OR, and
  ARG1-F-OR, and expanding the definitions of OR, APPEND, MAKE-DISJUNCT, and
  EVAL, to the following four new goals:

  Case 1.4.
          (IMPLIES (AND (NOT (EVAL (MAKE-DISJUNCT (CDR LIST1))
                                   ALIST))
                        (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR LIST1) LIST2))
                                     ALIST)
                               (EVAL (MAKE-DISJUNCT LIST2) ALIST))
                        (LISTP LIST1)
                        (LISTP LIST2)
                        (LISTP (CDR LIST1))
                        (NOT (EVAL (F-OR (CAR LIST1)
                                         (MAKE-DISJUNCT (CDR LIST1)))
                                   ALIST))
                        (EVAL (CAR LIST1) ALIST))
                   (EQUAL T
                          (EVAL (MAKE-DISJUNCT LIST2) ALIST))).

    This again simplifies, applying the lemma ARG1-F-OR, and expanding the
    definition of EVAL, to:

          T.

  Case 1.3.
          (IMPLIES (AND (NOT (EVAL (MAKE-DISJUNCT (CDR LIST1))
                                   ALIST))
                        (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR LIST1) LIST2))
                                     ALIST)
                               (EVAL (MAKE-DISJUNCT LIST2) ALIST))
                        (LISTP LIST1)
                        (LISTP LIST2)
                        (LISTP (CDR LIST1))
                        (EVAL (F-OR (CAR LIST1)
                                    (MAKE-DISJUNCT (CDR LIST1)))
                              ALIST)
                        (NOT (EVAL (CAR LIST1) ALIST)))
                   (EQUAL (EVAL (MAKE-DISJUNCT LIST2) ALIST)
                          T)),

    which again simplifies, applying ARG2-F-OR and ARG1-F-OR, and unfolding
    the definition of EVAL, to:

          T.

  Case 1.2.
          (IMPLIES (AND (EVAL (MAKE-DISJUNCT (CDR LIST1))
                              ALIST)
                        (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR LIST1) LIST2))
                                     ALIST)
                               T)
                        (LISTP LIST1)
                        (LISTP LIST2)
                        (LISTP (CDR LIST1))
                        (NOT (EVAL (F-OR (CAR LIST1)
                                         (MAKE-DISJUNCT (CDR LIST1)))
                                   ALIST)))
                   (EVAL (MAKE-DISJUNCT LIST2) ALIST)).

    But this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    unfolding EVAL, to:

          T.

  Case 1.1.
          (IMPLIES (AND (EVAL (MAKE-DISJUNCT (CDR LIST1))
                              ALIST)
                        (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR LIST1) LIST2))
                                     ALIST)
                               T)
                        (LISTP LIST1)
                        (LISTP LIST2)
                        (NOT (LISTP (CDR LIST1)))
                        (NOT (EVAL (CAR LIST1) ALIST)))
                   (EVAL (MAKE-DISJUNCT LIST2) ALIST)).

    This again simplifies, trivially, to:

          (IMPLIES (AND (EVAL (MAKE-DISJUNCT (CDR LIST1))
                              ALIST)
                        (EVAL (MAKE-DISJUNCT (APPEND (CDR LIST1) LIST2))
                              ALIST)
                        (LISTP LIST1)
                        (LISTP LIST2)
                        (NOT (LISTP (CDR LIST1)))
                        (NOT (EVAL (CAR LIST1) ALIST)))
                   (EVAL (MAKE-DISJUNCT LIST2) ALIST)),

    which further simplifies, opening up MAKE-DISJUNCT, F-ORP, F-NOTP, EVAL,
    and APPEND, to:

          T.


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


[ 0.0 0.0 0.0 ]

EVAL-MAKE-DISJUNCT


(PROVE-LEMMA NEG-LIST-EVAL
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST1)
                           (NEG-LIST (CAR FLIST1) FLIST2))
                      (EVAL (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))
                            ALIST))
             ((INDUCT (MEMBER X FLIST2))))

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

Case 3. (IMPLIES (AND (NOT (LISTP FLIST2))
                      (LISTP FLIST1)
                      (NEG-LIST (CAR FLIST1) FLIST2))
                 (EVAL (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))
                       ALIST)),

  which simplifies, opening up the definitions of MEMBER and NEG-LIST, to:

        T.

Case 2. (IMPLIES (AND (LISTP FLIST2)
                      (EQUAL X (CAR FLIST2))
                      (LISTP FLIST1)
                      (NEG-LIST (CAR FLIST1) FLIST2))
                 (EVAL (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))
                       ALIST)),

  which simplifies, applying EVAL-MAKE-DISJUNCT, and expanding NEG-LIST, to
  the following two new conjectures:

  Case 2.2.
          (IMPLIES (AND (LISTP FLIST2)
                        (LISTP FLIST1)
                        (NOT (F-NOTP (CAR FLIST1)))
                        (MEMBER (F-NOT (CAR FLIST1)) FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST)))
                   (EVAL (MAKE-DISJUNCT FLIST2) ALIST)).

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

          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (F-NOTP Z))
                        (MEMBER (F-NOT Z) FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT (CONS Z V))
                                   ALIST)))
                   (EVAL (MAKE-DISJUNCT FLIST2) ALIST)).

    This further simplifies, rewriting with the lemmas CAR-CONS, CDR-CONS,
    ARG-F-NOT, and MEMBER-EVAL, and expanding the definitions of MAKE-DISJUNCT
    and EVAL, to the conjecture:

          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (F-NOTP Z))
                        (MEMBER (F-NOT Z) FLIST2)
                        (LISTP V)
                        (NOT (EVAL (F-OR Z (MAKE-DISJUNCT V))
                                   ALIST)))
                   (EVAL (MAKE-DISJUNCT FLIST2) ALIST)).

    However this again simplifies, applying ARG2-F-OR, ARG1-F-OR, ARG-F-NOT,
    and MEMBER-EVAL, and expanding the definition of EVAL, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP FLIST2)
                        (LISTP FLIST1)
                        (F-NOTP (CAR FLIST1))
                        (MEMBER (ARG (CAR FLIST1)) FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST)))
                   (EVAL (MAKE-DISJUNCT FLIST2) ALIST)).

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

          (IMPLIES (AND (LISTP FLIST2)
                        (MEMBER W FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT (CONS (F-NOT W) V))
                                   ALIST)))
                   (EVAL (MAKE-DISJUNCT FLIST2) ALIST)).

    This further simplifies, rewriting with CAR-CONS and CDR-CONS, and
    unfolding the definition of MAKE-DISJUNCT, to the following two new goals:

    Case 2.1.2.
            (IMPLIES (AND (LISTP FLIST2)
                          (MEMBER W FLIST2)
                          (NOT (LISTP V))
                          (NOT (EVAL (F-NOT W) ALIST)))
                     (EVAL (MAKE-DISJUNCT FLIST2) ALIST)).

      This again simplifies, applying ARG-F-NOT and MEMBER-EVAL, and expanding
      the definition of EVAL, to:

            T.

    Case 2.1.1.
            (IMPLIES (AND (LISTP FLIST2)
                          (MEMBER W FLIST2)
                          (LISTP V)
                          (NOT (EVAL (F-OR (F-NOT W) (MAKE-DISJUNCT V))
                                     ALIST)))
                     (EVAL (MAKE-DISJUNCT FLIST2) ALIST)).

      However this again simplifies, rewriting with ARG2-F-OR, ARG1-F-OR,
      ARG-F-NOT, and MEMBER-EVAL, and unfolding EVAL, to:

            T.

Case 1. (IMPLIES
               (AND (LISTP FLIST2)
                    (NOT (EQUAL X (CAR FLIST2)))
                    (IMPLIES (AND (LISTP FLIST1)
                                  (NEG-LIST (CAR FLIST1) (CDR FLIST2)))
                             (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CDR FLIST2)))
                                   ALIST))
                    (LISTP FLIST1)
                    (NEG-LIST (CAR FLIST1) FLIST2))
               (EVAL (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))
                     ALIST)).

  This simplifies, rewriting with the lemma EVAL-MAKE-DISJUNCT, and expanding
  NEG-LIST, AND, IMPLIES, MEMBER, and MAKE-DISJUNCT, to the following eight
  new conjectures:

  Case 1.8.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (NOT (MEMBER (F-NOT (CAR FLIST1))
                                     (CDR FLIST2)))
                        (LISTP FLIST1)
                        (EQUAL (F-NOT (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP (CDR FLIST2)))
                   (EVAL (F-OR (CAR FLIST2)
                               (MAKE-DISJUNCT (CDR FLIST2)))
                         ALIST)).

    However this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    unfolding the function EVAL, to:

          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (NOT (MEMBER (CAR FLIST2) (CDR FLIST2)))
                        (LISTP FLIST1)
                        (EQUAL (F-NOT (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP (CDR FLIST2))
                        (NOT (EVAL (CAR FLIST2) ALIST)))
                   (EVAL (MAKE-DISJUNCT (CDR FLIST2))
                         ALIST)).

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

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (NOT (MEMBER Z V))
                        (LISTP FLIST1)
                        (EQUAL (F-NOT (CAR FLIST1)) Z)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP V)
                        (NOT (EVAL Z ALIST)))
                   (EVAL (MAKE-DISJUNCT V) ALIST)),

    which further simplifies, rewriting with the lemma ARG-F-NOT, and
    expanding EVAL, to:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT (CAR FLIST1))))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (NOT (MEMBER (F-NOT (CAR FLIST1)) V))
                        (LISTP FLIST1)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP V)
                        (EVAL (CAR FLIST1) ALIST))
                   (EVAL (MAKE-DISJUNCT V) ALIST)).

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

          (IMPLIES (AND (NOT (EQUAL X (F-NOT Z)))
                        (NOT (F-NOTP Z))
                        (NOT (MEMBER (F-NOT Z) V))
                        (NOT (EVAL (MAKE-DISJUNCT (CONS Z W))
                                   ALIST))
                        (LISTP V)
                        (EVAL Z ALIST))
                   (EVAL (MAKE-DISJUNCT V) ALIST)).

    But this further simplifies, rewriting with CAR-CONS and CDR-CONS, and
    unfolding the function MAKE-DISJUNCT, to:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT Z)))
                        (NOT (F-NOTP Z))
                        (NOT (MEMBER (F-NOT Z) V))
                        (LISTP W)
                        (NOT (EVAL (F-OR Z (MAKE-DISJUNCT W))
                                   ALIST))
                        (LISTP V)
                        (EVAL Z ALIST))
                   (EVAL (MAKE-DISJUNCT V) ALIST)),

    which finally simplifies, applying the lemma ARG1-F-OR, and unfolding the
    definition of EVAL, to:

          T.

  Case 1.7.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (NOT (MEMBER (F-NOT (CAR FLIST1))
                                     (CDR FLIST2)))
                        (LISTP FLIST1)
                        (EQUAL (F-NOT (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP (CDR FLIST2))))
                   (EVAL (CAR FLIST2) ALIST)),

    which again simplifies, unfolding the function MEMBER, to:

          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (LISTP FLIST1)
                        (EQUAL (F-NOT (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP (CDR FLIST2))))
                   (EVAL (CAR FLIST2) ALIST)).

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

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (LISTP FLIST1)
                        (EQUAL (F-NOT (CAR FLIST1)) Z)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL Z ALIST)).

    This further simplifies, applying ARG-F-NOT, and opening up EVAL, to the
    new goal:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT (CAR FLIST1))))
                        (NOT (F-NOTP (CAR FLIST1)))
                        (LISTP FLIST1)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (NOT (EVAL (CAR FLIST1) ALIST))).

    Applying the lemma CAR-CDR-ELIM, replace FLIST1 by (CONS Z W) to eliminate
    (CAR FLIST1) and (CDR FLIST1).  This produces the new formula:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT Z)))
                        (NOT (F-NOTP Z))
                        (NOT (EVAL (MAKE-DISJUNCT (CONS Z W))
                                   ALIST))
                        (NOT (LISTP V)))
                   (NOT (EVAL Z ALIST))),

    which further simplifies, rewriting with CAR-CONS and CDR-CONS, and
    expanding the function MAKE-DISJUNCT, to the new goal:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT Z)))
                        (NOT (F-NOTP Z))
                        (LISTP W)
                        (NOT (EVAL (F-OR Z (MAKE-DISJUNCT W))
                                   ALIST))
                        (NOT (LISTP V)))
                   (NOT (EVAL Z ALIST))),

    which finally simplifies, rewriting with ARG1-F-OR, and unfolding EVAL, to:

          T.

  Case 1.6.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (F-NOTP (CAR FLIST1))
                        (NOT (MEMBER (ARG (CAR FLIST1))
                                     (CDR FLIST2)))
                        (LISTP FLIST1)
                        (EQUAL (ARG (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP (CDR FLIST2)))
                   (EVAL (F-OR (CAR FLIST2)
                               (MAKE-DISJUNCT (CDR FLIST2)))
                         ALIST)).

    However this again simplifies, applying ARG2-F-OR and ARG1-F-OR, and
    unfolding the function EVAL, to the new goal:

          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (F-NOTP (CAR FLIST1))
                        (NOT (MEMBER (CAR FLIST2) (CDR FLIST2)))
                        (LISTP FLIST1)
                        (EQUAL (ARG (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP (CDR FLIST2))
                        (NOT (EVAL (CAR FLIST2) ALIST)))
                   (EVAL (MAKE-DISJUNCT (CDR FLIST2))
                         ALIST)).

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

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (F-NOTP (CAR FLIST1))
                        (NOT (MEMBER Z V))
                        (LISTP FLIST1)
                        (EQUAL (ARG (CAR FLIST1)) Z)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP V)
                        (NOT (EVAL Z ALIST)))
                   (EVAL (MAKE-DISJUNCT V) ALIST)),

    which further simplifies, obviously, to:

          (IMPLIES (AND (NOT (EQUAL X (ARG (CAR FLIST1))))
                        (F-NOTP (CAR FLIST1))
                        (NOT (MEMBER (ARG (CAR FLIST1)) V))
                        (LISTP FLIST1)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP V)
                        (NOT (EVAL (ARG (CAR FLIST1)) ALIST)))
                   (EVAL (MAKE-DISJUNCT V) ALIST)).

    Applying the lemmas CAR-CDR-ELIM and ARG-ELIM, replace FLIST1 by
    (CONS Z W) to eliminate (CAR FLIST1) and (CDR FLIST1) and Z by (F-NOT D)
    to eliminate (ARG Z).  We thus obtain:

          (IMPLIES (AND (NOT (EQUAL X D))
                        (NOT (MEMBER D V))
                        (NOT (EVAL (MAKE-DISJUNCT (CONS (F-NOT D) W))
                                   ALIST))
                        (LISTP V)
                        (NOT (EVAL D ALIST)))
                   (EVAL (MAKE-DISJUNCT V) ALIST)),

    which further simplifies, rewriting with CAR-CONS and CDR-CONS, and
    unfolding the definition of MAKE-DISJUNCT, to the following two new
    conjectures:

    Case 1.6.2.
            (IMPLIES (AND (NOT (EQUAL X D))
                          (NOT (MEMBER D V))
                          (NOT (LISTP W))
                          (NOT (EVAL (F-NOT D) ALIST))
                          (LISTP V)
                          (NOT (EVAL D ALIST)))
                     (EVAL (MAKE-DISJUNCT V) ALIST)).

      But this finally simplifies, rewriting with ARG-F-NOT, and expanding the
      function EVAL, to:

            T.

    Case 1.6.1.
            (IMPLIES (AND (NOT (EQUAL X D))
                          (NOT (MEMBER D V))
                          (LISTP W)
                          (NOT (EVAL (F-OR (F-NOT D) (MAKE-DISJUNCT W))
                                     ALIST))
                          (LISTP V)
                          (NOT (EVAL D ALIST)))
                     (EVAL (MAKE-DISJUNCT V) ALIST)).

      But this finally simplifies, applying the lemmas ARG2-F-OR, ARG1-F-OR,
      and ARG-F-NOT, and opening up the definition of EVAL, to:

            T.

  Case 1.5.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (F-NOTP (CAR FLIST1))
                        (NOT (MEMBER (ARG (CAR FLIST1))
                                     (CDR FLIST2)))
                        (LISTP FLIST1)
                        (EQUAL (ARG (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP (CDR FLIST2))))
                   (EVAL (CAR FLIST2) ALIST)),

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

          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (F-NOTP (CAR FLIST1))
                        (LISTP FLIST1)
                        (EQUAL (ARG (CAR FLIST1))
                               (CAR FLIST2))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP (CDR FLIST2))))
                   (EVAL (CAR FLIST2) ALIST)).

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

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (F-NOTP (CAR FLIST1))
                        (LISTP FLIST1)
                        (EQUAL (ARG (CAR FLIST1)) Z)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL Z ALIST)).

    This further simplifies, clearly, to:

          (IMPLIES (AND (NOT (EQUAL X (ARG (CAR FLIST1))))
                        (F-NOTP (CAR FLIST1))
                        (LISTP FLIST1)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL (ARG (CAR FLIST1)) ALIST)).

    Applying the lemmas CAR-CDR-ELIM and ARG-ELIM, replace FLIST1 by
    (CONS Z W) to eliminate (CAR FLIST1) and (CDR FLIST1) and Z by (F-NOT D)
    to eliminate (ARG Z).  We thus obtain the new conjecture:

          (IMPLIES (AND (NOT (EQUAL X D))
                        (NOT (EVAL (MAKE-DISJUNCT (CONS (F-NOT D) W))
                                   ALIST))
                        (NOT (LISTP V)))
                   (EVAL D ALIST)),

    which further simplifies, rewriting with CAR-CONS and CDR-CONS, and
    unfolding the function MAKE-DISJUNCT, to the following two new formulas:

    Case 1.5.2.
            (IMPLIES (AND (NOT (EQUAL X D))
                          (NOT (LISTP W))
                          (NOT (EVAL (F-NOT D) ALIST))
                          (NOT (LISTP V)))
                     (EVAL D ALIST)).

      But this finally simplifies, applying ARG-F-NOT, and expanding EVAL, to:

            T.

    Case 1.5.1.
            (IMPLIES (AND (NOT (EQUAL X D))
                          (LISTP W)
                          (NOT (EVAL (F-OR (F-NOT D) (MAKE-DISJUNCT W))
                                     ALIST))
                          (NOT (LISTP V)))
                     (EVAL D ALIST)).

      However this finally simplifies, applying ARG2-F-OR, ARG1-F-OR, and
      ARG-F-NOT, and opening up the definition of EVAL, to:

            T.

  Case 1.4.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CDR FLIST2)))
                              ALIST)
                        (LISTP FLIST1)
                        (NOT (F-NOTP (CAR FLIST1)))
                        (MEMBER (F-NOT (CAR FLIST1)) FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP (CDR FLIST2)))
                   (EVAL (F-OR (CAR FLIST2)
                               (MAKE-DISJUNCT (CDR FLIST2)))
                         ALIST)).

    But this again simplifies, rewriting with the lemmas EVAL-MAKE-DISJUNCT,
    ARG2-F-OR, and ARG1-F-OR, and opening up the function EVAL, to:

          T.

  Case 1.3.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CDR FLIST2)))
                              ALIST)
                        (LISTP FLIST1)
                        (NOT (F-NOTP (CAR FLIST1)))
                        (MEMBER (F-NOT (CAR FLIST1)) FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP (CDR FLIST2))))
                   (EVAL (CAR FLIST2) ALIST)).

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

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 V))
                              ALIST)
                        (LISTP FLIST1)
                        (NOT (F-NOTP (CAR FLIST1)))
                        (MEMBER (F-NOT (CAR FLIST1))
                                (CONS Z V))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL Z ALIST)),

    which further simplifies, applying CDR-CONS and CAR-CONS, and expanding
    the definition of MEMBER, to:

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 V))
                              ALIST)
                        (LISTP FLIST1)
                        (NOT (F-NOTP (CAR FLIST1)))
                        (EQUAL (F-NOT (CAR FLIST1)) Z)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL Z ALIST)),

    which again simplifies, applying ARG-F-NOT, and unfolding the definition
    of EVAL, to:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT (CAR FLIST1))))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 V))
                              ALIST)
                        (LISTP FLIST1)
                        (NOT (F-NOTP (CAR FLIST1)))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (NOT (EVAL (CAR FLIST1) ALIST))).

    Applying the lemma CAR-CDR-ELIM, replace FLIST1 by (CONS Z W) to eliminate
    (CAR FLIST1) and (CDR FLIST1).  We thus obtain the new formula:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT Z)))
                        (EVAL (MAKE-DISJUNCT (APPEND (CONS Z W) V))
                              ALIST)
                        (NOT (F-NOTP Z))
                        (NOT (EVAL (MAKE-DISJUNCT (CONS Z W))
                                   ALIST))
                        (NOT (LISTP V)))
                   (NOT (EVAL Z ALIST))),

    which further simplifies, applying CDR-CONS and CAR-CONS, and opening up
    the definitions of APPEND and MAKE-DISJUNCT, to the following two new
    conjectures:

    Case 1.3.2.
            (IMPLIES (AND (NOT (EQUAL X (F-NOT Z)))
                          (EVAL (F-OR Z (MAKE-DISJUNCT (APPEND W V)))
                                ALIST)
                          (NOT (F-NOTP Z))
                          (LISTP W)
                          (NOT (EVAL (F-OR Z (MAKE-DISJUNCT W))
                                     ALIST))
                          (NOT (LISTP V)))
                     (NOT (EVAL Z ALIST))).

      However this finally simplifies, rewriting with ARG1-F-OR, and expanding
      the definition of EVAL, to:

            T.

    Case 1.3.1.
            (IMPLIES (AND (NOT (EQUAL X (F-NOT Z)))
                          (NOT (LISTP (APPEND W V)))
                          (NOT (F-NOTP Z))
                          (LISTP W)
                          (NOT (EVAL (F-OR Z (MAKE-DISJUNCT W))
                                     ALIST))
                          (NOT (LISTP V)))
                     (NOT (EVAL Z ALIST))).

      However this finally simplifies, applying ARG1-F-OR, and expanding the
      function EVAL, to:

            T.

  Case 1.2.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CDR FLIST2)))
                              ALIST)
                        (LISTP FLIST1)
                        (F-NOTP (CAR FLIST1))
                        (MEMBER (ARG (CAR FLIST1)) FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (LISTP (CDR FLIST2)))
                   (EVAL (F-OR (CAR FLIST2)
                               (MAKE-DISJUNCT (CDR FLIST2)))
                         ALIST)).

    But this again simplifies, applying EVAL-MAKE-DISJUNCT, ARG2-F-OR, and
    ARG1-F-OR, and unfolding the definition of EVAL, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP FLIST2)
                        (NOT (EQUAL X (CAR FLIST2)))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CDR FLIST2)))
                              ALIST)
                        (LISTP FLIST1)
                        (F-NOTP (CAR FLIST1))
                        (MEMBER (ARG (CAR FLIST1)) FLIST2)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP (CDR FLIST2))))
                   (EVAL (CAR FLIST2) ALIST)).

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

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 V))
                              ALIST)
                        (LISTP FLIST1)
                        (F-NOTP (CAR FLIST1))
                        (MEMBER (ARG (CAR FLIST1)) (CONS Z V))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL Z ALIST)).

    But this further simplifies, appealing to the lemmas CDR-CONS and CAR-CONS,
    and unfolding the function MEMBER, to the formula:

          (IMPLIES (AND (NOT (EQUAL X Z))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 V))
                              ALIST)
                        (LISTP FLIST1)
                        (F-NOTP (CAR FLIST1))
                        (EQUAL (ARG (CAR FLIST1)) Z)
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL Z ALIST)).

    This again simplifies, trivially, to:

          (IMPLIES (AND (NOT (EQUAL X (ARG (CAR FLIST1))))
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 V))
                              ALIST)
                        (LISTP FLIST1)
                        (F-NOTP (CAR FLIST1))
                        (NOT (EVAL (MAKE-DISJUNCT FLIST1) ALIST))
                        (NOT (LISTP V)))
                   (EVAL (ARG (CAR FLIST1)) ALIST)).

    Applying the lemmas CAR-CDR-ELIM and ARG-ELIM, replace FLIST1 by
    (CONS Z W) to eliminate (CAR FLIST1) and (CDR FLIST1) and Z by (F-NOT D)
    to eliminate (ARG Z).  We would thus like to prove the new goal:

          (IMPLIES (AND (NOT (EQUAL X D))
                        (EVAL (MAKE-DISJUNCT (APPEND (CONS (F-NOT D) W) V))
                              ALIST)
                        (NOT (EVAL (MAKE-DISJUNCT (CONS (F-NOT D) W))
                                   ALIST))
                        (NOT (LISTP V)))
                   (EVAL D ALIST)),

    which further simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
    and opening up APPEND and MAKE-DISJUNCT, to three new goals:

    Case 1.1.3.
            (IMPLIES (AND (NOT (EQUAL X D))
                          (NOT (LISTP (APPEND W V)))
                          (EVAL (F-NOT D) ALIST)
                          (LISTP W)
                          (NOT (EVAL (F-OR (F-NOT D) (MAKE-DISJUNCT W))
                                     ALIST))
                          (NOT (LISTP V)))
                     (EVAL D ALIST)),

      which finally simplifies, applying ARG-F-NOT, ARG2-F-OR, and ARG1-F-OR,
      and unfolding the function EVAL, to:

            T.

    Case 1.1.2.
            (IMPLIES (AND (NOT (EQUAL X D))
                          (LISTP (APPEND W V))
                          (EVAL (F-OR (F-NOT D)
                                      (MAKE-DISJUNCT (APPEND W V)))
                                ALIST)
                          (NOT (LISTP W))
                          (NOT (EVAL (F-NOT D) ALIST))
                          (NOT (LISTP V)))
                     (EVAL D ALIST)).

      This finally simplifies, unfolding the function APPEND, to:

            T.

    Case 1.1.1.
            (IMPLIES (AND (NOT (EQUAL X D))
                          (LISTP (APPEND W V))
                          (EVAL (F-OR (F-NOT D)
                                      (MAKE-DISJUNCT (APPEND W V)))
                                ALIST)
                          (LISTP W)
                          (NOT (EVAL (F-OR (F-NOT D) (MAKE-DISJUNCT W))
                                     ALIST))
                          (NOT (LISTP V)))
                     (EVAL D ALIST)),

      which finally simplifies, rewriting with ARG2-F-OR, ARG1-F-OR, and
      ARG-F-NOT, and unfolding EVAL, to:

            T.

Q.E.D.


[ 0.0 0.1 0.3 ]

NEG-LIST-EVAL


(PROVE-LEMMA EVAL-PROP-ATOMP
        (REWRITE)
        (IMPLIES (AND (LISTP FLIST1)
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                   (CONS (CAR FLIST1) FLIST2)))
                            ALIST))
                 (EVAL (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))
                       ALIST))
        ((INDUCT (APPEND FLIST FLIST2))))

This conjecture simplifies, rewriting with the lemmas CAR-CONS and CDR-CONS,
and unfolding the functions APPEND and MAKE-DISJUNCT, to two new conjectures:

Case 2. (IMPLIES (AND (NOT (LISTP FLIST))
                      (LISTP FLIST1)
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                   (CONS (CAR FLIST1) FLIST2)))
                            ALIST)
                      (NOT (LISTP (APPEND (CDR FLIST1) FLIST2))))
                 (EVAL (CAR FLIST1) ALIST)).

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

        (IMPLIES (AND (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                            ALIST)
                      (NOT (LISTP (APPEND X FLIST2))))
                 (EVAL Z ALIST)),

  which we will name *1.

Case 1. (IMPLIES (AND (NOT (LISTP FLIST))
                      (LISTP FLIST1)
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                   (CONS (CAR FLIST1) FLIST2)))
                            ALIST)
                      (LISTP (APPEND (CDR FLIST1) FLIST2)))
                 (EVAL (F-OR (CAR FLIST1)
                             (MAKE-DISJUNCT (APPEND (CDR FLIST1) FLIST2)))
                       ALIST)).

  However this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
  opening up the function EVAL, to:

        (IMPLIES (AND (NOT (LISTP FLIST))
                      (LISTP FLIST1)
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                   (CONS (CAR FLIST1) FLIST2)))
                            ALIST)
                      (LISTP (APPEND (CDR FLIST1) FLIST2))
                      (NOT (EVAL (CAR FLIST1) ALIST)))
                 (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1) FLIST2))
                       ALIST)).

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

        (IMPLIES (AND (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                            ALIST)
                      (LISTP (APPEND X FLIST2))
                      (NOT (EVAL Z ALIST)))
                 (EVAL (MAKE-DISJUNCT (APPEND X FLIST2))
                       ALIST)),

  which we will name *2.


     We will appeal to induction.  There are four plausible inductions.  They
merge into two likely candidate inductions, both of which are unflawed.
However, one of these is more likely than the other.  We will induct according
to the following scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (p (CDR X) FLIST2 ALIST Z FLIST))
                    (p X FLIST2 ALIST Z FLIST))
           (IMPLIES (NOT (LISTP X))
                    (p X FLIST2 ALIST Z FLIST))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme produces four new
goals:

Case 4. (IMPLIES
               (AND (LISTP X)
                    (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR X) (CONS Z FLIST2)))
                               ALIST))
                    (NOT (LISTP FLIST))
                    (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                          ALIST)
                    (LISTP (APPEND X FLIST2))
                    (NOT (EVAL Z ALIST)))
               (EVAL (MAKE-DISJUNCT (APPEND X FLIST2))
                     ALIST)),

  which simplifies, applying CAR-CONS, CDR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  expanding the functions APPEND, MAKE-DISJUNCT, and EVAL, to the new formula:

        (IMPLIES
               (AND (LISTP X)
                    (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR X) (CONS Z FLIST2)))
                               ALIST))
                    (NOT (LISTP FLIST))
                    (EVAL (CAR X) ALIST)
                    (NOT (EVAL Z ALIST))
                    (LISTP (APPEND (CDR X) FLIST2)))
               (EVAL (F-OR (CAR X)
                           (MAKE-DISJUNCT (APPEND (CDR X) FLIST2)))
                     ALIST)),

  which again simplifies, rewriting with ARG1-F-OR, and expanding EVAL, to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (APPEND (CDR X) FLIST2)))
                      (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                            ALIST)
                      (LISTP (APPEND X FLIST2))
                      (NOT (EVAL Z ALIST)))
                 (EVAL (MAKE-DISJUNCT (APPEND X FLIST2))
                       ALIST)).

  This simplifies, applying CAR-CONS, CDR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  expanding the functions APPEND, MAKE-DISJUNCT, and EVAL, to the formula:

        (IMPLIES (AND (LISTP X)
                      (NOT (LISTP (APPEND (CDR X) FLIST2)))
                      (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR X) (CONS Z FLIST2)))
                            ALIST)
                      (NOT (EVAL Z ALIST)))
                 (EVAL (CAR X) ALIST)).

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

        (IMPLIES (AND (NOT (LISTP (APPEND V FLIST2)))
                      (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND V (CONS Z FLIST2)))
                            ALIST)
                      (NOT (EVAL Z ALIST)))
                 (EVAL W ALIST)).

  Eliminate the irrelevant term.  We would thus like to prove the new goal:

        (IMPLIES (AND (NOT (LISTP (APPEND V FLIST2)))
                      (EVAL (MAKE-DISJUNCT (APPEND V (CONS Z FLIST2)))
                            ALIST)
                      (NOT (EVAL Z ALIST)))
                 (EVAL W ALIST)),

  which we will name *2.1.

Case 2. (IMPLIES (AND (LISTP X)
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR X) FLIST2))
                            ALIST)
                      (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                            ALIST)
                      (LISTP (APPEND X FLIST2))
                      (NOT (EVAL Z ALIST)))
                 (EVAL (MAKE-DISJUNCT (APPEND X FLIST2))
                       ALIST)).

  This simplifies, applying CAR-CONS, CDR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  opening up the functions APPEND, MAKE-DISJUNCT, and EVAL, to three new
  conjectures:

  Case 2.3.
          (IMPLIES (AND (LISTP X)
                        (EVAL (MAKE-DISJUNCT (APPEND (CDR X) FLIST2))
                              ALIST)
                        (NOT (LISTP FLIST))
                        (EVAL (CAR X) ALIST)
                        (NOT (EVAL Z ALIST))
                        (LISTP (APPEND (CDR X) FLIST2)))
                   (EVAL (F-OR (CAR X)
                               (MAKE-DISJUNCT (APPEND (CDR X) FLIST2)))
                         ALIST)),

    which again simplifies, appealing to the lemma ARG1-F-OR, and expanding
    the function EVAL, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP X)
                        (EVAL (MAKE-DISJUNCT (APPEND (CDR X) FLIST2))
                              ALIST)
                        (NOT (LISTP FLIST))
                        (EVAL (MAKE-DISJUNCT (APPEND (CDR X) (CONS Z FLIST2)))
                              ALIST)
                        (NOT (EVAL Z ALIST))
                        (NOT (LISTP (APPEND (CDR X) FLIST2))))
                   (EVAL (CAR X) ALIST)),

    which again simplifies, unfolding the functions MAKE-DISJUNCT, F-ORP,
    F-NOTP, and EVAL, to:

          (IMPLIES (AND (LISTP X)
                        (MEMBER NIL ALIST)
                        (NOT (LISTP FLIST))
                        (EVAL (MAKE-DISJUNCT (APPEND (CDR X) (CONS Z FLIST2)))
                              ALIST)
                        (NOT (EVAL Z ALIST))
                        (NOT (LISTP (APPEND (CDR X) FLIST2))))
                   (EVAL (CAR X) ALIST)).

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

          (IMPLIES (AND (MEMBER NIL ALIST)
                        (NOT (LISTP FLIST))
                        (EVAL (MAKE-DISJUNCT (APPEND V (CONS Z FLIST2)))
                              ALIST)
                        (NOT (EVAL Z ALIST))
                        (NOT (LISTP (APPEND V FLIST2))))
                   (EVAL W ALIST)).

    Eliminate the irrelevant term.  This produces:

          (IMPLIES (AND (MEMBER NIL ALIST)
                        (EVAL (MAKE-DISJUNCT (APPEND V (CONS Z FLIST2)))
                              ALIST)
                        (NOT (EVAL Z ALIST))
                        (NOT (LISTP (APPEND V FLIST2))))
                   (EVAL W ALIST)),

    which we will name *2.2.

  Case 2.1.
          (IMPLIES (AND (LISTP X)
                        (EVAL (MAKE-DISJUNCT (APPEND (CDR X) FLIST2))
                              ALIST)
                        (NOT (LISTP FLIST))
                        (EVAL (MAKE-DISJUNCT (APPEND (CDR X) (CONS Z FLIST2)))
                              ALIST)
                        (NOT (EVAL Z ALIST))
                        (LISTP (APPEND (CDR X) FLIST2)))
                   (EVAL (F-OR (CAR X)
                               (MAKE-DISJUNCT (APPEND (CDR X) FLIST2)))
                         ALIST)).

    However this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    opening up the function EVAL, to:

          T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                            ALIST)
                      (LISTP (APPEND X FLIST2))
                      (NOT (EVAL Z ALIST)))
                 (EVAL (MAKE-DISJUNCT (APPEND X FLIST2))
                       ALIST)).

  This simplifies, rewriting with the lemmas CAR-CONS and CDR-CONS, and
  unfolding the functions APPEND and MAKE-DISJUNCT, to:

        (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP FLIST))
                      (LISTP FLIST2)
                      (EVAL (F-OR Z (MAKE-DISJUNCT FLIST2))
                            ALIST)
                      (NOT (EVAL Z ALIST)))
                 (EVAL (MAKE-DISJUNCT FLIST2) ALIST)),

  which again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
  unfolding the definition of EVAL, to:

        T.


     So next consider:

      (IMPLIES (AND (MEMBER NIL ALIST)
                    (EVAL (MAKE-DISJUNCT (APPEND V (CONS Z FLIST2)))
                          ALIST)
                    (NOT (EVAL Z ALIST))
                    (NOT (LISTP (APPEND V FLIST2))))
               (EVAL W ALIST)),

named *2.2 above.  This conjecture is subsumed by formula *2.1 above.


     So we now return to:

      (IMPLIES (AND (NOT (LISTP (APPEND V FLIST2)))
                    (EVAL (MAKE-DISJUNCT (APPEND V (CONS Z FLIST2)))
                          ALIST)
                    (NOT (EVAL Z ALIST)))
               (EVAL W ALIST)),

named *2.1 above.  But this conjecture is subsumed by the subgoal we named *1
above.


     That finishes the proof of *2.


     So next consider:

      (IMPLIES (AND (NOT (LISTP FLIST))
                    (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                          ALIST)
                    (NOT (LISTP (APPEND X FLIST2))))
               (EVAL Z ALIST)),

which we named *1 above.  We will appeal to induction.  The recursive terms in
the conjecture suggest three inductions.  They merge into two likely candidate
inductions, both of which are unflawed.  However, one of these is more likely
than the other.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X)
                         (p Z ALIST (CDR X) FLIST2 FLIST))
                    (p Z ALIST X FLIST2 FLIST))
           (IMPLIES (NOT (LISTP X))
                    (p Z ALIST X FLIST2 FLIST))).
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 leads to the following three new
goals:

Case 3. (IMPLIES
               (AND (LISTP X)
                    (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR X) (CONS Z FLIST2)))
                               ALIST))
                    (NOT (LISTP FLIST))
                    (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                          ALIST)
                    (NOT (LISTP (APPEND X FLIST2))))
               (EVAL Z ALIST)).

  This simplifies, applying the lemmas CAR-CONS, CDR-CONS, ARG2-F-OR, and
  ARG1-F-OR, and expanding the definitions of APPEND, MAKE-DISJUNCT, and EVAL,
  to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (LISTP (APPEND (CDR X) FLIST2))
                      (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                            ALIST)
                      (NOT (LISTP (APPEND X FLIST2))))
                 (EVAL Z ALIST)).

  This simplifies, applying CAR-CONS, CDR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  expanding the functions APPEND, MAKE-DISJUNCT, and EVAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (LISTP FLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND X (CONS Z FLIST2)))
                            ALIST)
                      (NOT (LISTP (APPEND X FLIST2))))
                 (EVAL Z ALIST)),

  which simplifies, rewriting with the lemmas CAR-CONS and CDR-CONS, and
  opening up the functions APPEND and MAKE-DISJUNCT, to:

        T.


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


[ 0.0 0.0 0.1 ]

EVAL-PROP-ATOMP


(PROVE-LEMMA EVAL-PROP-ATOMP1
        (REWRITE)
        (IMPLIES (AND (LISTP FLIST1)
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                   (CONS (CAR FLIST1) FLIST2)))
                            ALIST)
                      (EQUAL CONCL
                             (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))))
                 (EVAL CONCL ALIST))
        ((DISABLE APPEND)))

WARNING:  Note that EVAL-PROP-ATOMP1 contains the free variables FLIST2 and
FLIST1 which will be chosen by instantiating the hypotheses (LISTP FLIST1) and:
      (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                   (CONS (CAR FLIST1) FLIST2)))
            ALIST).



This formula simplifies, appealing to the lemma EVAL-PROP-ATOMP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EVAL-PROP-ATOMP1


(PROVE-LEMMA NEG-LIST-EVAL1
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST1)
                           (NEG-LIST (CAR FLIST1) FLIST2)
                           (EQUAL CONCL
                                  (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))))
                      (EVAL CONCL ALIST)))

WARNING:  Note that NEG-LIST-EVAL1 contains the free variables FLIST2 and
FLIST1 which will be chosen by instantiating the hypotheses (LISTP FLIST1) and:
      (NEG-LIST (CAR FLIST1) FLIST2).



This conjecture simplifies, applying NEG-LIST-EVAL, and opening up the
definition of NEG-LIST, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NEG-LIST-EVAL1


(PROVE-LEMMA TAUT-EVAL
             (REWRITE)
             (IMPLIES (TAUTOLOGYP1 FLIST AUXLIST)
                      (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                            ALIST))
             ((DISABLE EVAL-MAKE-DISJUNCT NEG-LIST)
              (INDUCT (TAUTOLOGYP1 FLIST AUXLIST))))

This formula can be simplified, using the abbreviations DBLE-NEG-TYPE,
NOR-TYPE, IMPLIES, NOT, OR, and AND, to the following five new goals:

Case 5. (IMPLIES
         (AND
          (LISTP FLIST)
          (F-ORP (CAR FLIST))
          (IMPLIES
           (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                              (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                        AUXLIST)
           (EVAL
            (MAKE-DISJUNCT (APPEND (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST))
            ALIST))
          (TAUTOLOGYP1 FLIST AUXLIST))
         (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
               ALIST)).

  This simplifies, rewriting with the lemmas CDR-CONS, CAR-CONS, ARG2-F-OR,
  and ARG1-F-OR, and opening up the functions APPEND, MAKE-DISJUNCT, EVAL,
  IMPLIES, and TAUTOLOGYP1, to the following three new goals:

  Case 5.3.
          (IMPLIES
                 (AND (LISTP FLIST)
                      (F-ORP (CAR FLIST))
                      (EVAL (ARG1 (CAR FLIST)) ALIST)
                      (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)
                      (NOT (LISTP (APPEND (CDR FLIST) AUXLIST))))
                 (EVAL (CAR FLIST) ALIST)).

    However this again simplifies, unfolding EVAL, to:

          T.

  Case 5.2.
          (IMPLIES
                 (AND (LISTP FLIST)
                      (F-ORP (CAR FLIST))
                      (EVAL (ARG1 (CAR FLIST)) ALIST)
                      (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)
                      (LISTP (APPEND (CDR FLIST) AUXLIST)))
                 (EVAL (F-OR (CAR FLIST)
                             (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                       ALIST)),

    which again simplifies, appealing to the lemmas ARG2-F-OR and ARG1-F-OR,
    and expanding the definition of EVAL, to:

          T.

  Case 5.1.
          (IMPLIES
                 (AND (LISTP FLIST)
                      (F-ORP (CAR FLIST))
                      (LISTP (APPEND (CDR FLIST) AUXLIST))
                      (EVAL (F-OR (ARG2 (CAR FLIST))
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            ALIST)
                      (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)
                      (NOT (EVAL (ARG1 (CAR FLIST)) ALIST))
                      (NOT (EVAL (ARG2 (CAR FLIST)) ALIST)))
                 (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       ALIST)),

    which again simplifies, appealing to the lemmas ARG2-F-OR and ARG1-F-OR,
    and opening up the function EVAL, to:

          T.

Case 4. (IMPLIES
         (AND
          (LISTP FLIST)
          (NOT (F-ORP (CAR FLIST)))
          (F-NOTP (CAR FLIST))
          (F-ORP (ARG (CAR FLIST)))
          (IMPLIES
            (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                               (CDR FLIST))
                         AUXLIST)
            (EVAL (MAKE-DISJUNCT (APPEND (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))
                  ALIST))
          (IMPLIES
            (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                               (CDR FLIST))
                         AUXLIST)
            (EVAL (MAKE-DISJUNCT (APPEND (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))
                  ALIST))
          (TAUTOLOGYP1 FLIST AUXLIST))
         (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
               ALIST)),

  which simplifies, applying CDR-CONS, CAR-CONS, ARG-F-NOT, ARG2-F-OR, and
  ARG1-F-OR, and expanding the functions APPEND, MAKE-DISJUNCT, IMPLIES,
  NOR-TYPE, TAUTOLOGYP1, and EVAL, to the following two new goals:

  Case 4.2.
          (IMPLIES (AND (LISTP FLIST)
                        (F-NOTP (CAR FLIST))
                        (F-ORP (ARG (CAR FLIST)))
                        (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                        (EVAL (F-NOT (ARG2 (ARG (CAR FLIST))))
                              ALIST)
                        (NOT (EVAL (ARG1 (ARG (CAR FLIST))) ALIST))
                        (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                           (CDR FLIST))
                                     AUXLIST)
                        (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                           (CDR FLIST))
                                     AUXLIST))
                   (NOT (EVAL (ARG2 (ARG (CAR FLIST)))
                              ALIST))).

    However this again simplifies, rewriting with ARG-F-NOT, and expanding the
    definition of EVAL, to:

          T.

  Case 4.1.
          (IMPLIES
                 (AND (LISTP FLIST)
                      (F-NOTP (CAR FLIST))
                      (F-ORP (ARG (CAR FLIST)))
                      (LISTP (APPEND (CDR FLIST) AUXLIST))
                      (EVAL (F-OR (F-NOT (ARG2 (ARG (CAR FLIST))))
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            ALIST)
                      (NOT (EVAL (ARG1 (ARG (CAR FLIST))) ALIST))
                      (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                         (CDR FLIST))
                                   AUXLIST)
                      (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                         (CDR FLIST))
                                   AUXLIST)
                      (EVAL (ARG2 (ARG (CAR FLIST))) ALIST))
                 (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       ALIST)).

    But this again simplifies, applying ARG2-F-OR, ARG1-F-OR, and ARG-F-NOT,
    and expanding the function EVAL, to:

          T.

Case 3. (IMPLIES
         (AND
            (LISTP FLIST)
            (NOT (F-ORP (CAR FLIST)))
            (NOT (NOR-TYPE (CAR FLIST)))
            (F-NOTP (CAR FLIST))
            (F-NOTP (ARG (CAR FLIST)))
            (IMPLIES (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                        (CDR FLIST))
                                  AUXLIST)
                     (EVAL (MAKE-DISJUNCT (APPEND (CONS (ARG (ARG (CAR FLIST)))
                                                        (CDR FLIST))
                                                  AUXLIST))
                           ALIST))
            (TAUTOLOGYP1 FLIST AUXLIST))
         (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
               ALIST)).

  This simplifies, applying CDR-CONS, CAR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  expanding the definitions of NOR-TYPE, APPEND, MAKE-DISJUNCT, IMPLIES,
  DBLE-NEG-TYPE, TAUTOLOGYP1, and EVAL, to:

        (IMPLIES (AND (LISTP FLIST)
                      (F-NOTP (CAR FLIST))
                      (F-NOTP (ARG (CAR FLIST)))
                      (LISTP (APPEND (CDR FLIST) AUXLIST))
                      (EVAL (F-OR (ARG (ARG (CAR FLIST)))
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            ALIST)
                      (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                         (CDR FLIST))
                                   AUXLIST)
                      (NOT (EVAL (ARG (ARG (CAR FLIST))) ALIST)))
                 (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       ALIST)).

  This again simplifies, appealing to the lemmas ARG2-F-OR and ARG1-F-OR, and
  unfolding EVAL, to:

        T.

Case 2. (IMPLIES
         (AND
             (LISTP FLIST)
             (NOT (F-ORP (CAR FLIST)))
             (NOT (NOR-TYPE (CAR FLIST)))
             (NOT (DBLE-NEG-TYPE (CAR FLIST)))
             (IMPLIES (TAUTOLOGYP1 (CDR FLIST)
                                   (CONS (CAR FLIST) AUXLIST))
                      (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST)
                                                   (CONS (CAR FLIST) AUXLIST)))
                            ALIST))
             (TAUTOLOGYP1 FLIST AUXLIST))
         (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
               ALIST)),

  which simplifies, applying the lemmas CAR-CONS, CDR-CONS, NEG-LIST-EVAL1,
  and EVAL-PROP-ATOMP1, and opening up NOR-TYPE, DBLE-NEG-TYPE, IMPLIES,
  TAUTOLOGYP1, APPEND, and MAKE-DISJUNCT, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP FLIST))
                      (TAUTOLOGYP1 FLIST AUXLIST))
                 (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                       ALIST)),

  which simplifies, opening up TAUTOLOGYP1, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

TAUT-EVAL


(DEFN FALSIFY
      (LIST)
      (IF (NLISTP LIST)
          NIL
          (IF (F-NOTP (CAR LIST))
              (CONS (ARG (CAR LIST))
                    (FALSIFY (CDR LIST)))
              (FALSIFY (CDR LIST)))))

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




[ 0.0 0.0 0.0 ]

FALSIFY


(DEFN FALSIFY-TAUT
      (FLIST AUXLIST)
      (IF (LISTP FLIST)
          (IF (F-ORP (CAR FLIST))
              (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                  (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                            AUXLIST)
              (IF (NOR-TYPE (CAR FLIST))
                  (IF (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                          (CDR FLIST))
                                    AUXLIST)
                      (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                          (CDR FLIST))
                                    AUXLIST)
                      (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                          (CDR FLIST))
                                    AUXLIST))
                  (IF (DBLE-NEG-TYPE (CAR FLIST))
                      (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                          (CDR FLIST))
                                    AUXLIST)
                      (IF (NEG-LIST (CAR FLIST) AUXLIST)
                          F
                          (FALSIFY-TAUT (CDR FLIST)
                                        (CONS (CAR FLIST) AUXLIST))))))
          (FALSIFY AUXLIST))
      ((LESSP (LIST-COUNT FLIST))))

     Linear arithmetic and the lemmas F-ORP-LIST-COUNT, NOR-TYPE-LIST-COUNT2,
NOR-TYPE-LIST-COUNT1, DBLE-NEG-LIST-COUNT, and LESSP-LIST-COUNT establish that
the measure (LIST-COUNT FLIST) decreases according to the well-founded
relation LESSP in each recursive call.  Hence, FALSIFY-TAUT is accepted under
the principle of definition.  From the definition we can conclude that:
      (OR (FALSEP (FALSIFY-TAUT FLIST AUXLIST))
          (LITATOM (FALSIFY-TAUT FLIST AUXLIST))
          (LISTP (FALSIFY-TAUT FLIST AUXLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

FALSIFY-TAUT


(PROVE-LEMMA NOT-FALSIFY-TAUT
             (REWRITE)
             (EQUAL (TAUTOLOGYP1 FLIST AUXLIST)
                    (NOT (FALSIFY-TAUT FLIST AUXLIST)))
             ((INDUCT (TAUTOLOGYP1 FLIST AUXLIST))))

This formula can be simplified, using the abbreviations DBLE-NEG-TYPE,
NOR-TYPE, NOT, OR, and AND, to the following five new goals:

Case 5. (IMPLIES
         (AND
          (LISTP FLIST)
          (F-ORP (CAR FLIST))
          (EQUAL
                (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                   (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                             AUXLIST)
                (NOT (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST))))
         (EQUAL (TAUTOLOGYP1 FLIST AUXLIST)
                (NOT (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, unfolding the functions NOT, TAUTOLOGYP1, FALSIFY-TAUT, and
  EQUAL, to:

        T.

Case 4. (IMPLIES
          (AND (LISTP FLIST)
               (NOT (F-ORP (CAR FLIST)))
               (F-NOTP (CAR FLIST))
               (F-ORP (ARG (CAR FLIST)))
               (EQUAL (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                         (CDR FLIST))
                                   AUXLIST)
                      (NOT (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
               (EQUAL (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                         (CDR FLIST))
                                   AUXLIST)
                      (NOT (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))))
          (EQUAL (TAUTOLOGYP1 FLIST AUXLIST)
                 (NOT (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, unfolding the functions NOT, NOR-TYPE, TAUTOLOGYP1,
  FALSIFY-TAUT, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (LISTP FLIST)
                      (NOT (F-ORP (CAR FLIST)))
                      (NOT (NOR-TYPE (CAR FLIST)))
                      (F-NOTP (CAR FLIST))
                      (F-NOTP (ARG (CAR FLIST)))
                      (EQUAL (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                                (CDR FLIST))
                                          AUXLIST)
                             (NOT (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                                      (CDR FLIST))
                                                AUXLIST))))
                 (EQUAL (TAUTOLOGYP1 FLIST AUXLIST)
                        (NOT (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, unfolding the definitions of NOR-TYPE, NOT, DBLE-NEG-TYPE,
  TAUTOLOGYP1, FALSIFY-TAUT, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (LISTP FLIST)
                      (NOT (F-ORP (CAR FLIST)))
                      (NOT (NOR-TYPE (CAR FLIST)))
                      (NOT (DBLE-NEG-TYPE (CAR FLIST)))
                      (EQUAL (TAUTOLOGYP1 (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))
                             (NOT (FALSIFY-TAUT (CDR FLIST)
                                                (CONS (CAR FLIST) AUXLIST)))))
                 (EQUAL (TAUTOLOGYP1 FLIST AUXLIST)
                        (NOT (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, expanding the functions NOR-TYPE, DBLE-NEG-TYPE, NOT,
  NEG-LIST, TAUTOLOGYP1, FALSIFY-TAUT, and EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP FLIST))
                 (EQUAL (TAUTOLOGYP1 FLIST AUXLIST)
                        (NOT (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, unfolding the functions TAUTOLOGYP1, FALSIFY-TAUT, NOT, and
  EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NOT-FALSIFY-TAUT


(PROVE-LEMMA EVAL-MEMBER
             (REWRITE)
             (IMPLIES (AND (NOT (F-NOTP EXP))
                           (NOT (F-ORP EXP))
                           (MEMBER EXP ALIST))
                      (EVAL EXP ALIST)))

This formula simplifies, opening up EVAL, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EVAL-MEMBER


(DEFN PROP-ATOMP-LIST
      (FLIST)
      (IF (LISTP FLIST)
          (AND (NOT (F-ORP (CAR FLIST)))
               (NOT (NOR-TYPE (CAR FLIST)))
               (NOT (DBLE-NEG-TYPE (CAR FLIST)))
               (NOT (NEG-LIST (CAR FLIST) (CDR FLIST)))
               (PROP-ATOMP-LIST (CDR FLIST)))
          T))

     Linear arithmetic and the lemma CDR-LESSP can be used to prove that the
measure (COUNT FLIST) decreases according to the well-founded relation LESSP
in each recursive call.  Hence, PROP-ATOMP-LIST is accepted under the
principle of definition.  From the definition we can conclude that:
      (OR (FALSEP (PROP-ATOMP-LIST FLIST))
          (TRUEP (PROP-ATOMP-LIST FLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

PROP-ATOMP-LIST


(PROVE-LEMMA MEMBER-FALSIFY
             (REWRITE)
             (EQUAL (MEMBER EXP (FALSIFY LIST))
                    (MEMBER (F-NOT EXP) LIST)))


     Name the conjecture *1.


     We will appeal to induction.  The recursive terms in the conjecture
suggest two inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP LIST) (p EXP LIST))
           (IMPLIES (AND (NOT (NLISTP LIST))
                         (F-NOTP (CAR LIST))
                         (p EXP (CDR LIST)))
                    (p EXP LIST))
           (IMPLIES (AND (NOT (NLISTP LIST))
                         (NOT (F-NOTP (CAR LIST)))
                         (p EXP (CDR LIST)))
                    (p EXP LIST))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP inform us that the measure (COUNT LIST) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces the following three new formulas:

Case 3. (IMPLIES (NLISTP LIST)
                 (EQUAL (MEMBER EXP (FALSIFY LIST))
                        (MEMBER (F-NOT EXP) LIST))).

  This simplifies, expanding the definitions of NLISTP, FALSIFY, LISTP, MEMBER,
  and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP LIST))
                      (F-NOTP (CAR LIST))
                      (EQUAL (MEMBER EXP (FALSIFY (CDR LIST)))
                             (MEMBER (F-NOT EXP) (CDR LIST))))
                 (EQUAL (MEMBER EXP (FALSIFY LIST))
                        (MEMBER (F-NOT EXP) LIST))).

  This simplifies, applying CDR-CONS, CAR-CONS, and ARG-F-NOT, and expanding
  the definitions of NLISTP, FALSIFY, and MEMBER, to two new goals:

  Case 2.2.
          (IMPLIES (AND (LISTP LIST)
                        (F-NOTP (CAR LIST))
                        (EQUAL (MEMBER EXP (FALSIFY (CDR LIST)))
                               (MEMBER (F-NOT EXP) (CDR LIST)))
                        (NOT (EQUAL (F-NOT EXP) (CAR LIST)))
                        (EQUAL EXP (ARG (CAR LIST))))
                   (EQUAL T
                          (MEMBER EXP (FALSIFY (CDR LIST))))),

    which again simplifies, appealing to the lemma F-NOT-ARG, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP LIST)
                        (F-NOTP (CAR LIST))
                        (EQUAL (MEMBER EXP (FALSIFY (CDR LIST)))
                               (MEMBER (F-NOT EXP) (CDR LIST)))
                        (EQUAL (F-NOT EXP) (CAR LIST))
                        (NOT (EQUAL EXP (ARG (CAR LIST)))))
                   (EQUAL (MEMBER EXP (FALSIFY (CDR LIST)))
                          T)),

    which again simplifies, trivially, to:

          (IMPLIES (AND (LISTP LIST)
                        (NOT (MEMBER (F-NOT EXP) (CDR LIST)))
                        (EQUAL (F-NOT EXP) (CAR LIST))
                        (NOT (EQUAL EXP (ARG (CAR LIST)))))
                   (MEMBER EXP (FALSIFY (CDR LIST)))),

    which further simplifies, obviously, to the new formula:

          (IMPLIES (AND (LISTP LIST)
                        (NOT (MEMBER (CAR LIST) (CDR LIST)))
                        (EQUAL (F-NOT EXP) (CAR LIST))
                        (NOT (EQUAL EXP (ARG (CAR LIST)))))
                   (MEMBER EXP (FALSIFY (CDR LIST)))).

    Applying the lemmas CAR-CDR-ELIM and ARG-ELIM, replace LIST by (CONS X Z)
    to eliminate (CAR LIST) and (CDR LIST) and X by (F-NOT V) to eliminate
    (ARG X).  We would thus like to prove the following two new conjectures:

    Case 2.1.2.
            (IMPLIES (AND (NOT (F-NOTP X))
                          (NOT (MEMBER X Z))
                          (EQUAL (F-NOT EXP) X)
                          (NOT (EQUAL EXP (ARG X))))
                     (MEMBER EXP (FALSIFY Z))).

      This further simplifies, obviously, to:

            T.

    Case 2.1.1.
            (IMPLIES (AND (NOT (MEMBER (F-NOT V) Z))
                          (EQUAL (F-NOT EXP) (F-NOT V))
                          (NOT (EQUAL EXP V)))
                     (MEMBER EXP (FALSIFY Z))).

      This further simplifies, appealing to the lemma ARG-F-NOT, to:

            T.

Case 1. (IMPLIES (AND (NOT (NLISTP LIST))
                      (NOT (F-NOTP (CAR LIST)))
                      (EQUAL (MEMBER EXP (FALSIFY (CDR LIST)))
                             (MEMBER (F-NOT EXP) (CDR LIST))))
                 (EQUAL (MEMBER EXP (FALSIFY LIST))
                        (MEMBER (F-NOT EXP) LIST))),

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

        T.


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


[ 0.0 0.0 0.0 ]

MEMBER-FALSIFY


(PROVE-LEMMA ALIST-CONS-EVAL2
             (REWRITE)
             (IMPLIES (AND (NOT (MEMBER X FLIST))
                           (LISTP FLIST)
                           (PROP-ATOMP-LIST FLIST)
                           (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                      (NOT (EVAL (MAKE-DISJUNCT FLIST)
                                 (CONS X ALIST)))))


     Name the conjecture *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 (NLISTP FLIST)
                    (p FLIST X ALIST))
           (IMPLIES (AND (NOT (NLISTP FLIST))
                         (EQUAL X (CAR FLIST)))
                    (p FLIST X ALIST))
           (IMPLIES (AND (NOT (NLISTP FLIST))
                         (NOT (EQUAL X (CAR FLIST)))
                         (p (CDR FLIST) X ALIST))
                    (p FLIST X ALIST))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT FLIST) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme leads to seven new formulas:

Case 7. (IMPLIES (AND (NLISTP FLIST)
                      (NOT (MEMBER X FLIST))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST)
                      (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (CONS X ALIST)))),

  which simplifies, unfolding the function NLISTP, to:

        T.

Case 6. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (EQUAL X (CAR FLIST))
                      (NOT (MEMBER X FLIST))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST)
                      (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (CONS X ALIST)))),

  which simplifies, expanding NLISTP and MEMBER, to:

        T.

Case 5. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (EQUAL X (CAR FLIST)))
                      (MEMBER X (CDR FLIST))
                      (NOT (MEMBER X FLIST))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST)
                      (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (CONS X ALIST)))),

  which simplifies, opening up NLISTP and MEMBER, to:

        T.

Case 4. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (EQUAL X (CAR FLIST)))
                      (NOT (LISTP (CDR FLIST)))
                      (NOT (MEMBER X FLIST))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST)
                      (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (CONS X ALIST)))),

  which simplifies, rewriting with the lemmas CAR-CONS and CDR-CONS, and
  expanding NLISTP, MEMBER, PROP-ATOMP-LIST, NOR-TYPE, DBLE-NEG-TYPE, NEG-LIST,
  MAKE-DISJUNCT, and EVAL, to:

        (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                      (NOT (LISTP (CDR FLIST)))
                      (NOT (MEMBER X (CDR FLIST)))
                      (LISTP FLIST)
                      (NOT (F-ORP (CAR FLIST)))
                      (NOT (F-ORP (ARG (CAR FLIST))))
                      (NOT (F-NOTP (ARG (CAR FLIST))))
                      (PROP-ATOMP-LIST (CDR FLIST))
                      (NOT (EVAL (CAR FLIST) ALIST)))
                 (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

  However this further simplifies, opening up the functions MEMBER and
  PROP-ATOMP-LIST, to:

        (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                      (NOT (LISTP (CDR FLIST)))
                      (LISTP FLIST)
                      (NOT (F-ORP (CAR FLIST)))
                      (NOT (F-ORP (ARG (CAR FLIST))))
                      (NOT (F-NOTP (ARG (CAR FLIST))))
                      (NOT (EVAL (CAR FLIST) ALIST)))
                 (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

  Appealing to the lemmas CAR-CDR-ELIM and ARG-ELIM, we now replace FLIST by
  (CONS Z V) to eliminate (CAR FLIST) and (CDR FLIST) and Z by (F-NOT W) to
  eliminate (ARG Z).  This generates two new goals:

  Case 4.2.
          (IMPLIES (AND (NOT (F-NOTP Z))
                        (NOT (EQUAL X Z))
                        (NOT (LISTP V))
                        (NOT (F-ORP Z))
                        (NOT (F-ORP (ARG Z)))
                        (NOT (F-NOTP (ARG Z)))
                        (NOT (EVAL Z ALIST)))
                   (NOT (EVAL Z (CONS X ALIST)))),

    which further simplifies, rewriting with ARG-NF-NOTP, CAR-CONS, and
    CDR-CONS, and unfolding the functions F-ORP, F-NOTP, EVAL, and MEMBER, to:

          T.

  Case 4.1.
          (IMPLIES (AND (NOT (EQUAL X (F-NOT W)))
                        (NOT (LISTP V))
                        (NOT (F-ORP W))
                        (NOT (F-NOTP W))
                        (NOT (EVAL (F-NOT W) ALIST)))
                   (NOT (EVAL (F-NOT W) (CONS X ALIST)))).

    This further simplifies, rewriting with the lemmas ARG-F-NOT, EVAL-MEMBER,
    CDR-CONS, and CAR-CONS, and unfolding EVAL and MEMBER, to:

          T.

Case 3. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (EQUAL X (CAR FLIST)))
                      (NOT (PROP-ATOMP-LIST (CDR FLIST)))
                      (NOT (MEMBER X FLIST))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST)
                      (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (CONS X ALIST)))),

  which simplifies, expanding the definitions of NLISTP, MEMBER,
  PROP-ATOMP-LIST, NOR-TYPE, DBLE-NEG-TYPE, and NEG-LIST, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (EQUAL X (CAR FLIST)))
                      (EVAL (MAKE-DISJUNCT (CDR FLIST))
                            ALIST)
                      (NOT (MEMBER X FLIST))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST)
                      (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (CONS X ALIST)))),

  which simplifies, applying CAR-CONS, CDR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  unfolding NLISTP, MEMBER, PROP-ATOMP-LIST, NOR-TYPE, DBLE-NEG-TYPE, NEG-LIST,
  MAKE-DISJUNCT, and EVAL, to the following six new goals:

  Case 2.6.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (MEMBER (CAR FLIST) ALIST))).

    But this again simplifies, rewriting with EVAL-MEMBER, and expanding the
    definition of MEMBER, to:

          T.

  Case 2.5.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST))
                        (NOT (EVAL (F-OR (CAR FLIST)
                                         (MAKE-DISJUNCT (CDR FLIST)))
                                   ALIST)))
                   (NOT (MEMBER (CAR FLIST) ALIST))).

    This again simplifies, applying EVAL-MEMBER and ARG1-F-OR, and opening up
    the definition of EVAL, to:

          T.

  Case 2.4.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST))
                        (NOT (EVAL (F-OR (CAR FLIST)
                                         (MAKE-DISJUNCT (CDR FLIST)))
                                   ALIST)))
                   (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              (CONS X ALIST)))).

    This again simplifies, rewriting with the lemmas ARG2-F-OR and ARG1-F-OR,
    and expanding EVAL, to:

          T.

  Case 2.3.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))),

    which again simplifies, expanding MEMBER, to:

          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    However this further simplifies, expanding the functions MAKE-DISJUNCT,
    F-ORP, F-NOTP, EVAL, MEMBER, and PROP-ATOMP-LIST, to:

          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (MEMBER NIL ALIST)
                        (LISTP FLIST)
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    Appealing to the lemmas CAR-CDR-ELIM and ARG-ELIM, we now replace FLIST by
    (CONS Z V) to eliminate (CAR FLIST) and (CDR FLIST) and Z by (F-NOT W) to
    eliminate (ARG Z).  The result is the goal:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT W)))
                        (MEMBER NIL ALIST)
                        (NOT (F-ORP W))
                        (NOT (F-NOTP W))
                        (NOT (LISTP V))
                        (NOT (EVAL (F-NOT W) ALIST)))
                   (NOT (EVAL (F-NOT W) (CONS X ALIST)))).

    However this further simplifies, rewriting with ARG-F-NOT, EVAL-MEMBER,
    CDR-CONS, and CAR-CONS, and opening up the definitions of EVAL and MEMBER,
    to:

          T.

  Case 2.2.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST))
                        (NOT (EVAL (F-OR (CAR FLIST)
                                         (MAKE-DISJUNCT (CDR FLIST)))
                                   ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    But this again simplifies, rewriting with the lemmas ARG2-F-OR and
    ARG1-F-OR, and unfolding the function EVAL, to:

          T.

  Case 2.1.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              ALIST)
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST))
                        (NOT (EVAL (F-OR (CAR FLIST)
                                         (MAKE-DISJUNCT (CDR FLIST)))
                                   ALIST)))
                   (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                              (CONS X ALIST)))),

    which again simplifies, applying ARG2-F-OR and ARG1-F-OR, and expanding
    the function EVAL, to:

          T.

Case 1. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (EQUAL X (CAR FLIST)))
                      (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                 (CONS X ALIST)))
                      (NOT (MEMBER X FLIST))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST)
                      (NOT (EVAL (MAKE-DISJUNCT FLIST) ALIST)))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (CONS X ALIST)))).

  This simplifies, applying CAR-CONS, CDR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  unfolding the functions NLISTP, MEMBER, PROP-ATOMP-LIST, NOR-TYPE,
  DBLE-NEG-TYPE, NEG-LIST, MAKE-DISJUNCT, and EVAL, to four new conjectures:

  Case 1.4.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (CONS X ALIST)))
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (MEMBER (CAR FLIST) ALIST))),

    which again simplifies, applying EVAL-MEMBER, and opening up the function
    MEMBER, to:

          T.

  Case 1.3.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (CONS X ALIST)))
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST))
                        (NOT (EVAL (F-OR (CAR FLIST)
                                         (MAKE-DISJUNCT (CDR FLIST)))
                                   ALIST)))
                   (NOT (MEMBER (CAR FLIST) ALIST))).

    This again simplifies, rewriting with EVAL-MEMBER and ARG1-F-OR, and
    expanding the function EVAL, to:

          T.

  Case 1.2.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (CONS X ALIST)))
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    However this again simplifies, expanding MEMBER, to:

          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (CONS X ALIST)))
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    This further simplifies, rewriting with CAR-CONS and CDR-CONS, and
    expanding the definitions of MAKE-DISJUNCT, MEMBER, F-ORP, F-NOTP, EVAL,
    and PROP-ATOMP-LIST, to:

          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (NOT (EQUAL NIL X))
                        (NOT (MEMBER NIL ALIST))
                        (LISTP FLIST)
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (LISTP (CDR FLIST)))
                        (NOT (EVAL (CAR FLIST) ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    Applying the lemmas CAR-CDR-ELIM and ARG-ELIM, replace FLIST by (CONS Z V)
    to eliminate (CAR FLIST) and (CDR FLIST) and Z by (F-NOT W) to eliminate
    (ARG Z).  We would thus like to prove the new goal:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT W)))
                        (NOT (EQUAL NIL X))
                        (NOT (MEMBER NIL ALIST))
                        (NOT (F-ORP W))
                        (NOT (F-NOTP W))
                        (NOT (LISTP V))
                        (NOT (EVAL (F-NOT W) ALIST)))
                   (NOT (EVAL (F-NOT W) (CONS X ALIST)))),

    which further simplifies, applying ARG-F-NOT, EVAL-MEMBER, CDR-CONS, and
    CAR-CONS, and opening up EVAL and MEMBER, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (CONS X ALIST)))
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST))
                        (NOT (EVAL (F-OR (CAR FLIST)
                                         (MAKE-DISJUNCT (CDR FLIST)))
                                   ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    But this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    unfolding the function EVAL, to:

          (IMPLIES (AND (NOT (EQUAL X (CAR FLIST)))
                        (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (CONS X ALIST)))
                        (NOT (MEMBER X (CDR FLIST)))
                        (LISTP FLIST)
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST))
                        (NOT (EVAL (CAR FLIST) ALIST))
                        (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   ALIST)))
                   (NOT (EVAL (CAR FLIST) (CONS X ALIST)))).

    Applying the lemmas CAR-CDR-ELIM and ARG-ELIM, replace FLIST by (CONS Z V)
    to eliminate (CAR FLIST) and (CDR FLIST) and Z by (F-NOT W) to eliminate
    (ARG Z).  We thus obtain the new conjecture:

          (IMPLIES (AND (NOT (EQUAL X (F-NOT W)))
                        (NOT (EVAL (MAKE-DISJUNCT V)
                                   (CONS X ALIST)))
                        (NOT (MEMBER X V))
                        (NOT (F-ORP W))
                        (NOT (F-NOTP W))
                        (NOT (MEMBER W V))
                        (PROP-ATOMP-LIST V)
                        (LISTP V)
                        (NOT (EVAL (F-NOT W) ALIST))
                        (NOT (EVAL (MAKE-DISJUNCT V) ALIST)))
                   (NOT (EVAL (F-NOT W) (CONS X ALIST)))),

    which further simplifies, rewriting with the lemmas ARG-F-NOT, EVAL-MEMBER,
    CDR-CONS, and CAR-CONS, and opening up the functions EVAL and MEMBER, to:

          T.


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


[ 0.0 0.1 0.0 ]

ALIST-CONS-EVAL2


(PROVE-LEMMA PROP-ATOMP-LIST-EVAL
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST)
                           (PROP-ATOMP-LIST FLIST))
                      (NOT (EVAL (MAKE-DISJUNCT FLIST)
                                 (FALSIFY FLIST)))))


     Name the conjecture *1.


     Perhaps we can prove it by induction.  Three inductions are suggested by
terms in the conjecture.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP FLIST) (p (CDR FLIST)))
                    (p FLIST))
           (IMPLIES (NOT (LISTP FLIST))
                    (p FLIST))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT FLIST) 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 conjectures:

Case 3. (IMPLIES (AND (NOT (LISTP (CDR FLIST)))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (FALSIFY FLIST)))).

  This simplifies, rewriting with the lemma MEMBER-FALSIFY, and opening up the
  definitions of PROP-ATOMP-LIST, NOR-TYPE, DBLE-NEG-TYPE, MEMBER, NEG-LIST,
  MAKE-DISJUNCT, FALSIFY, and EVAL, to the following two new conjectures:

  Case 3.2.
          (IMPLIES (AND (NOT (LISTP (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (F-NOTP (CAR FLIST))))
                   (NOT (EVAL (CAR FLIST)
                              (FALSIFY (CDR FLIST))))).

    But this again simplifies, rewriting with ARG-NF-NOTP and MEMBER-FALSIFY,
    and unfolding F-ORP, F-NOTP, MEMBER, and EVAL, to:

          T.

  Case 3.1.
          (IMPLIES (AND (NOT (LISTP (CDR FLIST)))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (F-NOTP (CAR FLIST)))
                   (NOT (EVAL (CAR FLIST)
                              (CONS (ARG (CAR FLIST))
                                    (FALSIFY (CDR FLIST)))))).

    But this again simplifies, applying EVAL-MEMBER and CAR-CONS, and
    unfolding MEMBER and EVAL, to:

          T.

Case 2. (IMPLIES (AND (NOT (PROP-ATOMP-LIST (CDR FLIST)))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (FALSIFY FLIST)))).

  This simplifies, opening up the functions PROP-ATOMP-LIST, NOR-TYPE,
  DBLE-NEG-TYPE, and NEG-LIST, to:

        T.

Case 1. (IMPLIES (AND (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                 (FALSIFY (CDR FLIST))))
                      (LISTP FLIST)
                      (PROP-ATOMP-LIST FLIST))
                 (NOT (EVAL (MAKE-DISJUNCT FLIST)
                            (FALSIFY FLIST)))).

  This simplifies, unfolding the functions PROP-ATOMP-LIST, NOR-TYPE,
  DBLE-NEG-TYPE, NEG-LIST, MAKE-DISJUNCT, and FALSIFY, to the following four
  new formulas:

  Case 1.4.
          (IMPLIES (AND (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (FALSIFY (CDR FLIST))))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST))))
                   (NOT (EVAL (CAR FLIST)
                              (FALSIFY (CDR FLIST))))).

    But this again simplifies, applying MEMBER-FALSIFY, and unfolding the
    definitions of MEMBER and EVAL, to:

          T.

  Case 1.3.
          (IMPLIES (AND (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (FALSIFY (CDR FLIST))))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST)))
                   (NOT (EVAL (F-OR (CAR FLIST)
                                    (MAKE-DISJUNCT (CDR FLIST)))
                              (FALSIFY (CDR FLIST))))).

    However this again simplifies, rewriting with the lemmas ARG2-F-OR,
    ARG1-F-OR, and MEMBER-FALSIFY, and expanding the function EVAL, to:

          T.

  Case 1.2.
          (IMPLIES (AND (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (FALSIFY (CDR FLIST))))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (NOT (LISTP (CDR FLIST))))
                   (NOT (EVAL (CAR FLIST)
                              (CONS (ARG (CAR FLIST))
                                    (FALSIFY (CDR FLIST)))))),

    which again simplifies, rewriting with the lemmas EVAL-MEMBER and CAR-CONS,
    and expanding the definitions of MEMBER and EVAL, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (EVAL (MAKE-DISJUNCT (CDR FLIST))
                                   (FALSIFY (CDR FLIST))))
                        (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (F-NOTP (CAR FLIST))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (MEMBER (ARG (CAR FLIST))
                                     (CDR FLIST)))
                        (PROP-ATOMP-LIST (CDR FLIST))
                        (LISTP (CDR FLIST)))
                   (NOT (EVAL (F-OR (CAR FLIST)
                                    (MAKE-DISJUNCT (CDR FLIST)))
                              (CONS (ARG (CAR FLIST))
                                    (FALSIFY (CDR FLIST)))))),

    which again simplifies, appealing to the lemmas ALIST-CONS-EVAL2,
    ARG2-F-OR, ARG1-F-OR, EVAL-MEMBER, and CAR-CONS, and opening up EVAL and
    MEMBER, to:

          T.


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


[ 0.0 0.0 0.0 ]

PROP-ATOMP-LIST-EVAL


(PROVE-LEMMA NOT-EVAL-PROP-ATOMP
             (REWRITE)
             (EQUAL (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CONS EXP FLIST2)))
                          ALIST)
                    (EVAL (MAKE-DISJUNCT (CONS EXP (APPEND FLIST1 FLIST2)))
                          ALIST)))

This formula simplifies, applying the lemmas CAR-CONS and CDR-CONS, and
unfolding MAKE-DISJUNCT, to the following two new goals:

Case 2. (IMPLIES (NOT (LISTP (APPEND FLIST1 FLIST2)))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CONS EXP FLIST2)))
                              ALIST)
                        (EVAL EXP ALIST))).

  Call the above conjecture *1.

Case 1. (IMPLIES (LISTP (APPEND FLIST1 FLIST2))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CONS EXP FLIST2)))
                              ALIST)
                        (EVAL (F-OR EXP
                                    (MAKE-DISJUNCT (APPEND FLIST1 FLIST2)))
                              ALIST))).

  However this again simplifies, applying ARG2-F-OR and ARG1-F-OR, and
  unfolding the function EVAL, to the following two new goals:

  Case 1.2.
          (IMPLIES
                 (AND (LISTP (APPEND FLIST1 FLIST2))
                      (NOT (EVAL EXP ALIST)))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CONS EXP FLIST2)))
                              ALIST)
                        (EVAL (MAKE-DISJUNCT (APPEND FLIST1 FLIST2))
                              ALIST))),

    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 (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CONS EXP FLIST2)))
             ALIST)
       (EVAL (MAKE-DISJUNCT (CONS EXP (APPEND FLIST1 FLIST2)))
             ALIST)),

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 FLIST1)
                         (p (CDR FLIST1) EXP FLIST2 ALIST))
                    (p FLIST1 EXP FLIST2 ALIST))
           (IMPLIES (NOT (LISTP FLIST1))
                    (p FLIST1 EXP FLIST2 ALIST))).
Linear arithmetic and the lemma CDR-LESSP can be used to establish that the
measure (COUNT FLIST1) decreases according to the well-founded relation LESSP
in each induction step of the scheme.  The above induction scheme produces two
new formulas:

Case 2. (IMPLIES
          (AND (LISTP FLIST1)
               (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                   (CONS EXP FLIST2)))
                            ALIST)
                      (EVAL (MAKE-DISJUNCT (CONS EXP
                                                 (APPEND (CDR FLIST1) FLIST2)))
                            ALIST)))
          (EQUAL (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CONS EXP FLIST2)))
                       ALIST)
                 (EVAL (MAKE-DISJUNCT (CONS EXP (APPEND FLIST1 FLIST2)))
                       ALIST))),

  which simplifies, applying CAR-CONS, CDR-CONS, ARG2-F-OR, and ARG1-F-OR, and
  opening up the definitions of MAKE-DISJUNCT, APPEND, and EVAL, to the
  following three new formulas:

  Case 2.3.
          (IMPLIES (AND (LISTP FLIST1)
                        (NOT (LISTP (APPEND (CDR FLIST1) FLIST2)))
                        (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                            (CONS EXP FLIST2)))
                                     ALIST)
                               (EVAL EXP ALIST))
                        (NOT (EVAL EXP ALIST))
                        (NOT (EVAL (CAR FLIST1) ALIST)))
                   (EQUAL (EVAL EXP ALIST)
                          (EVAL (CAR FLIST1) ALIST))).

    This again simplifies, obviously, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP FLIST1)
                        (NOT (LISTP (APPEND (CDR FLIST1) FLIST2)))
                        (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                            (CONS EXP FLIST2)))
                                     ALIST)
                               (EVAL EXP ALIST))
                        (NOT (EVAL EXP ALIST))
                        (EVAL (CAR FLIST1) ALIST))
                   (EQUAL T (EVAL (CAR FLIST1) ALIST))).

    This again simplifies, clearly, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP FLIST1)
                        (NOT (LISTP (APPEND (CDR FLIST1) FLIST2)))
                        (EQUAL (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST1)
                                                            (CONS EXP FLIST2)))
                                     ALIST)
                               (EVAL EXP ALIST))
                        (EVAL EXP ALIST)
                        (NOT (EVAL (CAR FLIST1) ALIST)))
                   (EQUAL (EVAL EXP ALIST) T)).

    This again simplifies, obviously, to:

          T.

Case 1. (IMPLIES (NOT (LISTP FLIST1))
                 (EQUAL (EVAL (MAKE-DISJUNCT (APPEND FLIST1 (CONS EXP FLIST2)))
                              ALIST)
                        (EVAL (MAKE-DISJUNCT (CONS EXP (APPEND FLIST1 FLIST2)))
                              ALIST))).

  This simplifies, applying the lemmas CAR-CONS and CDR-CONS, and expanding
  the functions APPEND and MAKE-DISJUNCT, to:

        T.


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


[ 0.0 0.0 0.0 ]

NOT-EVAL-PROP-ATOMP


(PROVE-LEMMA NOT-TAUT-FALSE
             (REWRITE)
             (IMPLIES (AND (PROP-ATOMP-LIST AUXLIST)
                           (NOT (TAUTOLOGYP1 FLIST AUXLIST)))
                      (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                                 (FALSIFY-TAUT FLIST AUXLIST))))
             ((INDUCT (FALSIFY-TAUT FLIST AUXLIST))))

This formula can be simplified, using the abbreviations DBLE-NEG-TYPE,
NOR-TYPE, NOT-FALSIFY-TAUT, IMPLIES, NOT, OR, AND, and NOT-EVAL-PROP-ATOMP, to
the following seven new conjectures:

Case 7. (IMPLIES
         (AND
          (LISTP FLIST)
          (F-ORP (CAR FLIST))
          (IMPLIES
           (AND (PROP-ATOMP-LIST AUXLIST)
                (NOT (TAUTOLOGYP1 (CONS (ARG1 (CAR FLIST))
                                        (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                  AUXLIST)))
           (NOT
            (EVAL
             (MAKE-DISJUNCT
                           (APPEND (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST))
             (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                 (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                           AUXLIST))))
          (PROP-ATOMP-LIST AUXLIST)
          (FALSIFY-TAUT FLIST AUXLIST))
         (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                    (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, rewriting with NOT-FALSIFY-TAUT, CDR-CONS, CAR-CONS,
  ARG2-F-OR, and ARG1-F-OR, and unfolding the definitions of NOT, AND, APPEND,
  MAKE-DISJUNCT, EVAL, IMPLIES, and FALSIFY-TAUT, to two new formulas:

  Case 7.2.
          (IMPLIES
           (AND
            (LISTP FLIST)
            (F-ORP (CAR FLIST))
            (NOT
               (EVAL (ARG1 (CAR FLIST))
                     (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)))
            (LISTP (APPEND (CDR FLIST) AUXLIST))
            (NOT
               (EVAL (F-OR (ARG2 (CAR FLIST))
                           (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                     (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)))
            (PROP-ATOMP-LIST AUXLIST)
            (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                          AUXLIST))
           (NOT
               (EVAL (ARG2 (CAR FLIST))
                     (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)))),

    which again simplifies, rewriting with ARG1-F-OR, and opening up the
    definition of EVAL, to:

          T.

  Case 7.1.
          (IMPLIES
           (AND
            (LISTP FLIST)
            (F-ORP (CAR FLIST))
            (NOT
               (EVAL (ARG1 (CAR FLIST))
                     (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)))
            (LISTP (APPEND (CDR FLIST) AUXLIST))
            (NOT
               (EVAL (F-OR (ARG2 (CAR FLIST))
                           (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                     (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)))
            (PROP-ATOMP-LIST AUXLIST)
            (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                          AUXLIST))
           (NOT
               (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                     (FALSIFY-TAUT (CONS (ARG1 (CAR FLIST))
                                         (CONS (ARG2 (CAR FLIST)) (CDR FLIST)))
                                   AUXLIST)))).

    But this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    unfolding the definition of EVAL, to:

          T.

Case 6. (IMPLIES
         (AND
          (LISTP FLIST)
          (NOT (F-ORP (CAR FLIST)))
          (F-NOTP (CAR FLIST))
          (F-ORP (ARG (CAR FLIST)))
          (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                              (CDR FLIST))
                        AUXLIST)
          (IMPLIES
           (AND (PROP-ATOMP-LIST AUXLIST)
                (NOT (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                        (CDR FLIST))
                                  AUXLIST)))
           (NOT
            (EVAL (MAKE-DISJUNCT (APPEND (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))
                  (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                      (CDR FLIST))
                                AUXLIST))))
          (PROP-ATOMP-LIST AUXLIST)
          (FALSIFY-TAUT FLIST AUXLIST))
         (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                    (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, rewriting with NOT-FALSIFY-TAUT, CDR-CONS, CAR-CONS,
  ARG2-F-OR, and ARG1-F-OR, and opening up NOT, AND, APPEND, MAKE-DISJUNCT,
  IMPLIES, NOR-TYPE, FALSIFY-TAUT, and EVAL, to three new conjectures:

  Case 6.3.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                    (CDR FLIST))
                              AUXLIST)
                (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                (NOT (EVAL (F-NOT (ARG2 (ARG (CAR FLIST))))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
                (PROP-ATOMP-LIST AUXLIST))
           (EVAL (ARG (CAR FLIST))
                 (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                     (CDR FLIST))
                               AUXLIST))),

    which again simplifies, rewriting with ARG-F-NOT, and opening up the
    function EVAL, to:

          T.

  Case 6.2.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                    (CDR FLIST))
                              AUXLIST)
                (LISTP (APPEND (CDR FLIST) AUXLIST))
                (NOT (EVAL (F-OR (F-NOT (ARG2 (ARG (CAR FLIST))))
                                 (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
                (PROP-ATOMP-LIST AUXLIST))
           (EVAL (ARG (CAR FLIST))
                 (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                     (CDR FLIST))
                               AUXLIST))).

    This again simplifies, rewriting with ARG2-F-OR, ARG1-F-OR, and ARG-F-NOT,
    and expanding EVAL, to:

          T.

  Case 6.1.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                    (CDR FLIST))
                              AUXLIST)
                (LISTP (APPEND (CDR FLIST) AUXLIST))
                (NOT (EVAL (F-OR (F-NOT (ARG2 (ARG (CAR FLIST))))
                                 (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
                (PROP-ATOMP-LIST AUXLIST))
           (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                      (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                          (CDR FLIST))
                                    AUXLIST)))).

    But this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    expanding EVAL, to:

          T.

Case 5. (IMPLIES
         (AND
          (LISTP FLIST)
          (NOT (F-ORP (CAR FLIST)))
          (F-NOTP (CAR FLIST))
          (F-ORP (ARG (CAR FLIST)))
          (NOT (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                   (CDR FLIST))
                             AUXLIST))
          (IMPLIES
           (AND (PROP-ATOMP-LIST AUXLIST)
                (NOT (TAUTOLOGYP1 (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                        (CDR FLIST))
                                  AUXLIST)))
           (NOT
            (EVAL (MAKE-DISJUNCT (APPEND (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))
                  (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                      (CDR FLIST))
                                AUXLIST))))
          (IMPLIES
           (AND (PROP-ATOMP-LIST AUXLIST)
                (NOT (TAUTOLOGYP1 (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                        (CDR FLIST))
                                  AUXLIST)))
           (NOT
            (EVAL (MAKE-DISJUNCT (APPEND (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))
                  (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                      (CDR FLIST))
                                AUXLIST))))
          (PROP-ATOMP-LIST AUXLIST)
          (FALSIFY-TAUT FLIST AUXLIST))
         (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                    (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, appealing to the lemmas NOT-FALSIFY-TAUT, CDR-CONS,
  CAR-CONS, ARG2-F-OR, and ARG1-F-OR, and unfolding the functions NOT, AND,
  APPEND, MAKE-DISJUNCT, IMPLIES, NOR-TYPE, FALSIFY-TAUT, and EVAL, to the
  following three new conjectures:

  Case 5.3.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (NOT (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                         (CDR FLIST))
                                   AUXLIST))
                (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                (NOT (EVAL (F-NOT (ARG1 (ARG (CAR FLIST))))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
                (PROP-ATOMP-LIST AUXLIST)
                (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                    (CDR FLIST))
                              AUXLIST)
                (NOT (EVAL (ARG1 (ARG (CAR FLIST)))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))))
           (EVAL (ARG2 (ARG (CAR FLIST)))
                 (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                     (CDR FLIST))
                               AUXLIST))).

    However this again simplifies, applying the lemma ARG-F-NOT, and unfolding
    the function EVAL, to:

          T.

  Case 5.2.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (NOT (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                         (CDR FLIST))
                                   AUXLIST))
                (LISTP (APPEND (CDR FLIST) AUXLIST))
                (NOT (EVAL (F-OR (F-NOT (ARG1 (ARG (CAR FLIST))))
                                 (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
                (PROP-ATOMP-LIST AUXLIST)
                (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                    (CDR FLIST))
                              AUXLIST)
                (NOT (EVAL (ARG1 (ARG (CAR FLIST)))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST))))
           (EVAL (ARG2 (ARG (CAR FLIST)))
                 (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                     (CDR FLIST))
                               AUXLIST))),

    which again simplifies, applying ARG2-F-OR, ARG1-F-OR, and ARG-F-NOT, and
    expanding the definition of EVAL, to:

          T.

  Case 5.1.
          (IMPLIES
           (AND (LISTP FLIST)
                (F-NOTP (CAR FLIST))
                (F-ORP (ARG (CAR FLIST)))
                (NOT (FALSIFY-TAUT (CONS (F-NOT (ARG2 (ARG (CAR FLIST))))
                                         (CDR FLIST))
                                   AUXLIST))
                (LISTP (APPEND (CDR FLIST) AUXLIST))
                (NOT (EVAL (F-OR (F-NOT (ARG1 (ARG (CAR FLIST))))
                                 (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                           (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                               (CDR FLIST))
                                         AUXLIST)))
                (PROP-ATOMP-LIST AUXLIST)
                (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                    (CDR FLIST))
                              AUXLIST))
           (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                      (FALSIFY-TAUT (CONS (F-NOT (ARG1 (ARG (CAR FLIST))))
                                          (CDR FLIST))
                                    AUXLIST)))).

    But this again simplifies, applying ARG2-F-OR and ARG1-F-OR, and unfolding
    EVAL, to:

          T.

Case 4. (IMPLIES
         (AND
          (LISTP FLIST)
          (NOT (F-ORP (CAR FLIST)))
          (NOT (NOR-TYPE (CAR FLIST)))
          (F-NOTP (CAR FLIST))
          (F-NOTP (ARG (CAR FLIST)))
          (IMPLIES
                (AND (PROP-ATOMP-LIST AUXLIST)
                     (NOT (TAUTOLOGYP1 (CONS (ARG (ARG (CAR FLIST)))
                                             (CDR FLIST))
                                       AUXLIST)))
                (NOT (EVAL (MAKE-DISJUNCT (APPEND (CONS (ARG (ARG (CAR FLIST)))
                                                        (CDR FLIST))
                                                  AUXLIST))
                           (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                               (CDR FLIST))
                                         AUXLIST))))
          (PROP-ATOMP-LIST AUXLIST)
          (FALSIFY-TAUT FLIST AUXLIST))
         (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                    (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, appealing to the lemmas NOT-FALSIFY-TAUT, CDR-CONS,
  CAR-CONS, ARG2-F-OR, and ARG1-F-OR, and unfolding the definitions of
  NOR-TYPE, NOT, AND, APPEND, MAKE-DISJUNCT, IMPLIES, DBLE-NEG-TYPE,
  FALSIFY-TAUT, and EVAL, to the following two new formulas:

  Case 4.2.
          (IMPLIES
            (AND (LISTP FLIST)
                 (F-NOTP (CAR FLIST))
                 (F-NOTP (ARG (CAR FLIST)))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (ARG (ARG (CAR FLIST)))
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                                (CDR FLIST))
                                          AUXLIST)))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                     (CDR FLIST))
                               AUXLIST))
            (NOT (EVAL (ARG (ARG (CAR FLIST)))
                       (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                           (CDR FLIST))
                                     AUXLIST)))).

    But this again simplifies, applying ARG1-F-OR, and unfolding EVAL, to:

          T.

  Case 4.1.
          (IMPLIES
            (AND (LISTP FLIST)
                 (F-NOTP (CAR FLIST))
                 (F-NOTP (ARG (CAR FLIST)))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (ARG (ARG (CAR FLIST)))
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                                (CDR FLIST))
                                          AUXLIST)))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                     (CDR FLIST))
                               AUXLIST))
            (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       (FALSIFY-TAUT (CONS (ARG (ARG (CAR FLIST)))
                                           (CDR FLIST))
                                     AUXLIST)))).

    But this again simplifies, applying ARG2-F-OR and ARG1-F-OR, and opening
    up the definition of EVAL, to:

          T.

Case 3. (IMPLIES (AND (LISTP FLIST)
                      (NOT (F-ORP (CAR FLIST)))
                      (NOT (NOR-TYPE (CAR FLIST)))
                      (NOT (DBLE-NEG-TYPE (CAR FLIST)))
                      (NEG-LIST (CAR FLIST) AUXLIST)
                      (PROP-ATOMP-LIST AUXLIST)
                      (FALSIFY-TAUT FLIST AUXLIST))
                 (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                            (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, opening up the functions NOR-TYPE, DBLE-NEG-TYPE, NEG-LIST,
  and FALSIFY-TAUT, to:

        T.

Case 2. (IMPLIES
         (AND
          (LISTP FLIST)
          (NOT (F-ORP (CAR FLIST)))
          (NOT (NOR-TYPE (CAR FLIST)))
          (NOT (DBLE-NEG-TYPE (CAR FLIST)))
          (NOT (NEG-LIST (CAR FLIST) AUXLIST))
          (IMPLIES
                 (AND (PROP-ATOMP-LIST (CONS (CAR FLIST) AUXLIST))
                      (NOT (TAUTOLOGYP1 (CDR FLIST)
                                        (CONS (CAR FLIST) AUXLIST))))
                 (NOT (EVAL (MAKE-DISJUNCT (CONS (CAR FLIST)
                                                 (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST)))))
          (PROP-ATOMP-LIST AUXLIST)
          (FALSIFY-TAUT FLIST AUXLIST))
         (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                    (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, rewriting with CDR-CONS, CAR-CONS, NOT-FALSIFY-TAUT,
  ARG2-F-OR, and ARG1-F-OR, and opening up the functions NOR-TYPE,
  DBLE-NEG-TYPE, NEG-LIST, PROP-ATOMP-LIST, NOT, AND, MAKE-DISJUNCT, IMPLIES,
  FALSIFY-TAUT, APPEND, and EVAL, to 11 new conjectures:

  Case 2.11.
          (IMPLIES (AND (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                        (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                        (NOT (EVAL (CAR FLIST)
                                   (FALSIFY-TAUT (CDR FLIST)
                                                 (CONS (CAR FLIST) AUXLIST))))
                        (PROP-ATOMP-LIST AUXLIST)
                        (FALSIFY-TAUT (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST)))
                   (NOT (MEMBER (CAR FLIST)
                                (FALSIFY-TAUT (CDR FLIST)
                                              (CONS (CAR FLIST) AUXLIST))))),

    which again simplifies, applying EVAL-MEMBER, to:

          T.

  Case 2.10.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (MEMBER (CAR FLIST)
                         (FALSIFY-TAUT (CDR FLIST)
                                       (CONS (CAR FLIST) AUXLIST))))).

    But this again simplifies, applying EVAL-MEMBER and ARG1-F-OR, and
    expanding the function EVAL, to:

          T.

  Case 2.9.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       (FALSIFY-TAUT (CDR FLIST)
                                     (CONS (CAR FLIST) AUXLIST))))).

    But this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    opening up EVAL, to:

          T.

  Case 2.8.
          (IMPLIES (AND (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                        (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                        (NOT (EVAL (CAR FLIST)
                                   (FALSIFY-TAUT (CDR FLIST)
                                                 (CONS (CAR FLIST) AUXLIST))))
                        (PROP-ATOMP-LIST AUXLIST)
                        (FALSIFY-TAUT (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST)))
                   (NOT (MEMBER (CAR FLIST)
                                (FALSIFY-TAUT (CDR FLIST)
                                              (CONS (CAR FLIST) AUXLIST))))).

    However this again simplifies, rewriting with ARG-NF-NOTP and EVAL-MEMBER,
    and unfolding the function F-ORP, to:

          T.

  Case 2.7.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (MEMBER (CAR FLIST)
                         (FALSIFY-TAUT (CDR FLIST)
                                       (CONS (CAR FLIST) AUXLIST))))).

    This again simplifies, appealing to the lemmas ARG-NF-NOTP, EVAL-MEMBER,
    and ARG1-F-OR, and expanding the definitions of F-ORP and EVAL, to:

          T.

  Case 2.6.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       (FALSIFY-TAUT (CDR FLIST)
                                     (CONS (CAR FLIST) AUXLIST))))),

    which again simplifies, rewriting with ARG-NF-NOTP, ARG2-F-OR, and
    ARG1-F-OR, and unfolding F-ORP and EVAL, to:

          T.

  Case 2.5.
          (IMPLIES (AND (LISTP FLIST)
                        (NOT (F-ORP (CAR FLIST)))
                        (NOT (F-ORP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (ARG (CAR FLIST))))
                        (NOT (F-NOTP (CAR FLIST)))
                        (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                        (NOT (LISTP (APPEND (CDR FLIST) AUXLIST)))
                        (NOT (EVAL (CAR FLIST)
                                   (FALSIFY-TAUT (CDR FLIST)
                                                 (CONS (CAR FLIST) AUXLIST))))
                        (PROP-ATOMP-LIST AUXLIST)
                        (FALSIFY-TAUT (CDR FLIST)
                                      (CONS (CAR FLIST) AUXLIST)))
                   (NOT (MEMBER (CAR FLIST)
                                (FALSIFY-TAUT (CDR FLIST)
                                              (CONS (CAR FLIST) AUXLIST))))).

    This again simplifies, appealing to the lemmas ARG-NF-NOTP and EVAL-MEMBER,
    and expanding the functions F-ORP and F-NOTP, to:

          T.

  Case 2.4.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (MEMBER (CAR FLIST)
                         (FALSIFY-TAUT (CDR FLIST)
                                       (CONS (CAR FLIST) AUXLIST))))),

    which again simplifies, rewriting with the lemmas ARG-NF-NOTP, EVAL-MEMBER,
    and ARG1-F-OR, and opening up the definitions of F-ORP, F-NOTP, and EVAL,
    to:

          T.

  Case 2.3.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (CAR FLIST)))
                 (NOT (MEMBER (F-NOT (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       (FALSIFY-TAUT (CDR FLIST)
                                     (CONS (CAR FLIST) AUXLIST))))),

    which again simplifies, rewriting with the lemmas ARG-NF-NOTP, ARG2-F-OR,
    and ARG1-F-OR, and opening up the functions F-ORP, F-NOTP, and EVAL, to:

          T.

  Case 2.2.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (F-NOTP (CAR FLIST))
                 (NOT (MEMBER (ARG (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (EVAL (CAR FLIST)
                       (FALSIFY-TAUT (CDR FLIST)
                                     (CONS (CAR FLIST) AUXLIST))))),

    which again simplifies, rewriting with ARG1-F-OR, and expanding EVAL, to:

          T.

  Case 2.1.
          (IMPLIES
            (AND (LISTP FLIST)
                 (NOT (F-ORP (CAR FLIST)))
                 (NOT (F-ORP (ARG (CAR FLIST))))
                 (NOT (F-NOTP (ARG (CAR FLIST))))
                 (F-NOTP (CAR FLIST))
                 (NOT (MEMBER (ARG (CAR FLIST)) AUXLIST))
                 (LISTP (APPEND (CDR FLIST) AUXLIST))
                 (NOT (EVAL (F-OR (CAR FLIST)
                                  (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST)))
                            (FALSIFY-TAUT (CDR FLIST)
                                          (CONS (CAR FLIST) AUXLIST))))
                 (PROP-ATOMP-LIST AUXLIST)
                 (FALSIFY-TAUT (CDR FLIST)
                               (CONS (CAR FLIST) AUXLIST)))
            (NOT (EVAL (MAKE-DISJUNCT (APPEND (CDR FLIST) AUXLIST))
                       (FALSIFY-TAUT (CDR FLIST)
                                     (CONS (CAR FLIST) AUXLIST))))).

    But this again simplifies, rewriting with ARG2-F-OR and ARG1-F-OR, and
    opening up the definition of EVAL, to:

          T.

Case 1. (IMPLIES (AND (NOT (LISTP FLIST))
                      (PROP-ATOMP-LIST AUXLIST)
                      (FALSIFY-TAUT FLIST AUXLIST))
                 (NOT (EVAL (MAKE-DISJUNCT (APPEND FLIST AUXLIST))
                            (FALSIFY-TAUT FLIST AUXLIST)))).

  This simplifies, expanding the functions FALSIFY-TAUT and APPEND, to:

        (IMPLIES (AND (NOT (LISTP FLIST))
                      (PROP-ATOMP-LIST AUXLIST))
                 (NOT (EVAL (MAKE-DISJUNCT AUXLIST)
                            (FALSIFY AUXLIST)))),

  which we will name *1.


     Perhaps we can prove it by induction.  Three inductions are suggested by
terms in the conjecture.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP AUXLIST)
                         (p (CDR AUXLIST) FLIST))
                    (p AUXLIST FLIST))
           (IMPLIES (NOT (LISTP AUXLIST))
                    (p AUXLIST FLIST))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure
(COUNT AUXLIST) 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 (LISTP AUXLIST)
                      (NOT (PROP-ATOMP-LIST (CDR AUXLIST)))
                      (NOT (LISTP FLIST))
                      (PROP-ATOMP-LIST AUXLIST))
                 (NOT (EVAL (MAKE-DISJUNCT AUXLIST)
                            (FALSIFY AUXLIST)))).

  This simplifies, opening up the functions PROP-ATOMP-LIST, NOR-TYPE,
  DBLE-NEG-TYPE, and NEG-LIST, to:

        T.

Case 2. (IMPLIES (AND (LISTP AUXLIST)
                      (NOT (EVAL (MAKE-DISJUNCT (CDR AUXLIST))
                                 (FALSIFY (CDR AUXLIST))))
                      (NOT (LISTP FLIST))
                      (PROP-ATOMP-LIST AUXLIST))
                 (NOT (EVAL (MAKE-DISJUNCT AUXLIST)
                            (FALSIFY AUXLIST)))).

  This simplifies, opening up the definitions of PROP-ATOMP-LIST, NOR-TYPE,
  DBLE-NEG-TYPE, NEG-LIST, MAKE-DISJUNCT, and FALSIFY, to the following four
  new goals:

  Case 2.4.
          (IMPLIES (AND (LISTP AUXLIST)
                        (NOT (EVAL (MAKE-DISJUNCT (CDR AUXLIST))
                                   (FALSIFY (CDR AUXLIST))))
                        (NOT (LISTP FLIST))
                        (NOT (F-ORP (CAR AUXLIST)))
                        (NOT (F-NOTP (CAR AUXLIST)))
                        (NOT (MEMBER (F-NOT (CAR AUXLIST))
                                     (CDR AUXLIST)))
                        (PROP-ATOMP-LIST (CDR AUXLIST))
                        (NOT (LISTP (CDR AUXLIST))))
                   (NOT (EVAL (CAR AUXLIST)
                              (FALSIFY (CDR AUXLIST))))).

    But this again simplifies, applying MEMBER-FALSIFY, and unfolding MEMBER
    and EVAL, to:

          T.

  Case 2.3.
          (IMPLIES (AND (LISTP AUXLIST)
                        (NOT (EVAL (MAKE-DISJUNCT (CDR AUXLIST))
                                   (FALSIFY (CDR AUXLIST))))
                        (NOT (LISTP FLIST))
                        (NOT (F-ORP (CAR AUXLIST)))
                        (NOT (F-NOTP (CAR AUXLIST)))
                        (NOT (MEMBER (F-NOT (CAR AUXLIST))
                                     (CDR AUXLIST)))
                        (PROP-ATOMP-LIST (CDR AUXLIST))
                        (LISTP (CDR AUXLIST)))
                   (NOT (EVAL (F-OR (CAR AUXLIST)
                                    (MAKE-DISJUNCT (CDR AUXLIST)))
                              (FALSIFY (CDR AUXLIST))))).

    This again simplifies, rewriting with the lemmas PROP-ATOMP-LIST-EVAL,
    ARG2-F-OR, ARG1-F-OR, and MEMBER-FALSIFY, and unfolding EVAL, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP AUXLIST)
                        (NOT (EVAL (MAKE-DISJUNCT (CDR AUXLIST))
                                   (FALSIFY (CDR AUXLIST))))
                        (NOT (LISTP FLIST))
                        (NOT (F-ORP (CAR AUXLIST)))
                        (F-NOTP (CAR AUXLIST))
                        (NOT (F-ORP (ARG (CAR AUXLIST))))
                        (NOT (F-NOTP (ARG (CAR AUXLIST))))
                        (NOT (MEMBER (ARG (CAR AUXLIST))
                                     (CDR AUXLIST)))
                        (PROP-ATOMP-LIST (CDR AUXLIST))
                        (NOT (LISTP (CDR AUXLIST))))
                   (NOT (EVAL (CAR AUXLIST)
                              (CONS (ARG (CAR AUXLIST))
                                    (FALSIFY (CDR AUXLIST)))))),

    which again simplifies, applying EVAL-MEMBER and CAR-CONS, and expanding
    the functions MEMBER and EVAL, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP AUXLIST)
                        (NOT (EVAL (MAKE-DISJUNCT (CDR AUXLIST))
                                   (FALSIFY (CDR AUXLIST))))
                        (NOT (LISTP FLIST))
                        (NOT (F-ORP (CAR AUXLIST)))
                        (F-NOTP (CAR AUXLIST))
                        (NOT (F-ORP (ARG (CAR AUXLIST))))
                        (NOT (F-NOTP (ARG (CAR AUXLIST))))
                        (NOT (MEMBER (ARG (CAR AUXLIST))
                                     (CDR AUXLIST)))
                        (PROP-ATOMP-LIST (CDR AUXLIST))
                        (LISTP (CDR AUXLIST)))
                   (NOT (EVAL (F-OR (CAR AUXLIST)
                                    (MAKE-DISJUNCT (CDR AUXLIST)))
                              (CONS (ARG (CAR AUXLIST))
                                    (FALSIFY (CDR AUXLIST)))))).

    However this again simplifies, applying PROP-ATOMP-LIST-EVAL,
    ALIST-CONS-EVAL2, ARG2-F-OR, ARG1-F-OR, EVAL-MEMBER, and CAR-CONS, and
    unfolding EVAL and MEMBER, to:

          T.

Case 1. (IMPLIES (AND (NOT (LISTP AUXLIST))
                      (NOT (LISTP FLIST))
                      (PROP-ATOMP-LIST AUXLIST))
                 (NOT (EVAL (MAKE-DISJUNCT AUXLIST)
                            (FALSIFY AUXLIST)))).

  This simplifies, expanding the functions PROP-ATOMP-LIST, MAKE-DISJUNCT,
  FALSIFY, MEMBER, F-ORP, F-NOTP, and EVAL, to:

        T.


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


[ 0.0 0.3 0.0 ]

NOT-TAUT-FALSE


(DEFN TAUTOLOGYP
      (FLIST)
      (TAUTOLOGYP1 FLIST NIL))

     Observe that (OR (FALSEP (TAUTOLOGYP FLIST)) (TRUEP (TAUTOLOGYP FLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

TAUTOLOGYP


(DEFN TAUT-PROOF
      (FLIST)
      (TAUT-PROOF1 FLIST NIL))

     Observe that (OR (LITATOM (TAUT-PROOF FLIST)) (LISTP (TAUT-PROOF FLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

TAUT-PROOF


(PROVE-LEMMA FORM-LIST-APPEND-NIL
             (REWRITE)
             (EQUAL (MAKE-DISJUNCT (APPEND FLIST NIL))
                    (MAKE-DISJUNCT FLIST)))


     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 FLIST) (p (CDR FLIST)))
                    (p FLIST))
           (IMPLIES (NOT (LISTP FLIST))
                    (p FLIST))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure
(COUNT FLIST) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates two new
conjectures:

Case 2. (IMPLIES (AND (LISTP FLIST)
                      (EQUAL (MAKE-DISJUNCT (APPEND (CDR FLIST) NIL))
                             (MAKE-DISJUNCT (CDR FLIST))))
                 (EQUAL (MAKE-DISJUNCT (APPEND FLIST NIL))
                        (MAKE-DISJUNCT FLIST))),

  which simplifies, applying CAR-CONS and CDR-CONS, and opening up APPEND and
  MAKE-DISJUNCT, to the following two new goals:

  Case 2.2.
          (IMPLIES (AND (LISTP FLIST)
                        (EQUAL (MAKE-DISJUNCT (APPEND (CDR FLIST) NIL))
                               (MAKE-DISJUNCT (CDR FLIST)))
                        (NOT (LISTP (CDR FLIST)))
                        (LISTP (APPEND (CDR FLIST) NIL)))
                   (EQUAL (F-OR (CAR FLIST)
                                (MAKE-DISJUNCT (CDR FLIST)))
                          (CAR FLIST))).

    This again simplifies, trivially, to:

          (IMPLIES (AND (LISTP FLIST)
                        (EQUAL (MAKE-DISJUNCT (APPEND (CDR FLIST) NIL))
                               (MAKE-DISJUNCT (CDR FLIST)))
                        (NOT (LISTP (CDR FLIST))))
                   (NOT (LISTP (APPEND (CDR FLIST) NIL)))),

    which further simplifies, opening up the functions APPEND, LISTP,
    MAKE-DISJUNCT, and EQUAL, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP FLIST)
                        (EQUAL (MAKE-DISJUNCT (APPEND (CDR FLIST) NIL))
                               (MAKE-DISJUNCT (CDR FLIST)))
                        (LISTP (CDR FLIST))
                        (NOT (LISTP (APPEND (CDR FLIST) NIL))))
                   (EQUAL (CAR FLIST)
                          (F-OR (CAR FLIST)
                                (MAKE-DISJUNCT (CDR FLIST))))),

    which again simplifies, expanding MAKE-DISJUNCT, to:

          (IMPLIES (AND (LISTP FLIST)
                        (EQUAL NIL
                               (MAKE-DISJUNCT (CDR FLIST)))
                        (LISTP (CDR FLIST)))
                   (LISTP (APPEND (CDR FLIST) NIL))).

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

          (IMPLIES (AND (EQUAL NIL (MAKE-DISJUNCT X))
                        (LISTP X))
                   (LISTP (APPEND X NIL))).

    Give the above formula the name *1.1.

Case 1. (IMPLIES (NOT (LISTP FLIST))
                 (EQUAL (MAKE-DISJUNCT (APPEND FLIST NIL))
                        (MAKE-DISJUNCT FLIST))).

  This simplifies, opening up the functions APPEND, LISTP, MAKE-DISJUNCT, and
  EQUAL, to:

        T.


     So next consider:

      (IMPLIES (AND (EQUAL NIL (MAKE-DISJUNCT X))
                    (LISTP X))
               (LISTP (APPEND X NIL))),

which we named *1.1 above.  We will appeal to induction.  Two inductions are
suggested by terms in the conjecture.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP X) (p X))
           (IMPLIES (AND (NOT (NLISTP X))
                         (NLISTP (CDR X)))
                    (p X))
           (IMPLIES (AND (NOT (NLISTP X))
                         (NOT (NLISTP (CDR X)))
                         (p (CDR X)))
                    (p X))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT X) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme leads to the following five new conjectures:

Case 5. (IMPLIES (AND (NLISTP X)
                      (EQUAL NIL (MAKE-DISJUNCT X))
                      (LISTP X))
                 (LISTP (APPEND X NIL))).

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

        T.

Case 4. (IMPLIES (AND (NOT (NLISTP X))
                      (NLISTP (CDR X))
                      (EQUAL NIL (MAKE-DISJUNCT X))
                      (LISTP X))
                 (LISTP (APPEND X NIL))).

  This simplifies, unfolding the definitions of NLISTP, MAKE-DISJUNCT, and
  APPEND, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP X))
                      (NOT (NLISTP (CDR X)))
                      (NOT (EQUAL NIL (MAKE-DISJUNCT (CDR X))))
                      (EQUAL NIL (MAKE-DISJUNCT X))
                      (LISTP X))
                 (LISTP (APPEND X NIL))).

  This simplifies, expanding NLISTP and MAKE-DISJUNCT, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP X))
                      (NOT (NLISTP (CDR X)))
                      (NOT (LISTP (CDR X)))
                      (EQUAL NIL (MAKE-DISJUNCT X))
                      (LISTP X))
                 (LISTP (APPEND X NIL))).

  This simplifies, unfolding the function NLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP X))
                      (NOT (NLISTP (CDR X)))
                      (LISTP (APPEND (CDR X) NIL))
                      (EQUAL NIL (MAKE-DISJUNCT X))
                      (LISTP X))
                 (LISTP (APPEND X NIL))).

  This simplifies, unfolding NLISTP and MAKE-DISJUNCT, to:

        T.


     That finishes the proof of *1.1, which, consequently, also finishes the
proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

FORM-LIST-APPEND-NIL


(PROVE-LEMMA TAUTOLOGY-THEOREM
             (REWRITE)
             (IMPLIES (AND (FORM-LIST FLIST SYMBOLS)
                           (TAUTOLOGYP FLIST)
                           (EQUAL CONCL (MAKE-DISJUNCT FLIST)))
                      (PROVES (TAUT-PROOF FLIST)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((DISABLE TAUT-PROOF1 TAUTOLOGYP1 FORMULA NOT-FALSIFY-TAUT)))

This formula can be simplified, using the abbreviations AND, IMPLIES,
TAUT-PROOF, and TAUTOLOGYP, to:

      (IMPLIES (AND (FORM-LIST FLIST SYMBOLS)
                    (TAUTOLOGYP1 FLIST NIL)
                    (EQUAL CONCL (MAKE-DISJUNCT FLIST)))
               (PROVES (TAUT-PROOF1 FLIST NIL)
                       CONCL GIVEN DEFNS SYMBOLS)),

which simplifies, rewriting with FORM-LIST-APPEND-NIL and TAUT-THM2, and
unfolding FORM-LIST and LISTP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TAUTOLOGY-THEOREM


(PROVE-LEMMA TAUT-EVAL2
             (REWRITE)
             (IMPLIES (AND (TAUTOLOGYP1 FLIST AUXLIST)
                           (EQUAL CONCL
                                  (MAKE-DISJUNCT (APPEND FLIST AUXLIST))))
                      (EVAL CONCL ALIST))
             ((DISABLE TAUTOLOGYP1 NOT-FALSIFY-TAUT)))

WARNING:  Note that TAUT-EVAL2 contains the free variables AUXLIST and FLIST
which will be chosen by instantiating the hypothesis:
      (TAUTOLOGYP1 FLIST AUXLIST).



This formula simplifies, applying TAUT-EVAL, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TAUT-EVAL2


(PROVE-LEMMA TAUTOLOGIES-ARE-TRUE
             (REWRITE)
             (IMPLIES (AND (LISTP FLIST) (TAUTOLOGYP FLIST))
                      (EVAL (MAKE-DISJUNCT FLIST) ALIST))
             ((DISABLE FORMULA TAUTOLOGYP1 NOT-FALSIFY-TAUT)))

This formula can be simplified, using the abbreviations AND, IMPLIES, and
TAUTOLOGYP, to:

      (IMPLIES (AND (LISTP FLIST)
                    (TAUTOLOGYP1 FLIST NIL))
               (EVAL (MAKE-DISJUNCT FLIST) ALIST)),

which simplifies, rewriting with the lemmas FORM-LIST-APPEND-NIL and
TAUT-EVAL2, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TAUTOLOGIES-ARE-TRUE


(PROVE-LEMMA NOT-TAUT-FALSIFY2
             (REWRITE)
             (IMPLIES (AND (PROP-ATOMP-LIST AUXLIST)
                           (NOT (TAUTOLOGYP1 FLIST AUXLIST))
                           (EQUAL CONCL
                                  (MAKE-DISJUNCT (APPEND FLIST AUXLIST))))
                      (NOT (EVAL CONCL
                                 (FALSIFY-TAUT FLIST AUXLIST))))
             ((DISABLE TAUTOLOGYP1 NOT-FALSIFY-TAUT FORMULA)))

This simplifies, applying NOT-TAUT-FALSE, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

NOT-TAUT-FALSIFY2


(PROVE-LEMMA TRUTHS-ARE-TAUTOLOGIES
             (REWRITE)
             (IMPLIES (NOT (TAUTOLOGYP FLIST))
                      (NOT (EVAL (MAKE-DISJUNCT FLIST)
                                 (FALSIFY-TAUT FLIST NIL))))
             ((DISABLE TAUTOLOGYP1 NOT-FALSIFY-TAUT FORMULA)))

This formula can be simplified, using the abbreviations NOT, IMPLIES, and
TAUTOLOGYP, to:

      (IMPLIES (NOT (TAUTOLOGYP1 FLIST NIL))
               (NOT (EVAL (MAKE-DISJUNCT FLIST)
                          (FALSIFY-TAUT FLIST NIL)))),

which simplifies, rewriting with FORM-LIST-APPEND-NIL and NOT-TAUT-FALSIFY2,
and expanding the definitions of PROP-ATOMP-LIST and LISTP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TRUTHS-ARE-TAUTOLOGIES


(DEFN LIS-NOT
      (FLIST)
      (IF (NLISTP FLIST)
          NIL
          (CONS (F-NOT (CAR FLIST))
                (LIS-NOT (CDR FLIST)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP inform us that the measure (COUNT FLIST) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
LIS-NOT is accepted under the definitional principle.  Observe that:
      (OR (LITATOM (LIS-NOT FLIST))
          (LISTP (LIS-NOT FLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

LIS-NOT


(DEFN TAUT-CONSEQ
      (FLIST EXP)
      (TAUTOLOGYP (APPEND (LIS-NOT FLIST)
                          (CONS EXP NIL))))

     Observe that:
      (OR (FALSEP (TAUT-CONSEQ FLIST EXP))
          (TRUEP (TAUT-CONSEQ FLIST EXP)))
is a theorem.




[ 0.0 0.0 0.0 ]

TAUT-CONSEQ


(DEFN TAUTCONSEQ-PROOF
      (FLIST EXP PFLIST)
      (LIST-DETACH-PROOF FLIST EXP PFLIST
                         (TAUT-PROOF (APPEND (LIS-NOT FLIST)
                                             (CONS EXP NIL)))))

     Note that:
      (OR (LITATOM (TAUTCONSEQ-PROOF FLIST EXP PFLIST))
          (LISTP (TAUTCONSEQ-PROOF FLIST EXP PFLIST)))
is a theorem.




[ 0.0 0.0 0.0 ]

TAUTCONSEQ-PROOF


(TOGGLE G0873 F-IMPLIES NIL)

[ 0.0 0.0 0.0 ]

G0873


(PROVE-LEMMA EVAL-F-IMPLIES
             (REWRITE)
             (EQUAL (EVAL (F-IMPLIES X Y) ALIST)
                    (IMPLIES (EVAL X ALIST)
                             (EVAL Y ALIST))))

This conjecture can be simplified, using the abbreviation F-IMPLIES, to the
goal:

      (EQUAL (EVAL (F-OR (F-NOT X) Y) ALIST)
             (IMPLIES (EVAL X ALIST)
                      (EVAL Y ALIST))).

This simplifies, applying the lemmas ARG2-F-OR, ARG1-F-OR, and ARG-F-NOT, and
unfolding the functions EVAL and IMPLIES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EVAL-F-IMPLIES


(PROVE-LEMMA LIST-IMPLIES-REDUC
             (REWRITE)
             (EQUAL (LIST-IMPLIES FLIST EXP)
                    (MAKE-DISJUNCT (APPEND (LIS-NOT FLIST)
                                           (CONS EXP NIL)))))


     Call the conjecture *1.


     We will try to prove it by induction.  There are two plausible inductions.
However, they merge into one likely candidate induction.  We will induct
according to the following scheme:
      (AND (IMPLIES (NLISTP FLIST) (p FLIST EXP))
           (IMPLIES (AND (NOT (NLISTP FLIST))
                         (NLISTP (CDR FLIST)))
                    (p FLIST EXP))
           (IMPLIES (AND (NOT (NLISTP FLIST))
                         (NOT (NLISTP (CDR FLIST)))
                         (p (CDR FLIST) EXP))
                    (p FLIST EXP))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP inform us that the measure (COUNT FLIST) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates three new goals:

Case 3. (IMPLIES (NLISTP FLIST)
                 (EQUAL (LIST-IMPLIES FLIST EXP)
                        (MAKE-DISJUNCT (APPEND (LIS-NOT FLIST)
                                               (LIST EXP))))),

  which simplifies, appealing to the lemmas CAR-CONS and CDR-CONS, and
  unfolding NLISTP, LIST-IMPLIES, LIS-NOT, LISTP, APPEND, and MAKE-DISJUNCT,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NLISTP (CDR FLIST)))
                 (EQUAL (LIST-IMPLIES FLIST EXP)
                        (MAKE-DISJUNCT (APPEND (LIS-NOT FLIST)
                                               (LIST EXP))))),

  which simplifies, rewriting with the lemmas CDR-CONS, CAR-CONS, ARG1-F-OR,
  ARG2-F-OR, and F-OR-EQUAL, and expanding the functions NLISTP, LIST-IMPLIES,
  F-IMPLIES, LIS-NOT, APPEND, and MAKE-DISJUNCT, to the goal:

        (IMPLIES (AND (LISTP FLIST)
                      (NOT (LISTP (CDR FLIST))))
                 (EQUAL EXP
                        (MAKE-DISJUNCT (APPEND (LIS-NOT (CDR FLIST))
                                               (LIST EXP))))).

  But this further simplifies, applying CAR-CONS and CDR-CONS, and unfolding
  LIS-NOT, LISTP, APPEND, and MAKE-DISJUNCT, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (NLISTP (CDR FLIST)))
                      (EQUAL (LIST-IMPLIES (CDR FLIST) EXP)
                             (MAKE-DISJUNCT (APPEND (LIS-NOT (CDR FLIST))
                                                    (LIST EXP)))))
                 (EQUAL (LIST-IMPLIES FLIST EXP)
                        (MAKE-DISJUNCT (APPEND (LIS-NOT FLIST)
                                               (LIST EXP))))).

  This simplifies, applying CDR-CONS and CAR-CONS, and opening up the
  functions NLISTP, LIST-IMPLIES, F-IMPLIES, LIS-NOT, APPEND, and
  MAKE-DISJUNCT, to:

        T.


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


[ 0.0 0.0 0.0 ]

LIST-IMPLIES-REDUC


(TOGGLE G0874 F-IMPLIES T)

[ 0.0 0.0 0.0 ]

G0874


(PROVE-LEMMA APPEND-EXP-FORM-LIST
             (REWRITE)
             (IMPLIES (AND (FORM-LIST FLIST SYMBOLS)
                           (FORMULA EXP SYMBOLS))
                      (FORM-LIST (APPEND (LIS-NOT FLIST)
                                         (CONS EXP NIL))
                                 SYMBOLS)))


     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, both of
which are unflawed.  However, one of these is more likely than the other.  We
will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP FLIST)
                         (p (CDR FLIST) EXP SYMBOLS))
                    (p FLIST EXP SYMBOLS))
           (IMPLIES (NOT (LISTP FLIST))
                    (p FLIST EXP SYMBOLS))).
Linear arithmetic and the lemma CDR-LESSP can be used to establish that the
measure (COUNT FLIST) 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 FLIST)
                      (NOT (FORM-LIST (CDR FLIST) SYMBOLS))
                      (FORM-LIST FLIST SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORM-LIST (APPEND (LIS-NOT FLIST) (LIST EXP))
                            SYMBOLS)),

  which simplifies, unfolding the function FORM-LIST, to:

        T.

Case 2. (IMPLIES (AND (LISTP FLIST)
                      (FORM-LIST (APPEND (LIS-NOT (CDR FLIST))
                                         (LIST EXP))
                                 SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORM-LIST (APPEND (LIS-NOT FLIST) (LIST EXP))
                            SYMBOLS)),

  which simplifies, rewriting with the lemmas CDR-CONS, CAR-CONS, and
  FORMULA-F-NOT, and opening up FORM-LIST, LIS-NOT, and APPEND, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP FLIST))
                      (FORM-LIST FLIST SYMBOLS)
                      (FORMULA EXP SYMBOLS))
                 (FORM-LIST (APPEND (LIS-NOT FLIST) (LIST EXP))
                            SYMBOLS)),

  which simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS, and
  expanding FORM-LIST, LIS-NOT, LISTP, and APPEND, to:

        T.


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


[ 0.0 0.0 0.0 ]

APPEND-EXP-FORM-LIST


(PROVE-LEMMA EVAL-TAUTOLOGYP
             (REWRITE)
             (IMPLIES (EVAL (MAKE-DISJUNCT FLIST)
                            (FALSIFY-TAUT FLIST NIL))
                      (TAUTOLOGYP FLIST))
             ((DISABLE TAUTOLOGYP FORM-LIST FALSIFY-TAUT)
              (USE (TRUTHS-ARE-TAUTOLOGIES))))

WARNING:  Note that the rewrite rule EVAL-TAUTOLOGYP will be stored so as to
apply only to terms with the nonrecursive function symbol TAUTOLOGYP.


This simplifies, applying TRUTHS-ARE-TAUTOLOGIES, and unfolding the functions
NOT and IMPLIES, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EVAL-TAUTOLOGYP


(PROVE-LEMMA PROVES-LIST-FORM-LIST
             (REWRITE)
             (IMPLIES (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS)
                      (FORM-LIST FLIST SYMBOLS)))

WARNING:  Note that PROVES-LIST-FORM-LIST contains the free variables DEFNS,
GIVEN, and PFLIST which will be chosen by instantiating the hypothesis:
      (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS).




     Give the conjecture the name *1.


     Let us appeal to the induction principle.  Two inductions are suggested
by terms in the conjecture.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP FLIST)
                    (p FLIST SYMBOLS PFLIST GIVEN DEFNS))
           (IMPLIES (AND (NOT (NLISTP FLIST))
                         (p (CDR FLIST)
                            SYMBOLS
                            (CDR PFLIST)
                            GIVEN DEFNS))
                    (p FLIST SYMBOLS PFLIST GIVEN DEFNS))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT FLIST) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  Note,
however, the inductive instance chosen for PFLIST.  The above induction scheme
generates three new conjectures:

Case 3. (IMPLIES (AND (NLISTP FLIST)
                      (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
                 (FORM-LIST FLIST SYMBOLS)),

  which simplifies, expanding the functions NLISTP, PROVES-LIST, and FORM-LIST,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (NOT (PROVES-LIST (CDR PFLIST)
                                        (CDR FLIST)
                                        GIVEN DEFNS SYMBOLS))
                      (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
                 (FORM-LIST FLIST SYMBOLS)),

  which simplifies, opening up the functions NLISTP and PROVES-LIST, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP FLIST))
                      (FORM-LIST (CDR FLIST) SYMBOLS)
                      (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
                 (FORM-LIST FLIST SYMBOLS)),

  which simplifies, opening up the definitions of NLISTP, PROVES-LIST, and
  FORM-LIST, to the goal:

        (IMPLIES (AND (LISTP FLIST)
                      (FORM-LIST (CDR FLIST) SYMBOLS)
                      (PROVES (CAR PFLIST)
                              (CAR FLIST)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES-LIST (CDR PFLIST)
                                   (CDR FLIST)
                                   GIVEN DEFNS SYMBOLS))
                 (FORMULA (CAR FLIST) SYMBOLS)).

  But this again simplifies, applying PROVES-IS-FORMULA-AGAIN, to:

        T.


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


[ 0.0 0.0 0.0 ]

PROVES-LIST-FORM-LIST


(PROVE-LEMMA TAUT-CONSEQ-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA EXP SYMBOLS)
                           (TAUT-CONSEQ FLIST EXP)
                           (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
                      (PROVES (TAUTCONSEQ-PROOF FLIST EXP PFLIST)
                              EXP GIVEN DEFNS SYMBOLS)))

This formula can be simplified, using the abbreviations NOT-FALSIFY-TAUT, AND,
IMPLIES, TAUTOLOGYP, and TAUT-CONSEQ, to the new formula:

      (IMPLIES (AND (FORMULA EXP SYMBOLS)
                    (NOT (FALSIFY-TAUT (APPEND (LIS-NOT FLIST) (LIST EXP))
                                       NIL))
                    (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
               (PROVES (TAUTCONSEQ-PROOF FLIST EXP PFLIST)
                       EXP GIVEN DEFNS SYMBOLS)),

which simplifies, rewriting with TAUT-THM2, PROVES-LIST-FORM-LIST,
APPEND-EXP-FORM-LIST, NOT-FALSIFY-TAUT, FORM-LIST-APPEND-NIL,
LIST-IMPLIES-REDUC, and DETACH-RULE-CORR, and expanding TAUT-PROOF,
TAUTCONSEQ-PROOF, LISTP, and FORM-LIST, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TAUT-CONSEQ-PROVES


(TOGGLE G0276 TAUTCONSEQ-PROOF T)

[ 0.0 0.0 0.0 ]

G0276


(PROVE-LEMMA EVAL-TAUTCONSEQ
             (REWRITE)
             (IMPLIES (AND (FORM-LIST FLIST SYMBOLS)
                           (FORMULA EXP SYMBOLS)
                           (EVAL (MAKE-DISJUNCT (APPEND (LIS-NOT FLIST)
                                                        (CONS EXP NIL)))
                                 (FALSIFY-TAUT (APPEND (LIS-NOT FLIST)
                                                       (CONS EXP NIL))
                                               NIL)))
                      (TAUT-CONSEQ FLIST EXP))
             ((DISABLE TAUTOLOGYP APPEND FORMULA LIS-NOT EVAL-MAKE-DISJUNCT
                       FORM-LIST)
              (USE (EVAL-TAUTOLOGYP (FLIST (APPEND (LIS-NOT FLIST)
                                                   (CONS EXP NIL)))))))

WARNING:  Note that the rewrite rule EVAL-TAUTCONSEQ will be stored so as to
apply only to terms with the nonrecursive function symbol TAUT-CONSEQ.


WARNING:  Note that EVAL-TAUTCONSEQ contains the free variable SYMBOLS which
will be chosen by instantiating the hypothesis (FORM-LIST FLIST SYMBOLS).


This formula can be simplified, using the abbreviations AND, IMPLIES,
TAUT-CONSEQ, and NOT-EVAL-PROP-ATOMP, to:

      (IMPLIES
        (AND (IMPLIES (EVAL (MAKE-DISJUNCT (CONS EXP
                                                 (APPEND (LIS-NOT FLIST) NIL)))
                            (FALSIFY-TAUT (APPEND (LIS-NOT FLIST) (LIST EXP))
                                          NIL))
                      (TAUTOLOGYP (APPEND (LIS-NOT FLIST) (LIST EXP))))
             (FORM-LIST FLIST SYMBOLS)
             (FORMULA EXP SYMBOLS)
             (EVAL (MAKE-DISJUNCT (CONS EXP
                                        (APPEND (LIS-NOT FLIST) NIL)))
                   (FALSIFY-TAUT (APPEND (LIS-NOT FLIST) (LIST EXP))
                                 NIL)))
        (TAUTOLOGYP (APPEND (LIS-NOT FLIST) (LIST EXP)))),

which simplifies, rewriting with CAR-CONS, CDR-CONS, FORM-LIST-APPEND-NIL,
ARG2-F-OR, ARG1-F-OR, NOT-EVAL-PROP-ATOMP, and EVAL-TAUTOLOGYP, and opening up
the definitions of MAKE-DISJUNCT, IMPLIES, and EVAL, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

EVAL-TAUTCONSEQ


(TOGGLE G0277 TAUT-CONSEQ T)

[ 0.0 0.0 0.0 ]

G0277


(TOGGLE G0282 FALSIFY-TAUT T)

[ 0.0 0.0 0.0 ]

G0282


(PROVE-LEMMA EVAL-TAUTCONSEQ-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA EXP SYMBOLS)
                           (EVAL (MAKE-DISJUNCT (APPEND (LIS-NOT FLIST)
                                                        (CONS EXP NIL)))
                                 (FALSIFY-TAUT (APPEND (LIS-NOT FLIST)
                                                       (CONS EXP NIL))
                                               NIL))
                           (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
                      (PROVES (TAUTCONSEQ-PROOF FLIST EXP PFLIST)
                              EXP GIVEN DEFNS SYMBOLS))
             ((DISABLE FORMULA FORM-LIST PROVES-LIST-FORM-LIST)
              (USE (PROVES-LIST-FORM-LIST))))

This conjecture can be simplified, using the abbreviations AND, IMPLIES, and
NOT-EVAL-PROP-ATOMP, to the goal:

      (IMPLIES (AND (IMPLIES (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS)
                             (FORM-LIST FLIST SYMBOLS))
                    (FORMULA EXP SYMBOLS)
                    (EVAL (MAKE-DISJUNCT (CONS EXP
                                               (APPEND (LIS-NOT FLIST) NIL)))
                          (FALSIFY-TAUT (APPEND (LIS-NOT FLIST) (LIST EXP))
                                        NIL))
                    (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
               (PROVES (TAUTCONSEQ-PROOF FLIST EXP PFLIST)
                       EXP GIVEN DEFNS SYMBOLS)).

This simplifies, rewriting with CAR-CONS, CDR-CONS, FORM-LIST-APPEND-NIL,
EVAL-TAUTCONSEQ, NOT-EVAL-PROP-ATOMP, and TAUT-CONSEQ-PROVES, and unfolding
the functions IMPLIES and MAKE-DISJUNCT, to:

      (IMPLIES (AND (FORM-LIST FLIST SYMBOLS)
                    (FORMULA EXP SYMBOLS)
                    (LISTP (APPEND (LIS-NOT FLIST) NIL))
                    (EVAL (F-OR EXP
                                (MAKE-DISJUNCT (LIS-NOT FLIST)))
                          (FALSIFY-TAUT (APPEND (LIS-NOT FLIST) (LIST EXP))
                                        NIL))
                    (PROVES-LIST PFLIST FLIST GIVEN DEFNS SYMBOLS))
               (PROVES (TAUTCONSEQ-PROOF FLIST EXP PFLIST)
                       EXP GIVEN DEFNS SYMBOLS)).

However this again simplifies, appealing to the lemmas ARG2-F-OR, ARG1-F-OR,
EVAL-TAUTCONSEQ, CAR-CONS, CDR-CONS, FORM-LIST-APPEND-NIL, NOT-EVAL-PROP-ATOMP,
and TAUT-CONSEQ-PROVES, and unfolding EVAL and MAKE-DISJUNCT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

EVAL-TAUTCONSEQ-PROOF-PROVES


(TOGGLE G0283 TAUT-CONSEQ-PROVES T)

[ 0.0 0.0 0.0 ]

G0283


(DEFN F-IFF-MP-PROOF1
      (A B PF1 PF2)
      (TAUTCONSEQ-PROOF (LIST (F-IFF A B) A)
                        B
                        (LIST PF1 PF2)))

     From the definition we can conclude that:
      (OR (LITATOM (F-IFF-MP-PROOF1 A B PF1 PF2))
          (LISTP (F-IFF-MP-PROOF1 A B PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

F-IFF-MP-PROOF1


(PROVE-LEMMA F-IFF-MP-PROVES1
             (REWRITE)
             (IMPLIES (AND (PROVES PF1
                                   (F-IFF A B)
                                   GIVEN DEFNS SYMBOLS)
                           (PROVES PF2 A GIVEN DEFNS SYMBOLS))
                      (PROVES (F-IFF-MP-PROOF1 A B PF1 PF2)
                              B GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IFF A B))))))

This formula simplifies, rewriting with the lemmas FORMULA-F-IMPLIES,
FORMULA-F-NOT, FORMULA-F-OR, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR,
CAR-CONS, CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES, and unfolding the
definitions of F-AND, F-IFF, IMPLIES, F-IFF-MP-PROOF1, EQUAL, PROVES-LIST,
EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

F-IFF-MP-PROVES1


(TOGGLE G0284 F-IFF-MP-PROOF1 T)

[ 0.0 0.0 0.0 ]

G0284


(DEFN F-IFF-MP-PROOF2
      (A B PF1 PF2)
      (TAUTCONSEQ-PROOF (LIST (F-IFF A B) B)
                        A
                        (LIST PF1 PF2)))

     From the definition we can conclude that:
      (OR (LITATOM (F-IFF-MP-PROOF2 A B PF1 PF2))
          (LISTP (F-IFF-MP-PROOF2 A B PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

F-IFF-MP-PROOF2


(PROVE-LEMMA F-IFF-MP-PROVES2
             (REWRITE)
             (IMPLIES (AND (PROVES PF1
                                   (F-IFF A B)
                                   GIVEN DEFNS SYMBOLS)
                           (PROVES PF2 B GIVEN DEFNS SYMBOLS))
                      (PROVES (F-IFF-MP-PROOF2 A B PF1 PF2)
                              A GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IFF A B))))))

This formula simplifies, rewriting with the lemmas FORMULA-F-IMPLIES,
FORMULA-F-NOT, FORMULA-F-OR, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR,
CAR-CONS, CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES, and unfolding the
definitions of F-AND, F-IFF, IMPLIES, F-IFF-MP-PROOF2, EQUAL, PROVES-LIST,
EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

F-IFF-MP-PROVES2


(DEFN TRANS-IMPLIES-PROOF
      (A B C PF1 PF2)
      (TAUTCONSEQ-PROOF (LIST (F-IMPLIES A B) (F-IMPLIES B C))
                        (F-IMPLIES A C)
                        (LIST PF1 PF2)))

     Note that:
      (OR (LITATOM (TRANS-IMPLIES-PROOF A B C PF1 PF2))
          (LISTP (TRANS-IMPLIES-PROOF A B C PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

TRANS-IMPLIES-PROOF


(PROVE-LEMMA TRANSITIVITY-OF-IMPLIES
             (REWRITE)
             (IMPLIES (AND (PROVES PF1
                                   (F-IMPLIES A B)
                                   GIVEN DEFNS SYMBOLS)
                           (PROVES PF2
                                   (F-IMPLIES B C)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (TRANS-IMPLIES-PROOF A B C PF1 PF2)
                              (F-IMPLIES A C)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IMPLIES A B)))
                   (PROVES-IS-FORMULA (PF PF2)
                                      (EXP (F-IMPLIES B C))))))

This formula simplifies, applying FORMULA-F-IMPLIES, EVAL-F-IMPLIES, ARG-F-NOT,
ARG1-F-OR, ARG2-F-OR, CAR-CONS, CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES,
and opening up the definitions of IMPLIES, TRANS-IMPLIES-PROOF, EQUAL,
PROVES-LIST, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

TRANSITIVITY-OF-IMPLIES


(TOGGLE G0285 TRANS-IMPLIES-PROOF T)

[ 0.0 0.0 0.0 ]

G0285


(DEFN TRANS-F-IFF-PROOF
      (A B C PF1 PF2)
      (TAUTCONSEQ-PROOF (LIST (F-IFF A B) (F-IFF B C))
                        (F-IFF A C)
                        (LIST PF1 PF2)))

     Note that:
      (OR (LITATOM (TRANS-F-IFF-PROOF A B C PF1 PF2))
          (LISTP (TRANS-F-IFF-PROOF A B C PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

TRANS-F-IFF-PROOF


(PROVE-LEMMA TRANSITIVITY-OF-IFF
             (REWRITE)
             (IMPLIES (AND (PROVES PF1
                                   (F-IFF A B)
                                   GIVEN DEFNS SYMBOLS)
                           (PROVES PF2
                                   (F-IFF B C)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (TRANS-F-IFF-PROOF A B C PF1 PF2)
                              (F-IFF A C)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IFF A B)))
                   (PROVES-IS-FORMULA (PF PF2)
                                      (EXP (F-IFF B C))))))

This formula simplifies, applying FORMULA-F-IMPLIES, FORMULA-F-NOT,
FORMULA-F-OR, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS,
CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES, and opening up the definitions of
F-AND, F-IFF, IMPLIES, TRANS-F-IFF-PROOF, EQUAL, PROVES-LIST, EVAL,
MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.3 0.0 ]

TRANSITIVITY-OF-IFF


(TOGGLE G0286 TRANS-F-IFF-PROOF T)

[ 0.0 0.0 0.0 ]

G0286


(DEFN AND-SPLIT-PROOF1
      (A B PF1)
      (TAUTCONSEQ-PROOF (LIST (F-AND A B))
                        A
                        (LIST PF1)))

     Note that:
      (OR (LITATOM (AND-SPLIT-PROOF1 A B PF1))
          (LISTP (AND-SPLIT-PROOF1 A B PF1)))
is a theorem.




[ 0.0 0.0 0.0 ]

AND-SPLIT-PROOF1


(PROVE-LEMMA AND-SPLIT1
             (REWRITE)
             (IMPLIES (PROVES PF1
                              (F-AND A B)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (AND-SPLIT-PROOF1 A B PF1)
                              A GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-AND A B))))))

This conjecture can be simplified, using the abbreviations IMPLIES,
FORMULA-F-NOT, and F-AND, to:

      (IMPLIES (AND (IMPLIES (PROVES PF1
                                     (F-NOT (F-OR (F-NOT A) (F-NOT B)))
                                     GIVEN DEFNS SYMBOLS)
                             (FORMULA (F-OR (F-NOT A) (F-NOT B))
                                      SYMBOLS))
                    (PROVES PF1
                            (F-NOT (F-OR (F-NOT A) (F-NOT B)))
                            GIVEN DEFNS SYMBOLS))
               (PROVES (AND-SPLIT-PROOF1 A B PF1)
                       A GIVEN DEFNS SYMBOLS)).

This simplifies, rewriting with FORMULA-F-NOT, FORMULA-F-OR, ARG-F-NOT,
ARG1-F-OR, ARG2-F-OR, CAR-CONS, CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES,
and opening up the functions IMPLIES, F-AND, AND-SPLIT-PROOF1, EQUAL,
PROVES-LIST, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

AND-SPLIT1


(DEFN AND-SPLIT-PROOF2
      (A B PF1)
      (TAUTCONSEQ-PROOF (LIST (F-AND A B))
                        B
                        (LIST PF1)))

     Note that:
      (OR (LITATOM (AND-SPLIT-PROOF2 A B PF1))
          (LISTP (AND-SPLIT-PROOF2 A B PF1)))
is a theorem.




[ 0.0 0.0 0.0 ]

AND-SPLIT-PROOF2


(PROVE-LEMMA AND-SPLIT2
             (REWRITE)
             (IMPLIES (PROVES PF1
                              (F-AND A B)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (AND-SPLIT-PROOF2 A B PF1)
                              B GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-AND A B))))))

This conjecture can be simplified, using the abbreviations IMPLIES,
FORMULA-F-NOT, and F-AND, to:

      (IMPLIES (AND (IMPLIES (PROVES PF1
                                     (F-NOT (F-OR (F-NOT A) (F-NOT B)))
                                     GIVEN DEFNS SYMBOLS)
                             (FORMULA (F-OR (F-NOT A) (F-NOT B))
                                      SYMBOLS))
                    (PROVES PF1
                            (F-NOT (F-OR (F-NOT A) (F-NOT B)))
                            GIVEN DEFNS SYMBOLS))
               (PROVES (AND-SPLIT-PROOF2 A B PF1)
                       B GIVEN DEFNS SYMBOLS)).

This simplifies, rewriting with FORMULA-F-NOT, FORMULA-F-OR, ARG-F-NOT,
ARG1-F-OR, ARG2-F-OR, CAR-CONS, CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES,
and opening up the functions IMPLIES, F-AND, AND-SPLIT-PROOF2, EQUAL,
PROVES-LIST, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

AND-SPLIT2


(DEFN AND-JOIN-PROOF
      (A B PF1 PF2)
      (TAUTCONSEQ-PROOF (LIST A B)
                        (F-AND A B)
                        (LIST PF1 PF2)))

     From the definition we can conclude that:
      (OR (LITATOM (AND-JOIN-PROOF A B PF1 PF2))
          (LISTP (AND-JOIN-PROOF A B PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

AND-JOIN-PROOF


(PROVE-LEMMA AND-JOIN
             (REWRITE)
             (IMPLIES (AND (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                           (PROVES PF2 B GIVEN DEFNS SYMBOLS))
                      (PROVES (AND-JOIN-PROOF A B PF1 PF2)
                              (F-AND A B)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1) (EXP A))
                   (PROVES-IS-FORMULA (PF PF2)
                                      (EXP B)))))

This formula can be simplified, using the abbreviations IMPLIES, AND, and
F-AND, to:

      (IMPLIES (AND (IMPLIES (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                             (FORMULA A SYMBOLS))
                    (IMPLIES (PROVES PF2 B GIVEN DEFNS SYMBOLS)
                             (FORMULA B SYMBOLS))
                    (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                    (PROVES PF2 B GIVEN DEFNS SYMBOLS))
               (PROVES (AND-JOIN-PROOF A B PF1 PF2)
                       (F-NOT (F-OR (F-NOT A) (F-NOT B)))
                       GIVEN DEFNS SYMBOLS)),

which simplifies, rewriting with ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS,
CDR-CONS, FORMULA-F-OR, FORMULA-F-NOT, and EVAL-TAUTCONSEQ-PROOF-PROVES, and
expanding IMPLIES, F-AND, AND-JOIN-PROOF, EQUAL, PROVES-LIST, EVAL,
MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

AND-JOIN


(TOGGLE G0287 AND-SPLIT-PROOF1 T)

[ 0.0 0.0 0.0 ]

G0287


(TOGGLE G0288 AND-SPLIT-PROOF2 T)

[ 0.0 0.0 0.0 ]

G0288


(TOGGLE G0289 AND-JOIN-PROOF T)

[ 0.0 0.0 0.0 ]

G0289


(DEFN IFF-SPLIT-PROOF1
      (A B PF1)
      (TAUTCONSEQ-PROOF (LIST (F-IFF A B))
                        (F-IMPLIES A B)
                        (LIST PF1)))

     Note that:
      (OR (LITATOM (IFF-SPLIT-PROOF1 A B PF1))
          (LISTP (IFF-SPLIT-PROOF1 A B PF1)))
is a theorem.




[ 0.0 0.0 0.0 ]

IFF-SPLIT-PROOF1


(PROVE-LEMMA IFF-SPLIT1
             (REWRITE)
             (IMPLIES (PROVES PF1
                              (F-IFF A B)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (IFF-SPLIT-PROOF1 A B PF1)
                              (F-IMPLIES A B)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IFF A B))))))

This simplifies, applying the lemmas FORMULA-F-IMPLIES, FORMULA-F-NOT,
FORMULA-F-OR, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS,
CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES, and opening up the functions F-AND,
F-IFF, IMPLIES, IFF-SPLIT-PROOF1, EQUAL, PROVES-LIST, EVAL, MAKE-DISJUNCT,
APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.3 0.0 ]

IFF-SPLIT1


(TOGGLE G0290 IFF-SPLIT-PROOF1 T)

[ 0.0 0.0 0.0 ]

G0290


(DEFN IFF-SPLIT-PROOF2
      (A B PF1)
      (TAUTCONSEQ-PROOF (LIST (F-IFF A B))
                        (F-IMPLIES B A)
                        (LIST PF1)))

     Note that:
      (OR (LITATOM (IFF-SPLIT-PROOF2 A B PF1))
          (LISTP (IFF-SPLIT-PROOF2 A B PF1)))
is a theorem.




[ 0.0 0.0 0.0 ]

IFF-SPLIT-PROOF2


(PROVE-LEMMA IFF-SPLIT2
             (REWRITE)
             (IMPLIES (PROVES PF1
                              (F-IFF A B)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (IFF-SPLIT-PROOF2 A B PF1)
                              (F-IMPLIES B A)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IFF A B))))))

This simplifies, applying the lemmas FORMULA-F-IMPLIES, FORMULA-F-NOT,
FORMULA-F-OR, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS,
CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES, and opening up the functions F-AND,
F-IFF, IMPLIES, IFF-SPLIT-PROOF2, EQUAL, PROVES-LIST, EVAL, MAKE-DISJUNCT,
APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

IFF-SPLIT2


(TOGGLE G0291 IFF-SPLIT-PROOF2 T)

[ 0.0 0.0 0.0 ]

G0291


(DEFN IFF-JOIN-PROOF
      (A B PF1 PF2)
      (TAUTCONSEQ-PROOF (LIST (F-IMPLIES A B) (F-IMPLIES B A))
                        (F-IFF A B)
                        (LIST PF1 PF2)))

     Observe that:
      (OR (LITATOM (IFF-JOIN-PROOF A B PF1 PF2))
          (LISTP (IFF-JOIN-PROOF A B PF1 PF2)))
is a theorem.




[ 0.0 0.0 0.0 ]

IFF-JOIN-PROOF


(PROVE-LEMMA IFF-JOIN
             (REWRITE)
             (IMPLIES (AND (PROVES PF1
                                   (F-IMPLIES A B)
                                   GIVEN DEFNS SYMBOLS)
                           (PROVES PF2
                                   (F-IMPLIES B A)
                                   GIVEN DEFNS SYMBOLS))
                      (PROVES (IFF-JOIN-PROOF A B PF1 PF2)
                              (F-IFF A B)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IMPLIES A B))))))

This formula simplifies, applying the lemmas FORMULA-F-IMPLIES, EVAL-F-IMPLIES,
ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS, CDR-CONS, FORMULA-F-OR,
FORMULA-F-NOT, and EVAL-TAUTCONSEQ-PROOF-PROVES, and unfolding the functions
IMPLIES, F-IFF, F-AND, IFF-JOIN-PROOF, EQUAL, PROVES-LIST, EVAL, MAKE-DISJUNCT,
APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

IFF-JOIN


(TOGGLE G0292 IFF-JOIN-PROOF T)

[ 0.0 0.0 0.0 ]

G0292


(DEFN CONTRA-POS-PROOF1
      (A B PF1)
      (TAUTCONSEQ-PROOF (LIST (F-IMPLIES A B))
                        (F-IMPLIES (F-NOT B) (F-NOT A))
                        (LIST PF1)))

     From the definition we can conclude that:
      (OR (LITATOM (CONTRA-POS-PROOF1 A B PF1))
          (LISTP (CONTRA-POS-PROOF1 A B PF1)))
is a theorem.




[ 0.0 0.0 0.0 ]

CONTRA-POS-PROOF1


(PROVE-LEMMA CONTRA-POS1
             (REWRITE)
             (IMPLIES (PROVES PF1
                              (F-IMPLIES A B)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (CONTRA-POS-PROOF1 A B PF1)
                              (F-IMPLIES (F-NOT B) (F-NOT A))
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP (F-IMPLIES A B))))))

This formula simplifies, applying FORMULA-F-IMPLIES, EVAL-F-IMPLIES, ARG-F-NOT,
ARG1-F-OR, ARG2-F-OR, CAR-CONS, CDR-CONS, FORMULA-F-NOT, and
EVAL-TAUTCONSEQ-PROOF-PROVES, and unfolding the definitions of IMPLIES,
CONTRA-POS-PROOF1, EQUAL, PROVES-LIST, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and
LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

CONTRA-POS1


(TOGGLE G0293 CONTRA-POS-PROOF1 T)

[ 0.0 0.0 0.0 ]

G0293


(DEFN CONTRA-POS-PROOF2
      (A B PF)
      (TAUTCONSEQ-PROOF (LIST (F-IMPLIES (F-NOT B) (F-NOT A)))
                        (F-IMPLIES A B)
                        (LIST PF)))

     From the definition we can conclude that:
      (OR (LITATOM (CONTRA-POS-PROOF2 A B PF))
          (LISTP (CONTRA-POS-PROOF2 A B PF)))
is a theorem.




[ 0.0 0.0 0.0 ]

CONTRA-POS-PROOF2


(PROVE-LEMMA CONTRA-POS2
             (REWRITE)
             (IMPLIES (PROVES PF
                              (F-IMPLIES (F-NOT B) (F-NOT A))
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (CONTRA-POS-PROOF2 A B PF)
                              (F-IMPLIES A B)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (EXP (F-IMPLIES (F-NOT B) (F-NOT A)))))))

This conjecture simplifies, rewriting with FORMULA-F-NOT, FORMULA-F-IMPLIES,
EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS, CDR-CONS, and
EVAL-TAUTCONSEQ-PROOF-PROVES, and opening up IMPLIES, CONTRA-POS-PROOF2, EQUAL,
PROVES-LIST, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

CONTRA-POS2


(TOGGLE G0294 CONTRA-POS-PROOF2 T)

[ 0.0 0.0 0.0 ]

G0294


(DEFN IFF-COMMUTE-PROOF
      (A B PF)
      (TAUTCONSEQ-PROOF (LIST (F-IFF A B))
                        (F-IFF B A)
                        (LIST PF)))

     Note that:
      (OR (LITATOM (IFF-COMMUTE-PROOF A B PF))
          (LISTP (IFF-COMMUTE-PROOF A B PF)))
is a theorem.




[ 0.0 0.0 0.0 ]

IFF-COMMUTE-PROOF


(PROVE-LEMMA IFF-COMMUTE-PROOF-PROVES
             (REWRITE)
             (IMPLIES (PROVES PF
                              (F-IFF A B)
                              GIVEN DEFNS SYMBOLS)
                      (PROVES (IFF-COMMUTE-PROOF A B PF)
                              (F-IFF B A)
                              GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (EXP (F-IFF A B))))))

This simplifies, applying the lemmas FORMULA-F-IMPLIES, FORMULA-F-NOT,
FORMULA-F-OR, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS,
CDR-CONS, and EVAL-TAUTCONSEQ-PROOF-PROVES, and opening up the functions F-AND,
F-IFF, IMPLIES, IFF-COMMUTE-PROOF, EQUAL, PROVES-LIST, EVAL, MAKE-DISJUNCT,
APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

IFF-COMMUTE-PROOF-PROVES


(TOGGLE G0884 IFF-COMMUTE-PROOF T)

[ 0.0 0.0 0.0 ]

G0884


(PROVE-LEMMA FORMULA-F-IFF
             (REWRITE)
             (EQUAL (FORMULA (F-IFF A B) SYMBOLS)
                    (AND (FORMULA A SYMBOLS)
                         (FORMULA B SYMBOLS))))

This simplifies, appealing to the lemmas FORMULA-F-IMPLIES, FORMULA-F-NOT, and
FORMULA-F-OR, and opening up the definitions of F-AND, F-IFF, and AND, to two
new goals:

Case 2. (IMPLIES (AND (FORMULA A SYMBOLS)
                      (NOT (FORMULA B SYMBOLS)))
                 (EQUAL F (FORMULA B SYMBOLS))),

  which again simplifies, trivially, to:

        T.

Case 1. (IMPLIES (AND (FORMULA A SYMBOLS)
                      (FORMULA B SYMBOLS))
                 (EQUAL (FORMULA A SYMBOLS)
                        (FORMULA B SYMBOLS))).

  This again simplifies, clearly, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORMULA-F-IFF


(PROVE-LEMMA COLLECT-FREE-F-IFF
             (REWRITE)
             (EQUAL (MEMBER VAR
                            (COLLECT-FREE (F-IFF A B) 0))
                    (OR (MEMBER VAR (COLLECT-FREE A 0))
                        (MEMBER VAR (COLLECT-FREE B 0)))))

This conjecture simplifies, applying ARG-F-NOT, ARG2-F-OR, ARG1-F-OR,
COLLECT-FREE-F-IMPLIES, and MEMBER-APPEND, and unfolding the definitions of
F-AND, F-IFF, VARIABLE, EQUAL, COLLECT-FREE, and OR, to two new goals:

Case 2. (IMPLIES (AND (NOT (MEMBER VAR (COLLECT-FREE A 0)))
                      (NOT (MEMBER VAR (COLLECT-FREE B 0))))
                 (EQUAL (MEMBER VAR (COLLECT-FREE A 0))
                        (MEMBER VAR (COLLECT-FREE B 0)))),

  which again simplifies, obviously, to:

        T.

Case 1. (IMPLIES (AND (NOT (MEMBER VAR (COLLECT-FREE A 0)))
                      (MEMBER VAR (COLLECT-FREE B 0)))
                 (EQUAL T
                        (MEMBER VAR (COLLECT-FREE B 0)))).

  This again simplifies, trivially, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COLLECT-FREE-F-IFF


(PROVE-LEMMA COVERING-F-IFF
             (REWRITE)
             (EQUAL (COVERING (F-IFF A B) VAR 0)
                    (APPEND (APPEND (COVERING A VAR 0)
                                    (COVERING B VAR 0))
                            (APPEND (COVERING B VAR 0)
                                    (COVERING A VAR 0)))))

This formula simplifies, applying ARG-F-NOT, ARG2-F-OR, ARG1-F-OR, and
COVERING-F-IMPLIES, and expanding the functions F-AND, F-IFF, EQUAL, and
COVERING, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

COVERING-F-IFF


(PROVE-LEMMA EVAL-F-IFF
             (REWRITE)
             (EQUAL (EVAL (F-IFF A B) ALIST)
                    (EQUAL (EVAL A ALIST)
                           (EVAL B ALIST))))

This simplifies, appealing to the lemmas ARG-F-NOT, ARG2-F-OR, ARG1-F-OR, and
EVAL-F-IMPLIES, and opening up the definitions of F-AND, F-IFF, and EVAL, to
four new goals:

Case 4. (IMPLIES (AND (NOT (EQUAL (EVAL A ALIST) (EVAL B ALIST)))
                      (NOT (EVAL A ALIST)))
                 (EVAL B ALIST)),

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

        T.

Case 3. (IMPLIES (AND (NOT (EQUAL (EVAL A ALIST) (EVAL B ALIST)))
                      (EVAL A ALIST))
                 (NOT (EVAL B ALIST))),

  which again simplifies, expanding EQUAL, to:

        T.

Case 2. (IMPLIES (AND (EQUAL (EVAL A ALIST) (EVAL B ALIST))
                      (EVAL A ALIST))
                 (EVAL B ALIST)),

  which again simplifies, expanding the function EQUAL, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (EVAL A ALIST) (EVAL B ALIST))
                      (NOT (EVAL A ALIST)))
                 (NOT (EVAL B ALIST))),

  which again simplifies, opening up the definition of EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

EVAL-F-IFF


(TOGGLE G0885 F-IFF T)

[ 0.0 0.0 0.0 ]

G0885


(DEFN FORALL-INTRO-PROOF
    (A B VAR PF)
    (TAUTCONSEQ-PROOF (LIST (F-IMPLIES (FORSOME VAR (F-NOT B))
                                       (F-NOT A)))
                      (F-IMPLIES A
                                 (F-NOT (FORSOME VAR (F-NOT B))))
                      (LIST (FORSOME-INTRO-PROOF VAR
                                                 (F-NOT B)
                                                 (F-NOT A)
                                                 (CONTRA-POS-PROOF1 A B PF)))))

     Note that:
      (OR (LITATOM (FORALL-INTRO-PROOF A B VAR PF))
          (LISTP (FORALL-INTRO-PROOF A B VAR PF)))
is a theorem.




[ 0.0 0.0 0.0 ]

FORALL-INTRO-PROOF


(PROVE-LEMMA MEMB-MEMBER-NUMBERP
             (REWRITE)
             (IMPLIES (NUMBERP X)
                      (EQUAL (MEMB X Y) (MEMBER X Y))))


     Give the conjecture the name *1.


     We will try to prove it by induction.  There are two plausible inductions.
However, they merge into one likely candidate induction.  We will induct
according to the following scheme:
      (AND (IMPLIES (AND (LISTP Y) (EQL X (CAR Y)))
                    (p X Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (EQL X (CAR Y)))
                         (p X (CDR Y)))
                    (p X Y))
           (IMPLIES (NOT (LISTP Y)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates three new goals:

Case 3. (IMPLIES (AND (LISTP Y)
                      (EQL X (CAR Y))
                      (NUMBERP X))
                 (EQUAL (MEMB X Y) (MEMBER X Y))),

  which simplifies, applying NUMBERP-EQL and MEMB-MEMBER, and unfolding the
  functions OR, MEMBER, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (LISTP Y)
                      (NOT (EQL X (CAR Y)))
                      (EQUAL (MEMB X (CDR Y))
                             (MEMBER X (CDR Y)))
                      (NUMBERP X))
                 (EQUAL (MEMB X Y) (MEMBER X Y))).

  This simplifies, rewriting with the lemma NUMBERP-EQL, and expanding the
  functions OR, MEMB, and MEMBER, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Y)) (NUMBERP X))
                 (EQUAL (MEMB X Y) (MEMBER X Y))).

  This simplifies, expanding the functions MEMB, MEMBER, and EQUAL, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMB-MEMBER-NUMBERP


(PROVE-LEMMA FORALL-INTRO-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF
                                   (F-IMPLIES A B)
                                   GIVEN DEFNS SYMBOLS)
                           (VARIABLE VAR)
                           (NOT (MEMBER VAR
                                        (COLLECT-FREE (F-NOT A) 0)))
                           (EQUAL CONCL
                                  (F-IMPLIES A (FORALL VAR B))))
                      (PROVES (FORALL-INTRO-PROOF A B VAR PF)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (EXP (F-IMPLIES A B))))
              (DISABLE COLLECT-FREE PROVES-IS-FORMULA)))

This formula can be simplified, using the abbreviations NOT, AND, IMPLIES,
FORALL, and VARIABLE, to:

      (IMPLIES (AND (IMPLIES (PROVES PF
                                     (F-IMPLIES A B)
                                     GIVEN DEFNS SYMBOLS)
                             (FORMULA (F-IMPLIES A B) SYMBOLS))
                    (PROVES PF
                            (F-IMPLIES A B)
                            GIVEN DEFNS SYMBOLS)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (F-NOT A) 0)))
                    (EQUAL CONCL
                           (F-IMPLIES A
                                      (F-NOT (FORSOME VAR (F-NOT B))))))
               (PROVES (FORALL-INTRO-PROOF A B VAR PF)
                       CONCL GIVEN DEFNS SYMBOLS)),

which simplifies, applying FORMULA-F-IMPLIES, MEMB-MEMBER-NUMBERP, CONTRA-POS1,
FORSOME-INTRO-PROVES, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR,
CAR-CONS, CDR-CONS, FORMULA-FORSOME, FORMULA-F-NOT, and
EVAL-TAUTCONSEQ-PROOF-PROVES, and opening up IMPLIES, FORALL-INTRO-PROOF,
EQUAL, PROVES-LIST, VARIABLE, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT,
to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

FORALL-INTRO-PROOF-PROVES


(TOGGLE G0295 FORALL-INTRO-PROOF T)

[ 0.0 0.0 0.0 ]

G0295


(DEFN GENERALISE-PROOF
 (VAR A PF1)
 (TAUTCONSEQ-PROOF
  (LIST (F-IMPLIES (F-NOT (FORALL VAR A))
                   (FORALL VAR A)))
  (FORALL VAR A)
  (LIST
     (FORALL-INTRO-PROOF (F-NOT (FORALL VAR A))
                         A VAR
                         (TAUTCONSEQ-PROOF (LIST A)
                                           (F-IMPLIES (F-NOT (FORALL VAR A)) A)
                                           (LIST PF1))))))

     From the definition we can conclude that:
      (OR (LITATOM (GENERALISE-PROOF VAR A PF1))
          (LISTP (GENERALISE-PROOF VAR A PF1)))
is a theorem.




[ 0.0 0.0 0.0 ]

GENERALISE-PROOF


(PROVE-LEMMA COLLECT-FREE-FLG
             (REWRITE)
             (IMPLIES (NOT (NUMBERP FLG))
                      (EQUAL (COLLECT-FREE EXP FLG)
                             (COLLECT-FREE EXP 0))))


     Call the conjecture *1.


     We will try to prove it by induction.  There are two plausible inductions.
However, they merge into one likely candidate induction.  We will induct
according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG) (VARIABLE EXP))
                    (p EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) 0))
                    (p EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG1 EXP) 0)
                         (p (ARG2 EXP) 0))
                    (p EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (p (BODY EXP) 0))
                    (p EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) 1))
                    (p EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CAR EXP) 0)
                         (p (CDR EXP) 1))
                    (p EXP FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme generates eight new goals:

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, opening up the functions ZEROP, VARIABLE, COLLECT-FREE,
  and EQUAL, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, expanding ZEROP, VARIABLE, COLLECT-FREE, and EQUAL, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, expanding the functions ZEROP, VARIABLE, COLLECT-FREE, and
  EQUAL, to:

        T.

Case 5. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, opening up the definitions of ZEROP, VARIABLE,
  COLLECT-FREE, and EQUAL, to:

        T.

Case 4. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, expanding ZEROP, VARIABLE, COLLECT-FREE, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, opening up the definitions of ZEROP, VARIABLE,
  COLLECT-FREE, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, unfolding the function ZEROP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COLLECT-FREE EXP FLG)
                        (COLLECT-FREE EXP 0))),

  which simplifies, opening up ZEROP, to:

        T.


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


[ 0.0 0.0 0.0 ]

COLLECT-FREE-FLG


(PROVE-LEMMA COVERING-FLG
             (REWRITE)
             (IMPLIES (NOT (NUMBERP FLG))
                      (EQUAL (COVERING EXP VAR FLG)
                             (COVERING EXP VAR 0))))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest two inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG)
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG1 EXP) VAR 0)
                         (p (ARG2 EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (MEMB VAR (COLLECT-FREE EXP 0))
                         (p (BODY EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (MEMB VAR (COLLECT-FREE EXP 0))))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR 1))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CAR EXP) VAR 0)
                         (p (CDR EXP) VAR 1))
                    (p EXP VAR FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP VAR FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP can be used to show that the measure (COUNT EXP)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for FLG.  The
above induction scheme generates the following eight new conjectures:

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (F-NOTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, opening up the functions ZEROP, COVERING, and EQUAL, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, unfolding the functions ZEROP, COVERING, and EQUAL, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (MEMB VAR (COLLECT-FREE EXP 0))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, expanding ZEROP, COVERING, and EQUAL, to:

        T.

Case 5. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (MEMB VAR (COLLECT-FREE EXP 0)))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, opening up ZEROP, COVERING, and EQUAL, to:

        T.

Case 4. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, opening up the functions ZEROP, COVERING, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, unfolding ZEROP, COVERING, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, opening up ZEROP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (COVERING EXP VAR FLG)
                        (COVERING EXP VAR 0))).

  This simplifies, expanding the definition of ZEROP, to:

        T.


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


[ 0.0 0.0 0.0 ]

COVERING-FLG


(PROVE-LEMMA SUBST-FLG
             (REWRITE)
             (IMPLIES (NOT (NUMBERP FLG))
                      (EQUAL (SUBST EXP VAR TERM FLG)
                             (SUBST EXP VAR TERM 0))))


     Name the conjecture *1.


     We will try to 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 (ZEROP FLG)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR)))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG1 EXP) VAR TERM 0)
                         (p (ARG2 EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR))
                         (p (BODY EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR TERM 1))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CAR EXP) VAR TERM 0)
                         (p (CDR EXP) VAR TERM 1))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP establish that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme generates ten new conjectures:

Case 10.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, opening up ZEROP, VARIABLE, SUBST, and EQUAL, to:

        T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, unfolding ZEROP, VARIABLE, SUBST, and EQUAL, to:

        T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, expanding the definitions of ZEROP, VARIABLE, SUBST, and
  EQUAL, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, expanding ZEROP, VARIABLE, SUBST, and EQUAL, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQL (BIND EXP) VAR)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, rewriting with NUMBERP-EQL, and expanding ZEROP, VARIABLE,
  OR, SUBST, and EQUAL, to:

        T.

Case 5. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))).

  This simplifies, rewriting with NUMBERP-EQL, and expanding the definitions
  of ZEROP, VARIABLE, OR, SUBST, and EQUAL, to:

        T.

Case 4. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, expanding ZEROP, VARIABLE, SUBST, and EQUAL, to:

        T.

Case 3. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, unfolding the definitions of ZEROP, VARIABLE, SUBST, and
  EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, unfolding ZEROP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP FLG)))
                 (EQUAL (SUBST EXP VAR TERM FLG)
                        (SUBST EXP VAR TERM 0))),

  which simplifies, unfolding ZEROP, to:

        T.


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


[ 0.0 0.0 0.0 ]

SUBST-FLG


(PROVE-LEMMA VARIABLEP-COLLECT-FREE
             (REWRITE)
             (IMPLIES (NOT (VARIABLE VAR))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))))

This formula can be simplified, using the abbreviations NOT, IMPLIES, and
VARIABLE, to:

      (IMPLIES (NOT (NUMBERP VAR))
               (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

which we will name *1.


     We will appeal to induction.  There is only one plausible induction.  We
will induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG) (VARIABLE EXP))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p VAR (ARG EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p VAR (ARG2 EXP) 0)
                         (p VAR (ARG1 EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (p VAR (BODY EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p VAR (CDR EXP) 1))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p VAR EXP FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p VAR (CDR EXP) 1)
                         (p VAR (CAR EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p VAR EXP FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP can be used to show that the measure (COUNT EXP)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for FLG.  The
above induction scheme produces eight new conjectures:

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

  which simplifies, applying the lemmas CDR-CONS, CAR-CONS, and
  COLLECT-FREE-FLG, and expanding ZEROP, VARIABLE, EQUAL, COLLECT-FREE, MEMBER,
  and LISTP, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (ARG EXP) 0)))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

  which simplifies, applying the lemma COLLECT-FREE-FLG, and opening up the
  functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (ARG2 EXP) 0)))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (ARG1 EXP) 0)))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

  which simplifies, applying the lemmas MEMBER-APPEND and COLLECT-FREE-FLG,
  and opening up ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 5. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (BODY EXP) 0)))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

  which simplifies, applying the lemma COLLECT-FREE-FLG, and opening up ZEROP,
  VARIABLE, EQUAL, and COLLECT-FREE, to two new conjectures:

  Case 5.2.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (NOT (MEMBER VAR
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0))))),

    which again simplifies, clearly, to:

          (IMPLIES (AND (FORSOMEP EXP)
                        (NOT (MEMBER VAR
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0))))).

    Applying the lemma BIND-BODY-ELIM, replace EXP by (FORSOME Z X) to
    eliminate (BODY EXP) and (BIND EXP).  We rely upon the type restriction
    lemma noted when BIND was introduced to restrict the new variables.  This
    produces:

          (IMPLIES (AND (NUMBERP Z)
                        (NOT (MEMBER VAR (COLLECT-FREE X 0)))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR
                                (DEL Z (COLLECT-FREE X 0))))),

    which we generalize by replacing (COLLECT-FREE X 0) by Y.  The result is:

          (IMPLIES (AND (NUMBERP Z)
                        (NOT (MEMBER VAR Y))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR (DEL Z Y)))).

    Call the above conjecture *1.1.

  Case 5.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (NOT (MEMBER VAR
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0))))).

    Appealing to the lemma BIND-BODY-ELIM, we now replace EXP by (FORSOME Z X)
    to eliminate (BODY EXP) and (BIND EXP).  We rely upon the type restriction
    lemma noted when BIND was introduced to constrain the new variables.  This
    generates the formula:

          (IMPLIES (AND (NUMBERP Z)
                        (NOT (NUMBERP FLG))
                        (NOT (MEMBER VAR (COLLECT-FREE X 0)))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR
                                (DEL Z (COLLECT-FREE X 0))))).

    We will try to prove the above formula by generalizing it, replacing
    (COLLECT-FREE X 0) by Y.  We must thus prove:

          (IMPLIES (AND (NUMBERP Z)
                        (NOT (NUMBERP FLG))
                        (NOT (MEMBER VAR Y))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR (DEL Z Y)))).

    Eliminate the irrelevant term.  We thus obtain the new conjecture:

          (IMPLIES (AND (NUMBERP Z)
                        (NOT (MEMBER VAR Y))
                        (NOT (NUMBERP VAR)))
                   (NOT (MEMBER VAR (DEL Z Y)))),

    which we will name *1.2.

Case 4. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (CDR EXP) 1)))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))).

  This simplifies, rewriting with COLLECT-FREE-FLG, and unfolding the
  functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 3. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

  which simplifies, applying the lemma COLLECT-FREE-FLG, and opening up the
  functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE, LISTP, and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (CDR EXP) 1)))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (CAR EXP) 0)))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

  which simplifies, appealing to the lemma MEMBER-APPEND, and expanding ZEROP
  and COLLECT-FREE, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))),

  which simplifies, unfolding the functions ZEROP, COLLECT-FREE, LISTP, and
  MEMBER, to:

        T.


     So let us turn our attention to:

      (IMPLIES (AND (NUMBERP Z)
                    (NOT (MEMBER VAR Y))
                    (NOT (NUMBERP VAR)))
               (NOT (MEMBER VAR (DEL Z Y)))),

which is formula *1.2 above.  But this conjecture is subsumed by the subgoal
we named *1.1 above.


     So let us turn our attention to:

      (IMPLIES (AND (NUMBERP Z)
                    (NOT (MEMBER VAR Y))
                    (NOT (NUMBERP VAR)))
               (NOT (MEMBER VAR (DEL Z Y)))),

which is formula *1.1 above.  Let us appeal to the induction principle.  Two
inductions are suggested by terms in the conjecture.  However, they merge into
one likely candidate induction.  We will induct according to the following
scheme:
      (AND (IMPLIES (NLISTP Y) (p VAR Z Y))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (EQUAL VAR (CAR Y)))
                    (p VAR Z Y))
           (IMPLIES (AND (NOT (NLISTP Y))
                         (NOT (EQUAL VAR (CAR Y)))
                         (p VAR Z (CDR Y)))
                    (p VAR Z 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 produces four new conjectures:

Case 4. (IMPLIES (AND (NLISTP Y)
                      (NUMBERP Z)
                      (NOT (MEMBER VAR Y))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (DEL Z Y)))),

  which simplifies, opening up NLISTP, MEMBER, and DEL, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Y))
                      (EQUAL VAR (CAR Y))
                      (NUMBERP Z)
                      (NOT (MEMBER VAR Y))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (DEL Z Y)))),

  which simplifies, unfolding the definitions of NLISTP and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL VAR (CAR Y)))
                      (MEMBER VAR (CDR Y))
                      (NUMBERP Z)
                      (NOT (MEMBER VAR Y))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (DEL Z Y)))),

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

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP Y))
                      (NOT (EQUAL VAR (CAR Y)))
                      (NOT (MEMBER VAR (DEL Z (CDR Y))))
                      (NUMBERP Z)
                      (NOT (MEMBER VAR Y))
                      (NOT (NUMBERP VAR)))
                 (NOT (MEMBER VAR (DEL Z Y)))),

  which simplifies, appealing to the lemma NUMBERP-EQL, and expanding NLISTP,
  MEMBER, DEL, and OR, to:

        (IMPLIES (AND (LISTP Y)
                      (NOT (EQUAL VAR (CAR Y)))
                      (NOT (MEMBER VAR (DEL Z (CDR Y))))
                      (NUMBERP Z)
                      (NOT (MEMBER VAR (CDR Y)))
                      (NOT (NUMBERP VAR))
                      (NOT (EQUAL Z (CAR Y))))
                 (NOT (MEMBER VAR
                              (CONS (CAR Y) (DEL Z (CDR Y)))))).

  But this again simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
  and expanding MEMBER, 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 ]

VARIABLEP-COLLECT-FREE


(PROVE-LEMMA MEMBER-DEL
             (REWRITE)
             (NOT (MEMBER X (DEL X Y))))


     Name the conjecture *1.


     Let us appeal to the induction principle.  There is only one suggested
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP Y)
                         (EQL X (CAR Y))
                         (p X (CDR Y)))
                    (p X Y))
           (IMPLIES (AND (LISTP Y)
                         (NOT (EQL X (CAR Y)))
                         (p X (CDR Y)))
                    (p X Y))
           (IMPLIES (NOT (LISTP Y)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT Y)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme leads to three new conjectures:

Case 3. (IMPLIES (AND (LISTP Y)
                      (EQL X (CAR Y))
                      (NOT (MEMBER X (DEL X (CDR Y)))))
                 (NOT (MEMBER X (DEL X Y)))),

  which simplifies, expanding DEL, to:

        T.

Case 2. (IMPLIES (AND (LISTP Y)
                      (NOT (EQL X (CAR Y)))
                      (NOT (MEMBER X (DEL X (CDR Y)))))
                 (NOT (MEMBER X (DEL X Y)))),

  which simplifies, rewriting with CDR-CONS and CAR-CONS, and expanding the
  functions DEL and MEMBER, to:

        (IMPLIES (AND (LISTP Y)
                      (NOT (EQL X (CAR Y)))
                      (NOT (MEMBER X (DEL X (CDR Y)))))
                 (NOT (EQUAL X (CAR Y)))),

  which again simplifies, rewriting with EQUAL-EQL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP Y))
                 (NOT (MEMBER X (DEL X Y)))).

  This simplifies, unfolding DEL and MEMBER, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMBER-DEL


(PROVE-LEMMA FORSOME-COLLECT-FREE-REDUC
             (REWRITE)
             (IMPLIES (NUMBERP VAR)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (FORSOME VAR EXP) 0)))))

This simplifies, appealing to the lemmas BODY-FORSOME, BIND-FORSOME, and
MEMBER-DEL, and opening up the definitions of VARIABLE, EQUAL, and
COLLECT-FREE, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

FORSOME-COLLECT-FREE-REDUC


(PROVE-LEMMA GENERALISE-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                           (VARIABLE VAR)
                           (EQUAL CONCL (FORALL VAR A)))
                      (PROVES (GENERALISE-PROOF VAR A PF1)
                              CONCL GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP A)))))

This formula can be simplified, using the abbreviations AND, IMPLIES, FORALL,
and VARIABLE, to:

      (IMPLIES (AND (IMPLIES (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                             (FORMULA A SYMBOLS))
                    (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                    (NUMBERP VAR)
                    (EQUAL CONCL
                           (F-NOT (FORSOME VAR (F-NOT A)))))
               (PROVES (GENERALISE-PROOF VAR A PF1)
                       CONCL GIVEN DEFNS SYMBOLS)),

which simplifies, applying the lemmas FORALL-INTRO-PROOF-PROVES,
FORMULA-F-IMPLIES, EVAL-TAUTCONSEQ-PROOF-PROVES, BODY-FORSOME, BIND-FORSOME,
MEMBER-DEL, EVAL-F-IMPLIES, EVAL-MEMBER, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR,
CAR-CONS, CDR-CONS, FORMULA-FORSOME, and FORMULA-F-NOT, and unfolding the
definitions of IMPLIES, FORALL, GENERALISE-PROOF, EQUAL, VARIABLE,
COLLECT-FREE, PROVES-LIST, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.4 0.0 ]

GENERALISE-PROOF-PROVES


(TOGGLE G0300 GENERALISE-PROOF T)

[ 0.0 0.0 0.0 ]

G0300


(DEFN SUBST-RULE-PROOF
      (A VAR TERM PF1)
      (TAUTCONSEQ-PROOF (LIST (F-IMPLIES (F-NOT (SUBST A VAR TERM 0))
                                         (FORSOME VAR (F-NOT A)))
                              (F-NOT (FORSOME VAR (F-NOT A))))
                        (SUBST A VAR TERM 0)
                        (LIST (SUBST-AXIOM-PROOF (F-NOT A) VAR TERM)
                              (GENERALISE-PROOF VAR A PF1))))

     Note that:
      (OR (LITATOM (SUBST-RULE-PROOF A VAR TERM PF1))
          (LISTP (SUBST-RULE-PROOF A VAR TERM PF1)))
is a theorem.




[ 0.0 0.0 0.0 ]

SUBST-RULE-PROOF


(PROVE-LEMMA SUBST-RULE-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (VARIABLE VAR)
                           (TERMP TERM 0 SYMBOLS)
                           (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                           (FREE-FOR A VAR TERM 0)
                           (EQUAL A-PRIME (SUBST A VAR TERM 0)))
                      (PROVES (SUBST-RULE-PROOF A VAR TERM PF1)
                              A-PRIME GIVEN DEFNS SYMBOLS))
             ((USE (PROVES-IS-FORMULA (PF PF1)
                                      (EXP A)))))

This formula can be simplified, using the abbreviations AND, IMPLIES, FREE-FOR,
and VARIABLE, to the new goal:

      (IMPLIES (AND (IMPLIES (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                             (FORMULA A SYMBOLS))
                    (NUMBERP VAR)
                    (TERMP TERM 0 SYMBOLS)
                    (PROVES PF1 A GIVEN DEFNS SYMBOLS)
                    (NIL-INTERSECT (COVERING A VAR 0)
                                   (COLLECT-FREE TERM 0))
                    (EQUAL A-PRIME (SUBST A VAR TERM 0)))
               (PROVES (SUBST-RULE-PROOF A VAR TERM PF1)
                       A-PRIME GIVEN DEFNS SYMBOLS)),

which simplifies, applying GENERALISE-PROOF-PROVES, FORMULA-F-NOT,
SUBST-AXIOM-PROVES, EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS,
CDR-CONS, SUBST-FORMULA, and EVAL-TAUTCONSEQ-PROOF-PROVES, and expanding the
functions IMPLIES, SUBST-RULE-PROOF, FORALL, PROVES-LIST, FREE-FOR, COVERING,
SUBST, EQUAL, VARIABLE, EVAL, MAKE-DISJUNCT, APPEND, LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

SUBST-RULE-PROOF-PROVES


(TOGGLE G0886 SUBST-RULE-PROOF T)

[ 0.0 0.0 0.0 ]

G0886


(PROVE-LEMMA SUBST-VAR-VAR
             (REWRITE)
             (EQUAL (SUBST EXP VAR VAR FLG) EXP))


     Name the conjecture *1.


     Let us appeal to the induction principle.  There is only one suggested
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR)))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG2 EXP) VAR 0)
                         (p (ARG1 EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR))
                         (p (BODY EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR 1))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CDR EXP) VAR 1)
                         (p (CAR EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP VAR FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme leads to ten new conjectures:

Case 10.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)),

  which simplifies, applying SUBST-FLG, and unfolding the functions ZEROP,
  VARIABLE, EQUAL, and SUBST, to:

        T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)).

  This simplifies, applying SUBST-FLG, and opening up the definitions of ZEROP,
  VARIABLE, EQUAL, and SUBST, to:

        T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (EQUAL (SUBST (ARG EXP) VAR VAR 0)
                             (ARG EXP)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)),

  which simplifies, rewriting with F-NOT-ARG and SUBST-FLG, and opening up
  ZEROP, VARIABLE, EQUAL, and SUBST, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (EQUAL (SUBST (ARG2 EXP) VAR VAR 0)
                             (ARG2 EXP))
                      (EQUAL (SUBST (ARG1 EXP) VAR VAR 0)
                             (ARG1 EXP)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)).

  This simplifies, applying F-OR-ARG1-ARG2 and SUBST-FLG, and unfolding the
  functions ZEROP, VARIABLE, EQUAL, and SUBST, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQL (BIND EXP) VAR))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)),

  which simplifies, applying the lemmas NUMBERP-EQL and SUBST-FLG, and
  expanding ZEROP, VARIABLE, OR, EQUAL, and SUBST, to:

        T.

Case 5. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (EQUAL (SUBST (BODY EXP) VAR VAR 0)
                             (BODY EXP)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)),

  which simplifies, rewriting with NUMBERP-EQL, FORSOME-BIND-BODY, and
  SUBST-FLG, and expanding the definitions of ZEROP, VARIABLE, OR, EQUAL, and
  SUBST, to:

        T.

Case 4. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (EQUAL (SUBST (CDR EXP) VAR VAR 1)
                             (CDR EXP)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)).

  This simplifies, applying CONS-CAR-CDR and SUBST-FLG, and expanding the
  definitions of ZEROP, VARIABLE, EQUAL, and SUBST, to:

        T.

Case 3. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)),

  which simplifies, rewriting with SUBST-FLG, and expanding ZEROP, VARIABLE,
  EQUAL, and SUBST, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL (SUBST (CDR EXP) VAR VAR 1)
                             (CDR EXP))
                      (EQUAL (SUBST (CAR EXP) VAR VAR 0)
                             (CAR EXP)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)).

  This simplifies, rewriting with CONS-CAR-CDR, and unfolding the definitions
  of ZEROP and SUBST, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP)))
                 (EQUAL (SUBST EXP VAR VAR FLG) EXP)),

  which simplifies, unfolding ZEROP and SUBST, to:

        T.


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


[ 0.0 0.0 0.0 ]

SUBST-VAR-VAR


(DEFN E-INTRO-PROOF
      (VAR C)
      (SUBST-AXIOM-PROOF C VAR VAR))

     Observe that (LISTP (E-INTRO-PROOF VAR C)) is a theorem.




[ 0.0 0.0 0.0 ]

E-INTRO-PROOF


(PROVE-LEMMA APPEND-NIL-INTERSECT
             (REWRITE)
             (EQUAL (NIL-INTERSECT (APPEND X Y) Z)
                    (AND (NIL-INTERSECT X Z)
                         (NIL-INTERSECT Y Z))))

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

Case 2. (IMPLIES (NOT (NIL-INTERSECT X Z))
                 (EQUAL (NIL-INTERSECT (APPEND X Y) Z)
                        F)),

  which again simplifies, clearly, to:

        (IMPLIES (NOT (NIL-INTERSECT X Z))
                 (NOT (NIL-INTERSECT (APPEND X Y) Z))),

  which we will name *1.

Case 1. (IMPLIES (NIL-INTERSECT X Z)
                 (EQUAL (NIL-INTERSECT (APPEND X Y) Z)
                        (NIL-INTERSECT 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 (NIL-INTERSECT (APPEND X Y) Z)
       (AND (NIL-INTERSECT X Z)
            (NIL-INTERSECT Y Z))),

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 X) (p (CDR X) Y Z))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP X)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme produces two new
conjectures:

Case 2. (IMPLIES (AND (LISTP X)
                      (EQUAL (NIL-INTERSECT (APPEND (CDR X) Y) Z)
                             (AND (NIL-INTERSECT (CDR X) Z)
                                  (NIL-INTERSECT Y Z))))
                 (EQUAL (NIL-INTERSECT (APPEND X Y) Z)
                        (AND (NIL-INTERSECT X Z)
                             (NIL-INTERSECT Y Z)))),

  which simplifies, applying the lemmas CDR-CONS and CAR-CONS, and expanding
  AND, APPEND, NIL-INTERSECT, and EQUAL, to:

        T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (EQUAL (NIL-INTERSECT (APPEND X Y) Z)
                        (AND (NIL-INTERSECT X Z)
                             (NIL-INTERSECT Y Z)))),

  which simplifies, opening up the definitions of APPEND, NIL-INTERSECT, and
  AND, to:

        T.


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


[ 0.0 0.1 0.0 ]

APPEND-NIL-INTERSECT


(PROVE-LEMMA VAR-COVERING-VAR
             (REWRITE)
             (NOT (MEMBER VAR (COVERING EXP VAR FLG))))


     Give the conjecture the name *1.


     We will appeal to induction.  There is only one plausible induction.  We
will induct according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG)
                         (F-NOTP EXP)
                         (p VAR (ARG EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p VAR (ARG2 EXP) 0)
                         (p VAR (ARG1 EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (MEMB VAR (COLLECT-FREE EXP 0))
                         (p VAR (BODY EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (MEMB VAR (COLLECT-FREE EXP 0))))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p VAR (CDR EXP) 1))
                    (p VAR EXP FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p VAR EXP FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p VAR (CDR EXP) 1)
                         (p VAR (CAR EXP) 0))
                    (p VAR EXP FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p VAR EXP FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme produces the following eight new conjectures:

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (F-NOTP EXP)
                      (NOT (MEMBER VAR
                                   (COVERING (ARG EXP) VAR 0))))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))).

  This simplifies, applying COVERING-FLG, and opening up the functions ZEROP,
  EQUAL, and COVERING, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (MEMBER VAR
                                   (COVERING (ARG2 EXP) VAR 0)))
                      (NOT (MEMBER VAR
                                   (COVERING (ARG1 EXP) VAR 0))))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))),

  which simplifies, rewriting with MEMBER-APPEND and COVERING-FLG, and opening
  up ZEROP, EQUAL, and COVERING, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (MEMB VAR (COLLECT-FREE EXP 0))
                      (NOT (MEMBER VAR
                                   (COVERING (BODY EXP) VAR 0))))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))).

  This simplifies, rewriting with CDR-CONS, CAR-CONS, and COVERING-FLG, and
  expanding ZEROP, VARIABLE, EQUAL, COLLECT-FREE, COVERING, and MEMBER, to two
  new goals:

  Case 6.2.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (MEMB VAR
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (COVERING (BODY EXP) VAR 0))))
                   (NOT (EQUAL VAR (BIND EXP)))),

    which again simplifies, applying the lemmas MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 6.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (MEMB VAR
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (COVERING (BODY EXP) VAR 0))))
                   (NOT (EQUAL VAR (BIND EXP)))),

    which again simplifies, rewriting with MEMBER-DEL and MEMB-MEMBER-NUMBERP,
    to:

          T.

Case 5. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (MEMB VAR (COLLECT-FREE EXP 0))))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))).

  This simplifies, applying the lemma COVERING-FLG, and expanding the
  functions ZEROP, EQUAL, COVERING, LISTP, and MEMBER, to:

        T.

Case 4. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (MEMBER VAR
                                   (COVERING (CDR EXP) VAR 1))))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))).

  This simplifies, rewriting with COVERING-FLG, and unfolding the functions
  ZEROP, EQUAL, and COVERING, to:

        T.

Case 3. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP)))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))),

  which simplifies, applying COVERING-FLG, and expanding the functions ZEROP,
  EQUAL, COVERING, LISTP, and MEMBER, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (MEMBER VAR
                                   (COVERING (CDR EXP) VAR 1)))
                      (NOT (MEMBER VAR
                                   (COVERING (CAR EXP) VAR 0))))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))).

  This simplifies, rewriting with MEMBER-APPEND, and unfolding ZEROP and
  COVERING, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP)))
                 (NOT (MEMBER VAR (COVERING EXP VAR FLG)))),

  which simplifies, opening up ZEROP, COVERING, LISTP, and MEMBER, to:

        T.


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


[ 0.0 0.0 0.0 ]

VAR-COVERING-VAR


(PROVE-LEMMA NIL-INTERSECT-CONS
             (REWRITE)
             (IMPLIES (AND (NOT (MEMB Z X))
                           (NIL-INTERSECT X Y))
                      (NIL-INTERSECT X (CONS Z Y))))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest three inductions.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP X) (EQL Z (CAR X)))
                    (p X Z Y))
           (IMPLIES (AND (LISTP X)
                         (NOT (EQL Z (CAR X)))
                         (p (CDR X) Z Y))
                    (p X Z Y))
           (IMPLIES (NOT (LISTP X)) (p X Z Y))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates the
following five new conjectures:

Case 5. (IMPLIES (AND (LISTP X)
                      (EQL Z (CAR X))
                      (NOT (MEMB Z X))
                      (NIL-INTERSECT X Y))
                 (NIL-INTERSECT X (CONS Z Y))).

  This simplifies, opening up the function MEMB, to:

        T.

Case 4. (IMPLIES (AND (LISTP X)
                      (NOT (EQL Z (CAR X)))
                      (MEMB Z (CDR X))
                      (NOT (MEMB Z X))
                      (NIL-INTERSECT X Y))
                 (NIL-INTERSECT X (CONS Z Y))).

  This simplifies, unfolding the function MEMB, to:

        T.

Case 3. (IMPLIES (AND (LISTP X)
                      (NOT (EQL Z (CAR X)))
                      (NOT (NIL-INTERSECT (CDR X) Y))
                      (NOT (MEMB Z X))
                      (NIL-INTERSECT X Y))
                 (NIL-INTERSECT X (CONS Z Y))).

  This simplifies, expanding MEMB and NIL-INTERSECT, to:

        T.

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (EQL Z (CAR X)))
                      (NIL-INTERSECT (CDR X) (CONS Z Y))
                      (NOT (MEMB Z X))
                      (NIL-INTERSECT X Y))
                 (NIL-INTERSECT X (CONS Z Y))).

  This simplifies, rewriting with the lemmas CDR-CONS, EQL-COMM, and CAR-CONS,
  and expanding the functions MEMB and NIL-INTERSECT, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (MEMB Z X))
                      (NIL-INTERSECT X Y))
                 (NIL-INTERSECT X (CONS Z Y))).

  This simplifies, unfolding the functions MEMB and NIL-INTERSECT, to:

        T.


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


[ 0.0 0.0 0.0 ]

NIL-INTERSECT-CONS


(PROVE-LEMMA NIL-INTERSECT-NIL
             (REWRITE)
             (NIL-INTERSECT X NIL))


     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 (LISTP X) (p (CDR X)))
                    (p X))
           (IMPLIES (NOT (LISTP X)) (p X))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT X) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme leads to two new
goals:

Case 2. (IMPLIES (AND (LISTP X)
                      (NIL-INTERSECT (CDR X) NIL))
                 (NIL-INTERSECT X NIL)),

  which simplifies, unfolding the definitions of NIL-INTERSECT, LISTP, and
  MEMB, to:

        T.

Case 1. (IMPLIES (NOT (LISTP X))
                 (NIL-INTERSECT X NIL)),

  which simplifies, opening up NIL-INTERSECT, to:

        T.


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


[ 0.0 0.0 0.0 ]

NIL-INTERSECT-NIL


(PROVE-LEMMA E-INTRO-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA C SYMBOLS)
                           (VARIABLE VAR))
                      (PROVES (E-INTRO-PROOF VAR C)
                              (F-IMPLIES C (FORSOME VAR C))
                              GIVEN DEFNS SYMBOLS)))

This conjecture can be simplified, using the abbreviations AND, IMPLIES, and
VARIABLE, to:

      (IMPLIES (AND (FORMULA C SYMBOLS)
                    (NUMBERP VAR))
               (PROVES (E-INTRO-PROOF VAR C)
                       (F-IMPLIES C (FORSOME VAR C))
                       GIVEN DEFNS SYMBOLS)).

This simplifies, rewriting with the lemmas NIL-INTERSECT-NIL,
MEMB-MEMBER-NUMBERP, VAR-COVERING-VAR, NIL-INTERSECT-CONS, SUBST-VAR-VAR, and
SUBST-AXIOM-PROVES, and expanding the functions E-INTRO-PROOF, FREE-FOR,
COLLECT-FREE, TERMP, EQUAL, and VARIABLE, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

E-INTRO-PROOF-PROVES


(TOGGLE G0306 E-INTRO-PROOF T)

[ 0.0 0.0 0.0 ]

G0306


(DEFN ALL-ELIM-PROOF
      (VAR C)
      (TAUTCONSEQ-PROOF (LIST (F-IMPLIES (F-NOT C)
                                         (FORSOME VAR (F-NOT C))))
                        (F-IMPLIES (FORALL VAR C) C)
                        (LIST (E-INTRO-PROOF VAR (F-NOT C)))))

     Note that:
      (OR (LITATOM (ALL-ELIM-PROOF VAR C))
          (LISTP (ALL-ELIM-PROOF VAR C)))
is a theorem.




[ 0.0 0.0 0.0 ]

ALL-ELIM-PROOF


(PROVE-LEMMA ALL-ELIM-PROOF-PROVES
             (REWRITE)
             (IMPLIES (AND (FORMULA C SYMBOLS)
                           (VARIABLE VAR))
                      (PROVES (ALL-ELIM-PROOF VAR C)
                              (F-IMPLIES (FORALL VAR C) C)
                              GIVEN DEFNS SYMBOLS)))

This conjecture can be simplified, using the abbreviations AND, IMPLIES,
FORALL, and VARIABLE, to:

      (IMPLIES (AND (FORMULA C SYMBOLS)
                    (NUMBERP VAR))
               (PROVES (ALL-ELIM-PROOF VAR C)
                       (F-IMPLIES (F-NOT (FORSOME VAR (F-NOT C)))
                                  C)
                       GIVEN DEFNS SYMBOLS)).

This simplifies, rewriting with the lemmas E-INTRO-PROOF-PROVES,
EVAL-F-IMPLIES, ARG-F-NOT, ARG1-F-OR, ARG2-F-OR, CAR-CONS, CDR-CONS,
FORMULA-F-IMPLIES, FORMULA-FORSOME, FORMULA-F-NOT, and
EVAL-TAUTCONSEQ-PROOF-PROVES, and expanding the functions FORALL,
ALL-ELIM-PROOF, EQUAL, PROVES-LIST, VARIABLE, EVAL, MAKE-DISJUNCT, APPEND,
LISTP, and LIS-NOT, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ALL-ELIM-PROOF-PROVES


(TOGGLE G0307 ALL-ELIM-PROOF T)

[ 0.0 0.0 0.0 ]

G0307


(PROVE-LEMMA MEMBER-DEL1
             (REWRITE)
             (IMPLIES (NOT (EQL X Y))
                      (EQUAL (MEMBER X (DEL Y Z))
                             (MEMBER X Z))))


     Give the conjecture the name *1.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest four 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 Z)
                         (EQL Y (CAR Z))
                         (p X Y (CDR Z)))
                    (p X Y Z))
           (IMPLIES (AND (LISTP Z)
                         (NOT (EQL Y (CAR Z)))
                         (p X Y (CDR Z)))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP Z)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP can be used to show that the measure
(COUNT Z) decreases according to the well-founded relation LESSP in each
induction step of the scheme.  The above induction scheme generates the
following three new conjectures:

Case 3. (IMPLIES (AND (LISTP Z)
                      (EQL Y (CAR Z))
                      (EQUAL (MEMBER X (DEL Y (CDR Z)))
                             (MEMBER X (CDR Z)))
                      (NOT (EQL X Y)))
                 (EQUAL (MEMBER X (DEL Y Z))
                        (MEMBER X Z))).

  This simplifies, opening up the functions DEL and MEMBER, to:

        (IMPLIES (AND (LISTP Z)
                      (EQL Y (CAR Z))
                      (EQUAL (MEMBER X (DEL Y (CDR Z)))
                             (MEMBER X (CDR Z)))
                      (NOT (EQL X Y))
                      (EQUAL X (CAR Z)))
                 (EQUAL (MEMBER X (CDR Z)) T)),

  which again simplifies, applying the lemma EQL-COMM, to:

        T.

Case 2. (IMPLIES (AND (LISTP Z)
                      (NOT (EQL Y (CAR Z)))
                      (EQUAL (MEMBER X (DEL Y (CDR Z)))
                             (MEMBER X (CDR Z)))
                      (NOT (EQL X Y)))
                 (EQUAL (MEMBER X (DEL Y Z))
                        (MEMBER X Z))),

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

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Z)) (NOT (EQL X Y)))
                 (EQUAL (MEMBER X (DEL Y Z))
                        (MEMBER X Z))).

  This simplifies, expanding the functions DEL, MEMBER, and EQUAL, to:

        T.


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


[ 0.0 0.0 0.0 ]

MEMBER-DEL1


(PROVE-LEMMA SUBST-IDENT
             (REWRITE)
             (IMPLIES (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (EQUAL (SUBST EXP VAR TERM FLG) EXP)))


     Name 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 (ZEROP FLG)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR)))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG2 EXP) VAR TERM 0)
                         (p (ARG1 EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR))
                         (p (BODY EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR TERM 1))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CDR EXP) VAR TERM 1)
                         (p (CAR EXP) VAR TERM 0))
                    (p EXP VAR TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP VAR TERM FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme leads to the following 19 new conjectures:

Case 19.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, rewriting with the lemmas CAR-CONS and COLLECT-FREE-FLG,
  and opening up the definitions of ZEROP, VARIABLE, EQUAL, COLLECT-FREE, and
  MEMBER, to:

        T.

Case 18.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, appealing to the lemmas CDR-CONS, CAR-CONS,
  COLLECT-FREE-FLG, and SUBST-FLG, and expanding ZEROP, VARIABLE, EQUAL,
  COLLECT-FREE, MEMBER, LISTP, and SUBST, to:

        T.

Case 17.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG EXP) 0))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, applying COLLECT-FREE-FLG, and opening up the definitions
  of ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 16.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (EQUAL (SUBST (ARG EXP) VAR TERM 0)
                             (ARG EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, rewriting with F-NOT-ARG, COLLECT-FREE-FLG, and SUBST-FLG,
  and expanding the definitions of ZEROP, VARIABLE, EQUAL, COLLECT-FREE, and
  SUBST, to:

        T.

Case 15.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG2 EXP) 0))
                      (MEMBER VAR
                              (COLLECT-FREE (ARG1 EXP) 0))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, rewriting with MEMBER-APPEND and COLLECT-FREE-FLG, and
  opening up ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 14.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (EQUAL (SUBST (ARG2 EXP) VAR TERM 0)
                             (ARG2 EXP))
                      (MEMBER VAR
                              (COLLECT-FREE (ARG1 EXP) 0))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, rewriting with MEMBER-APPEND and COLLECT-FREE-FLG, and
  expanding the functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 13.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG2 EXP) 0))
                      (EQUAL (SUBST (ARG1 EXP) VAR TERM 0)
                             (ARG1 EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, rewriting with MEMBER-APPEND and COLLECT-FREE-FLG, and
  expanding the functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 12.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (EQUAL (SUBST (ARG2 EXP) VAR TERM 0)
                             (ARG2 EXP))
                      (EQUAL (SUBST (ARG1 EXP) VAR TERM 0)
                             (ARG1 EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, rewriting with the lemmas MEMBER-APPEND, F-OR-ARG1-ARG2,
  COLLECT-FREE-FLG, and SUBST-FLG, and expanding the functions ZEROP, VARIABLE,
  EQUAL, COLLECT-FREE, and SUBST, to:

        T.

Case 11.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQL (BIND EXP) VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, rewriting with the lemmas NUMBERP-EQL, COLLECT-FREE-FLG,
  and SUBST-FLG, and expanding the definitions of ZEROP, VARIABLE, OR, EQUAL,
  and SUBST, to:

        T.

Case 10.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (MEMBER VAR
                              (COLLECT-FREE (BODY EXP) 0))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, appealing to the lemmas NUMBERP-EQL, MEMBER-DEL1, and
  COLLECT-FREE-FLG, and opening up ZEROP, VARIABLE, OR, EQUAL, and
  COLLECT-FREE, to:

        T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR))
                      (EQUAL (SUBST (BODY EXP) VAR TERM 0)
                             (BODY EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1, FORSOME-BIND-BODY,
  COLLECT-FREE-FLG, and SUBST-FLG, and opening up ZEROP, VARIABLE, OR, EQUAL,
  COLLECT-FREE, and SUBST, to:

        T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, applying COLLECT-FREE-FLG, and unfolding the definitions of
  ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (EQUAL (SUBST (CDR EXP) VAR TERM 1)
                             (CDR EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, applying the lemmas CONS-CAR-CDR, COLLECT-FREE-FLG, and
  SUBST-FLG, and unfolding the functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE,
  and SUBST, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, rewriting with COLLECT-FREE-FLG and SUBST-FLG, and opening
  up ZEROP, VARIABLE, EQUAL, COLLECT-FREE, LISTP, MEMBER, and SUBST, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (MEMBER VAR
                              (COLLECT-FREE (CAR EXP) 0))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, applying the lemma MEMBER-APPEND, and expanding the
  definitions of ZEROP and COLLECT-FREE, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL (SUBST (CDR EXP) VAR TERM 1)
                             (CDR EXP))
                      (MEMBER VAR
                              (COLLECT-FREE (CAR EXP) 0))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, rewriting with MEMBER-APPEND, and unfolding the definitions
  of ZEROP and COLLECT-FREE, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (EQUAL (SUBST (CAR EXP) VAR TERM 0)
                             (CAR EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, rewriting with MEMBER-APPEND, and expanding the functions
  ZEROP and COLLECT-FREE, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL (SUBST (CDR EXP) VAR TERM 1)
                             (CDR EXP))
                      (EQUAL (SUBST (CAR EXP) VAR TERM 0)
                             (CAR EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)).

  This simplifies, applying MEMBER-APPEND and CONS-CAR-CDR, and expanding the
  functions ZEROP, COLLECT-FREE, and SUBST, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (SUBST EXP VAR TERM FLG) EXP)),

  which simplifies, opening up the definitions of ZEROP, COLLECT-FREE, LISTP,
  MEMBER, and SUBST, to:

        T.


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


[ 0.0 0.0 0.1 ]

SUBST-IDENT


(PROVE-LEMMA COLLECT-FREE-SUBST
             (REWRITE)
             (IMPLIES (AND (VARIABLE VAR)
                           (VARIABLE VAR1)
                           (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                      (EQUAL (MEMBER VAR
                                     (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                                   FLG))
                             (OR (AND (NOT (EQUAL VAR VAR1))
                                      (MEMBER VAR (COLLECT-FREE EXP FLG)))
                                 (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                      (MEMBER VAR
                                              (COLLECT-FREE TERM 0)))))))

This conjecture can be simplified, using the abbreviations NOT, AND, IMPLIES,
and VARIABLE, to the goal:

      (IMPLIES (AND (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG))
                      (OR (AND (NOT (EQUAL VAR VAR1))
                               (MEMBER VAR (COLLECT-FREE EXP FLG)))
                          (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                               (MEMBER VAR
                                       (COLLECT-FREE TERM 0)))))).

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

Case 5. (IMPLIES (AND (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (MEMBER VAR1 (COLLECT-FREE EXP FLG)))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (MEMBER VAR (COLLECT-FREE TERM 0)))).

  Call the above conjecture *1.

Case 4. (IMPLIES (AND (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG)))
                      (EQUAL VAR VAR1)
                      (MEMBER VAR1 (COLLECT-FREE EXP FLG)))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (MEMBER VAR (COLLECT-FREE TERM 0)))).

  However this again simplifies, rewriting with the lemma VAR-COVERING-VAR, to:

        (IMPLIES (AND (NUMBERP VAR1)
                      (MEMBER VAR1 (COLLECT-FREE EXP FLG)))
                 (EQUAL (MEMBER VAR1
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (MEMBER VAR1 (COLLECT-FREE TERM 0)))),

  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 (AND (VARIABLE VAR)
              (VARIABLE VAR1)
              (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
         (EQUAL (MEMBER VAR
                        (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                      FLG))
                (OR (AND (NOT (EQUAL VAR VAR1))
                         (MEMBER VAR (COLLECT-FREE EXP FLG)))
                    (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                         (MEMBER VAR
                                 (COLLECT-FREE TERM 0)))))),

which we named *1 above.  We will appeal to 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 (ZEROP FLG)
                         (F-NOTP EXP)
                         (p VAR (ARG EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p VAR (ARG1 EXP) VAR1 TERM 0)
                         (p VAR (ARG2 EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (MEMB VAR1 (COLLECT-FREE EXP 0))
                         (p VAR (BODY EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (MEMB VAR1 (COLLECT-FREE EXP 0))))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p VAR (CDR EXP) VAR1 TERM 1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p VAR (CAR EXP) VAR1 TERM 0)
                         (p VAR (CDR EXP) VAR1 TERM 1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p VAR EXP VAR1 TERM FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme generates the following 17 new conjectures:

Case 17.(IMPLIES (AND (ZEROP FLG)
                      (F-NOTP EXP)
                      (MEMBER VAR
                              (COVERING (ARG EXP) VAR1 0))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))).

  This simplifies, appealing to the lemma COVERING-FLG, and expanding the
  definitions of ZEROP, VARIABLE, EQUAL, and COVERING, to:

        T.

Case 16.(IMPLIES
                (AND (ZEROP FLG)
                     (F-NOTP EXP)
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            (OR (AND (NOT (EQUAL VAR VAR1))
                                     (MEMBER VAR
                                             (COLLECT-FREE (ARG EXP) 0)))
                                (AND (MEMBER VAR1
                                             (COLLECT-FREE (ARG EXP) 0))
                                     (MEMBER VAR (COLLECT-FREE TERM 0)))))
                     (VARIABLE VAR)
                     (VARIABLE VAR1)
                     (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                             FLG))
                       (OR (AND (NOT (EQUAL VAR VAR1))
                                (MEMBER VAR (COLLECT-FREE EXP FLG)))
                           (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                (MEMBER VAR
                                        (COLLECT-FREE TERM 0)))))).

  This simplifies, appealing to the lemmas ARG-F-NOT, VAR-COVERING-VAR,
  SUBST-IDENT, COVERING-FLG, SUBST-FLG, and COLLECT-FREE-FLG, and unfolding
  ZEROP, NOT, AND, OR, VARIABLE, EQUAL, COVERING, SUBST, and COLLECT-FREE, to
  the following eight new conjectures:

  Case 16.8.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (ARG EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (ARG EXP) 0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       F)).

    This again simplifies, clearly, to:

          T.

  Case 16.7.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (ARG EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (ARG EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 16.6.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (ARG EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (ARG EXP) 0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       F)).

    This again simplifies, obviously, to:

          T.

  Case 16.5.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (ARG EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (ARG EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 16.4.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (ARG EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (ARG EXP) 0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       F)).

    This again simplifies, trivially, to:

          T.

  Case 16.3.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (ARG EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (ARG EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 16.2.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (ARG EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (ARG EXP) 0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       F)).

    This again simplifies, clearly, to:

          T.

  Case 16.1.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (F-NOTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (ARG EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (ARG EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (ARG EXP) VAR TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

Case 15.(IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COVERING (ARG1 EXP) VAR1 0))
                      (MEMBER VAR
                              (COVERING (ARG2 EXP) VAR1 0))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))).

  This simplifies, rewriting with the lemmas MEMBER-APPEND and COVERING-FLG,
  and opening up ZEROP, VARIABLE, EQUAL, and COVERING, to:

        T.

Case 14.(IMPLIES
               (AND (ZEROP FLG)
                    (NOT (F-NOTP EXP))
                    (F-ORP EXP)
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (OR (AND (NOT (EQUAL VAR VAR1))
                                    (MEMBER VAR
                                            (COLLECT-FREE (ARG1 EXP) 0)))
                               (AND (MEMBER VAR1
                                            (COLLECT-FREE (ARG1 EXP) 0))
                                    (MEMBER VAR (COLLECT-FREE TERM 0)))))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (VARIABLE VAR)
                    (VARIABLE VAR1)
                    (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG))
                      (OR (AND (NOT (EQUAL VAR VAR1))
                               (MEMBER VAR (COLLECT-FREE EXP FLG)))
                          (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                               (MEMBER VAR
                                       (COLLECT-FREE TERM 0)))))).

  This simplifies, rewriting with MEMBER-APPEND, VAR-COVERING-VAR, ARG2-F-OR,
  ARG1-F-OR, COVERING-FLG, SUBST-FLG, and COLLECT-FREE-FLG, and unfolding the
  definitions of ZEROP, NOT, AND, OR, VARIABLE, EQUAL, COVERING, SUBST, and
  COLLECT-FREE, to 24 new conjectures:

  Case 14.24.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)),

    which again simplifies, clearly, to:

          T.

  Case 14.23.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, opening up EQUAL, to:

          T.

  Case 14.22.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, unfolding EQUAL, to:

          T.

  Case 14.21.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 14.20.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, rewriting with the lemma VAR-COVERING-VAR,
    to:

          T.

  Case 14.19.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))),

    which again simplifies, clearly, to:

          T.

  Case 14.18.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    However this again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 14.17.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 14.16.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 14.15.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 14.14.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 14.13.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))).

    This again simplifies, trivially, to:

          T.

  Case 14.12.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, clearly, to:

          T.

  Case 14.11.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, opening up EQUAL, to:

          T.

  Case 14.10.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, expanding EQUAL, to:

          T.

  Case 14.9.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, rewriting with the lemma VAR-COVERING-VAR, to:

          T.

  Case 14.8.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, applying the lemma VAR-COVERING-VAR, to:

          T.

  Case 14.7.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))),

    which again simplifies, trivially, to:

          T.

  Case 14.6.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, rewriting with the lemma VAR-COVERING-VAR, to:

          T.

  Case 14.5.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, clearly, to:

          T.

  Case 14.4.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 14.3.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 14.2.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, appealing to the lemma VAR-COVERING-VAR, to:

          T.

  Case 14.1.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COVERING (ARG2 EXP) VAR1 0))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))),

    which again simplifies, obviously, to:

          T.

Case 13.(IMPLIES
               (AND (ZEROP FLG)
                    (NOT (F-NOTP EXP))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (OR (AND (NOT (EQUAL VAR VAR1))
                                    (MEMBER VAR
                                            (COLLECT-FREE (ARG2 EXP) 0)))
                               (AND (MEMBER VAR1
                                            (COLLECT-FREE (ARG2 EXP) 0))
                                    (MEMBER VAR (COLLECT-FREE TERM 0)))))
                    (VARIABLE VAR)
                    (VARIABLE VAR1)
                    (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG))
                      (OR (AND (NOT (EQUAL VAR VAR1))
                               (MEMBER VAR (COLLECT-FREE EXP FLG)))
                          (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                               (MEMBER VAR
                                       (COLLECT-FREE TERM 0)))))).

  This simplifies, appealing to the lemmas MEMBER-APPEND, VAR-COVERING-VAR,
  ARG2-F-OR, ARG1-F-OR, COVERING-FLG, SUBST-FLG, and COLLECT-FREE-FLG, and
  opening up the definitions of ZEROP, NOT, AND, OR, VARIABLE, EQUAL, COVERING,
  SUBST, and COLLECT-FREE, to the following 24 new goals:

  Case 13.24.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, trivially, to:

          T.

  Case 13.23.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, applying VAR-COVERING-VAR, to:

          T.

  Case 13.22.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, applying VAR-COVERING-VAR, to:

          T.

  Case 13.21.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 13.20.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 13.19.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))).

    This again simplifies, clearly, to:

          T.

  Case 13.18.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, trivially, to:

          T.

  Case 13.17.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, applying the lemma VAR-COVERING-VAR, to:

          T.

  Case 13.16.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, clearly, to:

          T.

  Case 13.15.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 13.14.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 13.13.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))).

    However this again simplifies, applying VAR-COVERING-VAR, to:

          T.

  Case 13.12.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, clearly, to:

          T.

  Case 13.11.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying VAR-COVERING-VAR, to:

          T.

  Case 13.10.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 13.9.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 13.8.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 13.7.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))).

    This again simplifies, trivially, to:

          T.

  Case 13.6.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, trivially, to:

          T.

  Case 13.5.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying the lemma VAR-COVERING-VAR, to:

          T.

  Case 13.4.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, trivially, to:

          T.

  Case 13.3.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying the lemma VAR-COVERING-VAR, to:

          T.

  Case 13.2.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, obviously, to:

          T.

  Case 13.1.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (MEMBER VAR
                            (COVERING (ARG1 EXP) VAR1 0))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))).

    But this again simplifies, applying VAR-COVERING-VAR, to:

          T.

Case 12.(IMPLIES
               (AND (ZEROP FLG)
                    (NOT (F-NOTP EXP))
                    (F-ORP EXP)
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (OR (AND (NOT (EQUAL VAR VAR1))
                                    (MEMBER VAR
                                            (COLLECT-FREE (ARG1 EXP) 0)))
                               (AND (MEMBER VAR1
                                            (COLLECT-FREE (ARG1 EXP) 0))
                                    (MEMBER VAR (COLLECT-FREE TERM 0)))))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (OR (AND (NOT (EQUAL VAR VAR1))
                                    (MEMBER VAR
                                            (COLLECT-FREE (ARG2 EXP) 0)))
                               (AND (MEMBER VAR1
                                            (COLLECT-FREE (ARG2 EXP) 0))
                                    (MEMBER VAR (COLLECT-FREE TERM 0)))))
                    (VARIABLE VAR)
                    (VARIABLE VAR1)
                    (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG))
                      (OR (AND (NOT (EQUAL VAR VAR1))
                               (MEMBER VAR (COLLECT-FREE EXP FLG)))
                          (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                               (MEMBER VAR
                                       (COLLECT-FREE TERM 0)))))).

  This simplifies, rewriting with the lemmas MEMBER-APPEND, ARG2-F-OR,
  ARG1-F-OR, VAR-COVERING-VAR, SUBST-IDENT, COVERING-FLG, SUBST-FLG, and
  COLLECT-FREE-FLG, and unfolding the definitions of ZEROP, NOT, AND, OR,
  VARIABLE, EQUAL, COVERING, SUBST, and COLLECT-FREE, to the following 32 new
  conjectures:

  Case 12.32.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, obviously, to:

          T.

  Case 12.31.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 12.30.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, obviously, to:

          T.

  Case 12.29.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 12.28.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, obviously, to:

          T.

  Case 12.27.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.26.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 12.25.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, unfolding the definition of EQUAL, to:

          T.

  Case 12.24.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)),

    which again simplifies, trivially, to:

          T.

  Case 12.23.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 12.22.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, clearly, to:

          T.

  Case 12.21.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 12.20.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, obviously, to:

          T.

  Case 12.19.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.18.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 12.17.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 12.16.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, clearly, to:

          T.

  Case 12.15.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 12.14.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, trivially, to:

          T.

  Case 12.13.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.12.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, clearly, to:

          T.

  Case 12.11.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.10.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 12.9.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG1 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, expanding EQUAL, to:

          T.

  Case 12.8.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)),

    which again simplifies, obviously, to:

          T.

  Case 12.7.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.6.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, obviously, to:

          T.

  Case 12.5.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.4.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG1 EXP) 0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      F)).

    This again simplifies, clearly, to:

          T.

  Case 12.3.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (ARG2 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG1 EXP) 0)))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.2.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                               0))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR TERM 0)
                                            0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 12.1.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (F-ORP EXP)
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (ARG1 EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (MEMBER VAR
                            (COLLECT-FREE (ARG2 EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (COLLECT-FREE (SUBST (ARG1 EXP) VAR TERM 0)
                                          0)))
               (EQUAL T
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

Case 11.(IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (MEMB VAR1 (COLLECT-FREE EXP 0))
                      (MEMBER VAR
                              (COVERING (BODY EXP) VAR1 0))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))).

  This simplifies, rewriting with MEMB-MEMBER-NUMBERP, SUBST-IDENT,
  NUMBERP-EQL, COVERING-FLG, COLLECT-FREE-FLG, and SUBST-FLG, and expanding
  the functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE, COVERING, NOT, AND, OR,
  and SUBST, to 14 new formulas:

  Case 11.14.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR1
                                     (DEL (BIND EXP)
                                          (COLLECT-FREE (BODY EXP) 0))))
                        (NOT (MEMBER VAR NIL))
                        (EQUAL VAR VAR1))
                   (EQUAL (MEMBER VAR
                                  (DEL (BIND EXP)
                                       (COLLECT-FREE (BODY EXP) 0)))
                          F)),

    which again simplifies, trivially, to:

          T.

  Case 11.13.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR
                        (COVERING (BODY EXP) VAR1 0))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and unfolding the functions
    OR and MEMBER, to:

          T.

  Case 11.12.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR
                        (COVERING (BODY EXP) VAR1 0))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (EQUAL VAR VAR1)
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, and VAR-COVERING-VAR, and opening up the definition
    of OR, to:

          T.

  Case 11.11.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (MEMBER VAR1
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (CONS (BIND EXP)
                                           (COVERING (BODY EXP) VAR1 0))))
                        (NOT (MEMBER VAR
                                     (DEL (BIND EXP)
                                          (COLLECT-FREE (BODY EXP) 0))))
                        (EQUAL (BIND EXP) VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 11.10.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (MEMBER VAR1
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (CONS (BIND EXP)
                                           (COVERING (BODY EXP) VAR1 0))))
                        (EQUAL VAR VAR1)
                        (EQUAL (BIND EXP) VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with MEMBER-DEL and MEMB-MEMBER-NUMBERP,
    to:

          T.

  Case 11.9.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR
                        (COVERING (BODY EXP) VAR1 0))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)).

    However this again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and expanding OR and MEMBER,
    to:

          T.

  Case 11.8.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (MEMBER VAR1
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (CONS (BIND EXP)
                                           (COVERING (BODY EXP) VAR1 0))))
                        (NOT (EQUAL VAR VAR1))
                        (MEMBER VAR
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (EQUAL (BIND EXP) VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          T)).

    However this again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP,
    to:

          T.

  Case 11.7.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR1
                                     (DEL (BIND EXP)
                                          (COLLECT-FREE (BODY EXP) 0))))
                        (NOT (MEMBER VAR NIL))
                        (EQUAL VAR VAR1))
                   (EQUAL (MEMBER VAR
                                  (DEL (BIND EXP)
                                       (COLLECT-FREE (BODY EXP) 0)))
                          F)).

    This again simplifies, trivially, to:

          T.

  Case 11.6.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR
                        (COVERING (BODY EXP) VAR1 0))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and opening up the functions
    OR and MEMBER, to:

          T.

  Case 11.5.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR
                        (COVERING (BODY EXP) VAR1 0))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (EQUAL VAR VAR1)
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, and VAR-COVERING-VAR, and opening up the definition
    of OR, to:

          T.

  Case 11.4.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (MEMBER VAR1
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (CONS (BIND EXP)
                                           (COVERING (BODY EXP) VAR1 0))))
                        (NOT (MEMBER VAR
                                     (DEL (BIND EXP)
                                          (COLLECT-FREE (BODY EXP) 0))))
                        (EQUAL (BIND EXP) VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, rewriting with MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 11.3.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (MEMBER VAR1
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (CONS (BIND EXP)
                                           (COVERING (BODY EXP) VAR1 0))))
                        (EQUAL VAR VAR1)
                        (EQUAL (BIND EXP) VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying the lemmas MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 11.2.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR
                        (COVERING (BODY EXP) VAR1 0))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)),

    which again simplifies, rewriting with the lemmas NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and expanding the definitions
    of OR and MEMBER, to:

          T.

  Case 11.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (MEMB VAR1
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                        (MEMBER VAR
                                (COVERING (BODY EXP) VAR1 0))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (MEMBER VAR1
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (NOT (MEMBER VAR
                                     (CONS (BIND EXP)
                                           (COVERING (BODY EXP) VAR1 0))))
                        (NOT (EQUAL VAR VAR1))
                        (MEMBER VAR
                                (DEL (BIND EXP)
                                     (COLLECT-FREE (BODY EXP) 0)))
                        (EQUAL (BIND EXP) VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          T)),

    which again simplifies, rewriting with MEMBER-DEL and MEMB-MEMBER-NUMBERP,
    to:

          T.

Case 10.(IMPLIES
               (AND (ZEROP FLG)
                    (NOT (F-NOTP EXP))
                    (NOT (F-ORP EXP))
                    (FORSOMEP EXP)
                    (MEMB VAR1 (COLLECT-FREE EXP 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (OR (AND (NOT (EQUAL VAR VAR1))
                                    (MEMBER VAR
                                            (COLLECT-FREE (BODY EXP) 0)))
                               (AND (MEMBER VAR1
                                            (COLLECT-FREE (BODY EXP) 0))
                                    (MEMBER VAR (COLLECT-FREE TERM 0)))))
                    (VARIABLE VAR)
                    (VARIABLE VAR1)
                    (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
               (EQUAL (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG))
                      (OR (AND (NOT (EQUAL VAR VAR1))
                               (MEMBER VAR (COLLECT-FREE EXP FLG)))
                          (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                               (MEMBER VAR
                                       (COLLECT-FREE TERM 0)))))).

  This simplifies, applying MEMB-MEMBER-NUMBERP, SUBST-IDENT, NUMBERP-EQL,
  COVERING-FLG, COLLECT-FREE-FLG, and SUBST-FLG, and expanding the functions
  ZEROP, VARIABLE, EQUAL, COLLECT-FREE, NOT, AND, OR, COVERING, and SUBST, to
  44 new conjectures:

  Case 10.44.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (NOT (MEMBER VAR1
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (NOT (MEMBER VAR NIL))
                    (EQUAL VAR VAR1))
               (EQUAL (MEMBER VAR
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                      F)),

    which again simplifies, trivially, to:

          T.

  Case 10.43.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, CAR-CONS, BODY-FORSOME, and BIND-FORSOME,
    and unfolding the functions OR, MEMBER, VARIABLE, EQUAL, and COLLECT-FREE,
    to:

          T.

  Case 10.42.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (EQUAL VAR VAR1)
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 10.41.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (MEMBER VAR
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with MEMBER-DEL and MEMB-MEMBER-NUMBERP,
    to:

          T.

  Case 10.40.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (EQUAL VAR VAR1)
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 10.39.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)).

    This again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and unfolding the definitions
    of OR and MEMBER, to:

          T.

  Case 10.38.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      T)).

    This again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.37.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL VAR VAR1)
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR 0))))
                (NOT (EQUAL (BIND EXP) VAR)))
           (EQUAL (MEMBER VAR
                          (COLLECT-FREE (FORSOME (BIND EXP)
                                                 (SUBST (BODY EXP) VAR TERM 0))
                                        0))
                  (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying the lemmas NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, VAR-COVERING-VAR, CDR-CONS, CAR-CONS, BODY-FORSOME,
    and BIND-FORSOME, and opening up OR, MEMBER, VARIABLE, EQUAL, and
    COLLECT-FREE, to:

          T.

  Case 10.36.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR 0))))
                    (EQUAL (BIND EXP) VAR))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.35.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (NOT (MEMBER VAR1
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (NOT (MEMBER VAR NIL))
                    (EQUAL VAR VAR1))
               (EQUAL (MEMBER VAR
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                      F)).

    This again simplifies, trivially, to:

          T.

  Case 10.34.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, applying NUMBERP-EQL, MEMBER-DEL1, and
    MEMB-MEMBER-NUMBERP, and expanding the function OR, to:

          T.

  Case 10.33.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (EQUAL VAR VAR1)
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, applying the lemmas NUMBERP-EQL, MEMBER-DEL1,
    and MEMB-MEMBER-NUMBERP, and unfolding OR, to:

          T.

  Case 10.32.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (MEMBER VAR
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.31.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (EQUAL VAR VAR1)
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.30.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)).

    But this again simplifies, applying the lemmas NUMBERP-EQL, MEMBER-DEL1,
    and MEMB-MEMBER-NUMBERP, and unfolding OR, to:

          T.

  Case 10.29.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      T)),

    which again simplifies, appealing to the lemmas MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.28.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL VAR VAR1)
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR 0))))
                (NOT (EQUAL (BIND EXP) VAR)))
           (EQUAL (MEMBER VAR
                          (COLLECT-FREE (FORSOME (BIND EXP)
                                                 (SUBST (BODY EXP) VAR TERM 0))
                                        0))
                  (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, applying the lemmas NUMBERP-EQL, MEMBER-DEL1, and
    MEMB-MEMBER-NUMBERP, and unfolding the function OR, to:

          T.

  Case 10.27.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR 0))))
                    (EQUAL (BIND EXP) VAR))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, rewriting with MEMBER-DEL and MEMB-MEMBER-NUMBERP,
    to:

          T.

  Case 10.26.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       T)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and unfolding OR and MEMBER,
    to:

          T.

  Case 10.25.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           T)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (MEMBER VAR
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with the lemmas MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.24.
          (IMPLIES
           (AND (EQUAL FLG 0)
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       T)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)),

    which again simplifies, appealing to the lemmas NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, CAR-CONS, BODY-FORSOME, and BIND-FORSOME,
    and expanding the definitions of OR, MEMBER, VARIABLE, EQUAL, and
    COLLECT-FREE, to:

          T.

  Case 10.23.
          (IMPLIES
               (AND (EQUAL FLG 0)
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           T)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      T)),

    which again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.22.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (NOT (MEMBER VAR1
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (NOT (MEMBER VAR NIL))
                    (EQUAL VAR VAR1))
               (EQUAL (MEMBER VAR
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                      F)).

    This again simplifies, trivially, to:

          T.

  Case 10.21.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, CAR-CONS, BODY-FORSOME, and BIND-FORSOME,
    and opening up OR, MEMBER, VARIABLE, EQUAL, and COLLECT-FREE, to:

          T.

  Case 10.20.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (EQUAL VAR VAR1)
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 10.19.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (MEMBER VAR
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.18.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (EQUAL VAR VAR1)
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 10.17.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)).

    However this again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and unfolding OR and MEMBER,
    to:

          T.

  Case 10.16.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      T)).

    However this again simplifies, rewriting with MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.15.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL VAR VAR1)
                (MEMBER VAR1
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))
                (NUMBERP VAR)
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR 0))))
                (NOT (EQUAL (BIND EXP) VAR)))
           (EQUAL (MEMBER VAR
                          (COLLECT-FREE (FORSOME (BIND EXP)
                                                 (SUBST (BODY EXP) VAR TERM 0))
                                        0))
                  (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, VAR-COVERING-VAR, CDR-CONS, CAR-CONS, BODY-FORSOME,
    and BIND-FORSOME, and expanding OR, MEMBER, VARIABLE, EQUAL, and
    COLLECT-FREE, to:

          T.

  Case 10.14.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL VAR VAR1)
                    (MEMBER VAR1
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           (MEMBER VAR (COLLECT-FREE TERM 0)))
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR 0))))
                    (EQUAL (BIND EXP) VAR))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, appealing to the lemmas MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.13.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (NOT (MEMBER VAR1
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (NOT (MEMBER VAR NIL))
                    (EQUAL VAR VAR1))
               (EQUAL (MEMBER VAR
                              (DEL (BIND EXP)
                                   (COLLECT-FREE (BODY EXP) 0)))
                      F)),

    which again simplifies, clearly, to:

          T.

  Case 10.12.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, rewriting with the lemmas NUMBERP-EQL,
    MEMBER-DEL1, and MEMB-MEMBER-NUMBERP, and expanding OR, to:

          T.

  Case 10.11.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (EQUAL VAR VAR1)
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1, and
    MEMB-MEMBER-NUMBERP, and unfolding OR, to:

          T.

  Case 10.10.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (MEMBER VAR
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, rewriting with MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.9.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (EQUAL VAR VAR1)
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, rewriting with MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.8.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)).

    But this again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1, and
    MEMB-MEMBER-NUMBERP, and expanding OR, to:

          T.

  Case 10.7.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      T)).

    However this again simplifies, rewriting with MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.6.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL VAR VAR1)
                (NOT (MEMBER VAR1
                             (COLLECT-FREE (BODY EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       F)
                (NUMBERP VAR)
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR 0))))
                (NOT (EQUAL (BIND EXP) VAR)))
           (EQUAL (MEMBER VAR
                          (COLLECT-FREE (FORSOME (BIND EXP)
                                                 (SUBST (BODY EXP) VAR TERM 0))
                                        0))
                  (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, applying the lemmas NUMBERP-EQL, MEMBER-DEL1,
    and MEMB-MEMBER-NUMBERP, and unfolding the definition of OR, to:

          T.

  Case 10.5.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL VAR VAR1)
                    (NOT (MEMBER VAR1
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           F)
                    (NUMBERP VAR)
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR 0))))
                    (EQUAL (BIND EXP) VAR))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP, to:

          T.

  Case 10.4.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       T)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (NOT (MEMBER VAR
                             (DEL (BIND EXP)
                                  (COLLECT-FREE (BODY EXP) 0))))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, and CAR-CONS, and opening up the functions
    OR and MEMBER, to:

          T.

  Case 10.3.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           T)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (NOT (MEMBER VAR
                                 (DEL (BIND EXP)
                                      (COLLECT-FREE (BODY EXP) 0))))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, applying MEMBER-DEL and MEMB-MEMBER-NUMBERP,
    to:

          T.

  Case 10.2.
          (IMPLIES
           (AND (NOT (NUMBERP FLG))
                (FORSOMEP EXP)
                (MEMB VAR1
                      (DEL (BIND EXP)
                           (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL VAR VAR1))
                (MEMBER VAR
                        (COLLECT-FREE (BODY EXP) 0))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                             0))
                       T)
                (NUMBERP VAR)
                (NUMBERP VAR1)
                (MEMBER VAR1
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (MEMBER VAR
                             (CONS (BIND EXP)
                                   (COVERING (BODY EXP) VAR1 0))))
                (MEMBER VAR
                        (DEL (BIND EXP)
                             (COLLECT-FREE (BODY EXP) 0)))
                (NOT (EQUAL (BIND EXP) VAR1)))
           (EQUAL
                 (MEMBER VAR
                         (COLLECT-FREE (FORSOME (BIND EXP)
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0))
                 T)).

    However this again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, CDR-CONS, CAR-CONS, BODY-FORSOME, and BIND-FORSOME,
    and expanding the functions OR, MEMBER, VARIABLE, EQUAL, and COLLECT-FREE,
    to:

          T.

  Case 10.1.
          (IMPLIES
               (AND (NOT (NUMBERP FLG))
                    (FORSOMEP EXP)
                    (MEMB VAR1
                          (DEL (BIND EXP)
                               (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR
                            (COLLECT-FREE (BODY EXP) 0))
                    (EQUAL (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0))
                           T)
                    (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (MEMBER VAR1
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (NOT (MEMBER VAR
                                 (CONS (BIND EXP)
                                       (COVERING (BODY EXP) VAR1 0))))
                    (MEMBER VAR
                            (DEL (BIND EXP)
                                 (COLLECT-FREE (BODY EXP) 0)))
                    (EQUAL (BIND EXP) VAR1))
               (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                      T)).

    This again simplifies, applying the lemmas MEMBER-DEL and
    MEMB-MEMBER-NUMBERP, to:

          T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))),

  which simplifies, rewriting with COVERING-FLG, SUBST-FLG, and
  COLLECT-FREE-FLG, and unfolding ZEROP, VARIABLE, NOT, AND, and OR, to the
  following ten new conjectures:

  Case 9.10.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))
                        (MEMBER VAR1 (COLLECT-FREE EXP 0)))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, appealing to the lemma MEMB-MEMBER-NUMBERP, to:

          T.

  Case 9.9.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (EQUAL VAR VAR1)
                        (MEMBER VAR1 (COLLECT-FREE EXP 0)))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, rewriting with MEMB-MEMBER-NUMBERP, to:

          T.

  Case 9.8.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))
                        (NOT (MEMBER VAR1 (COLLECT-FREE EXP 0))))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          F)).

    This again simplifies, rewriting with MEMB-MEMBER-NUMBERP and SUBST-IDENT,
    and expanding EQUAL, COVERING, LISTP, and MEMBER, to:

          T.

  Case 9.7.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (EQUAL VAR VAR1)
                        (NOT (MEMBER VAR1 (COLLECT-FREE EXP 0))))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          F)).

    But this again simplifies, rewriting with the lemmas MEMB-MEMBER-NUMBERP
    and SUBST-IDENT, and expanding EQUAL, COVERING, LISTP, and MEMBER, to:

          T.

  Case 9.6.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (NOT (EQUAL VAR VAR1))
                        (MEMBER VAR (COLLECT-FREE EXP 0)))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          T)),

    which again simplifies, applying MEMB-MEMBER-NUMBERP and SUBST-IDENT, and
    unfolding the definitions of EQUAL, COVERING, LISTP, and MEMBER, to:

          T.

  Case 9.5.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))
                        (MEMBER VAR1 (COLLECT-FREE EXP 0)))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, rewriting with MEMB-MEMBER-NUMBERP, to:

          T.

  Case 9.4.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (EQUAL VAR VAR1)
                        (MEMBER VAR1 (COLLECT-FREE EXP 0)))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, applying the lemma MEMB-MEMBER-NUMBERP, to:

          T.

  Case 9.3.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))
                        (NOT (MEMBER VAR1 (COLLECT-FREE EXP 0))))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          F)),

    which again simplifies, applying the lemmas MEMB-MEMBER-NUMBERP and
    SUBST-IDENT, and expanding EQUAL, COVERING, LISTP, and MEMBER, to:

          T.

  Case 9.2.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (EQUAL VAR VAR1)
                        (NOT (MEMBER VAR1 (COLLECT-FREE EXP 0))))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          F)),

    which again simplifies, rewriting with MEMB-MEMBER-NUMBERP and SUBST-IDENT,
    and unfolding the functions EQUAL, COVERING, LISTP, and MEMBER, to:

          T.

  Case 9.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (NOT (MEMB VAR1 (COLLECT-FREE EXP 0)))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (MEMBER VAR (COVERING EXP VAR1 0)))
                        (NOT (EQUAL VAR VAR1))
                        (MEMBER VAR (COLLECT-FREE EXP 0)))
                   (EQUAL (MEMBER VAR
                                  (COLLECT-FREE (SUBST EXP VAR1 TERM 0)
                                                0))
                          T)).

    But this again simplifies, applying MEMB-MEMBER-NUMBERP and SUBST-IDENT,
    and unfolding EQUAL, COVERING, LISTP, and MEMBER, to:

          T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COVERING (CDR EXP) VAR1 1))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))).

  This simplifies, applying COVERING-FLG, and unfolding the functions ZEROP,
  VARIABLE, EQUAL, and COVERING, to:

        T.

Case 7. (IMPLIES
                (AND (ZEROP FLG)
                     (NOT (F-NOTP EXP))
                     (NOT (F-ORP EXP))
                     (NOT (FORSOMEP EXP))
                     (LISTP EXP)
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (OR (AND (NOT (EQUAL VAR VAR1))
                                     (MEMBER VAR
                                             (COLLECT-FREE (CDR EXP) 1)))
                                (AND (MEMBER VAR1
                                             (COLLECT-FREE (CDR EXP) 1))
                                     (MEMBER VAR (COLLECT-FREE TERM 0)))))
                     (VARIABLE VAR)
                     (VARIABLE VAR1)
                     (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                             FLG))
                       (OR (AND (NOT (EQUAL VAR VAR1))
                                (MEMBER VAR (COLLECT-FREE EXP FLG)))
                           (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                (MEMBER VAR
                                        (COLLECT-FREE TERM 0)))))),

  which simplifies, rewriting with CDR-CONS, VAR-COVERING-VAR, SUBST-IDENT,
  COVERING-FLG, SUBST-FLG, and COLLECT-FREE-FLG, and expanding the definitions
  of ZEROP, NOT, AND, OR, VARIABLE, EQUAL, COVERING, SUBST, and COLLECT-FREE,
  to the following eight new formulas:

  Case 7.8.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, obviously, to:

          T.

  Case 7.7.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 7.6.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, obviously, to:

          T.

  Case 7.5.
          (IMPLIES
                (AND (EQUAL FLG 0)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 7.4.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, trivially, to:

          T.

  Case 7.3.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 7.2.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, clearly, to:

          T.

  Case 7.1.
          (IMPLIES
                (AND (NOT (NUMBERP FLG))
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))).

  This simplifies, rewriting with COVERING-FLG, SUBST-FLG, and
  COLLECT-FREE-FLG, and expanding ZEROP, VARIABLE, EQUAL, COVERING, LISTP,
  MEMBER, SUBST, NOT, COLLECT-FREE, AND, and OR, to 26 new formulas:

  Case 6.26.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR (LIST EXP)))
                        (MEMBER VAR1 (LIST EXP))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
    opening up MEMBER and LISTP, to:

          T.

  Case 6.25.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (NUMBERP EXP))
                        (NOT (MEMBER VAR NIL))
                        (MEMBER VAR1 NIL))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, expanding the functions LISTP and MEMBER, to:

          T.

  Case 6.24.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NUMBERP EXP)
                        (MEMBER VAR1 (LIST EXP))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))),

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

          T.

  Case 6.23.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NOT (NUMBERP EXP))
                        (MEMBER VAR1 NIL))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, expanding LISTP and MEMBER, to:

          T.

  Case 6.22.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR (LIST EXP)))
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)),

    which again simplifies, applying CDR-CONS and CAR-CONS, and expanding the
    functions MEMBER, LISTP, VARIABLE, EQUAL, and COLLECT-FREE, to:

          T.

  Case 6.21.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (NUMBERP EXP))
                        (NOT (MEMBER VAR NIL))
                        (NOT (MEMBER VAR1 NIL)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)).

    But this again simplifies, expanding LISTP, MEMBER, VARIABLE, EQUAL, and
    COLLECT-FREE, to:

          T.

  Case 6.20.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)),

    which again simplifies, applying CDR-CONS and CAR-CONS, and opening up the
    definitions of MEMBER, LISTP, VARIABLE, EQUAL, and COLLECT-FREE, to:

          T.

  Case 6.19.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NOT (NUMBERP EXP))
                        (NOT (MEMBER VAR1 NIL)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)).

    But this again simplifies, opening up the functions LISTP, MEMBER,
    VARIABLE, EQUAL, and COLLECT-FREE, to:

          T.

  Case 6.18.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR (LIST EXP)))
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (EQUAL EXP VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE TERM 0))
                          F)),

    which again simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
    and unfolding the functions MEMBER and LISTP, to:

          T.

  Case 6.17.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (EQUAL EXP VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE TERM 0))
                          F)),

    which again simplifies, rewriting with the lemma CAR-CONS, and expanding
    the function MEMBER, to:

          T.

  Case 6.16.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (EQUAL VAR VAR1))
                        (NOT (NUMBERP EXP))
                        (MEMBER VAR NIL))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          T)),

    which again simplifies, opening up the functions LISTP and MEMBER, to:

          T.

  Case 6.15.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (EQUAL VAR VAR1))
                        (NUMBERP EXP)
                        (MEMBER VAR (LIST EXP))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          T)),

    which again simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
    and opening up MEMBER, LISTP, VARIABLE, EQUAL, and COLLECT-FREE, to:

          T.

  Case 6.14.
          (IMPLIES (AND (EQUAL FLG 0)
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (EQUAL VAR VAR1))
                        (NUMBERP EXP)
                        (MEMBER VAR (LIST EXP))
                        (EQUAL EXP VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE TERM 0))
                          T)),

    which again simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
    and expanding MEMBER and LISTP, to:

          T.

  Case 6.13.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR (LIST EXP)))
                        (MEMBER VAR1 (LIST EXP))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))),

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

          T.

  Case 6.12.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (NUMBERP EXP))
                        (NOT (MEMBER VAR NIL))
                        (MEMBER VAR1 NIL))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, unfolding LISTP and MEMBER, to:

          T.

  Case 6.11.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NUMBERP EXP)
                        (MEMBER VAR1 (LIST EXP))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))),

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

          T.

  Case 6.10.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NOT (NUMBERP EXP))
                        (MEMBER VAR1 NIL))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, opening up the functions LISTP and MEMBER,
    to:

          T.

  Case 6.9.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR (LIST EXP)))
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)),

    which again simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
    opening up the functions MEMBER, LISTP, VARIABLE, EQUAL, and COLLECT-FREE,
    to:

          T.

  Case 6.8.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (NUMBERP EXP))
                        (NOT (MEMBER VAR NIL))
                        (NOT (MEMBER VAR1 NIL)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)),

    which again simplifies, opening up the definitions of LISTP, MEMBER,
    VARIABLE, EQUAL, and COLLECT-FREE, to:

          T.

  Case 6.7.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)),

    which again simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
    and unfolding the functions MEMBER, LISTP, VARIABLE, EQUAL, and
    COLLECT-FREE, to:

          T.

  Case 6.6.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NOT (NUMBERP EXP))
                        (NOT (MEMBER VAR1 NIL)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          F)),

    which again simplifies, opening up the functions LISTP, MEMBER, VARIABLE,
    EQUAL, and COLLECT-FREE, to:

          T.

  Case 6.5.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR (LIST EXP)))
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (EQUAL EXP VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE TERM 0))
                          F)),

    which again simplifies, applying CDR-CONS and CAR-CONS, and unfolding the
    functions MEMBER and LISTP, to:

          T.

  Case 6.4.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (EQUAL VAR VAR1)
                        (NUMBERP EXP)
                        (NOT (MEMBER VAR1 (LIST EXP)))
                        (EQUAL EXP VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE TERM 0))
                          F)).

    However this again simplifies, applying CAR-CONS, and unfolding MEMBER, to:

          T.

  Case 6.3.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (EQUAL VAR VAR1))
                        (NOT (NUMBERP EXP))
                        (MEMBER VAR NIL))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          T)).

    But this again simplifies, opening up the functions LISTP and MEMBER, to:

          T.

  Case 6.2.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (EQUAL VAR VAR1))
                        (NUMBERP EXP)
                        (MEMBER VAR (LIST EXP))
                        (NOT (EQUAL EXP VAR1)))
                   (EQUAL (MEMBER VAR (COLLECT-FREE EXP 0))
                          T)),

    which again simplifies, rewriting with CDR-CONS and CAR-CONS, and
    unfolding the functions MEMBER, LISTP, VARIABLE, EQUAL, and COLLECT-FREE,
    to:

          T.

  Case 6.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (NOT (F-NOTP EXP))
                        (NOT (F-ORP EXP))
                        (NOT (FORSOMEP EXP))
                        (NOT (LISTP EXP))
                        (NUMBERP VAR)
                        (NUMBERP VAR1)
                        (NOT (EQUAL VAR VAR1))
                        (NUMBERP EXP)
                        (MEMBER VAR (LIST EXP))
                        (EQUAL EXP VAR1))
                   (EQUAL (MEMBER VAR (COLLECT-FREE TERM 0))
                          T)).

    But this again simplifies, appealing to the lemmas CDR-CONS and CAR-CONS,
    and opening up the definitions of MEMBER and LISTP, to:

          T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COVERING (CAR EXP) VAR1 0))
                      (MEMBER VAR
                              (COVERING (CDR EXP) VAR1 1))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))),

  which simplifies, applying MEMBER-APPEND, and opening up the definitions of
  ZEROP, VARIABLE, and COVERING, to:

        T.

Case 4. (IMPLIES
                (AND (NOT (ZEROP FLG))
                     (LISTP EXP)
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (OR (AND (NOT (EQUAL VAR VAR1))
                                     (MEMBER VAR
                                             (COLLECT-FREE (CAR EXP) 0)))
                                (AND (MEMBER VAR1
                                             (COLLECT-FREE (CAR EXP) 0))
                                     (MEMBER VAR (COLLECT-FREE TERM 0)))))
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (VARIABLE VAR)
                     (VARIABLE VAR1)
                     (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                             FLG))
                       (OR (AND (NOT (EQUAL VAR VAR1))
                                (MEMBER VAR (COLLECT-FREE EXP FLG)))
                           (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                (MEMBER VAR
                                        (COLLECT-FREE TERM 0)))))).

  This simplifies, rewriting with MEMBER-APPEND, VAR-COVERING-VAR, CDR-CONS,
  and CAR-CONS, and expanding the definitions of ZEROP, NOT, AND, OR, VARIABLE,
  COVERING, SUBST, and COLLECT-FREE, to 12 new goals:

  Case 4.12.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)),

    which again simplifies, obviously, to:

          T.

  Case 4.11.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, opening up the definition of EQUAL, to:

          T.

  Case 4.10.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, unfolding EQUAL, to:

          T.

  Case 4.9.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, appealing to the lemma VAR-COVERING-VAR, to:

          T.

  Case 4.8.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))),

    which again simplifies, applying VAR-COVERING-VAR, to:

          T.

  Case 4.7.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))).

    This again simplifies, obviously, to:

          T.

  Case 4.6.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    However this again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 4.5.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 4.4.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 4.3.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 4.2.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 4.1.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COVERING (CDR EXP) VAR1 1))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))).

    This again simplifies, clearly, to:

          T.

Case 3. (IMPLIES
                (AND (NOT (ZEROP FLG))
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (OR (AND (NOT (EQUAL VAR VAR1))
                                     (MEMBER VAR
                                             (COLLECT-FREE (CDR EXP) 1)))
                                (AND (MEMBER VAR1
                                             (COLLECT-FREE (CDR EXP) 1))
                                     (MEMBER VAR (COLLECT-FREE TERM 0)))))
                     (VARIABLE VAR)
                     (VARIABLE VAR1)
                     (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                             FLG))
                       (OR (AND (NOT (EQUAL VAR VAR1))
                                (MEMBER VAR (COLLECT-FREE EXP FLG)))
                           (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                (MEMBER VAR
                                        (COLLECT-FREE TERM 0)))))).

  This simplifies, rewriting with the lemmas MEMBER-APPEND, VAR-COVERING-VAR,
  CDR-CONS, and CAR-CONS, and expanding the definitions of ZEROP, NOT, AND, OR,
  VARIABLE, COVERING, SUBST, and COLLECT-FREE, to the following 12 new
  conjectures:

  Case 3.12.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, clearly, to:

          T.

  Case 3.11.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 3.10.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    But this again simplifies, applying VAR-COVERING-VAR, to:

          T.

  Case 3.9.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 3.8.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 3.7.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))).

    This again simplifies, obviously, to:

          T.

  Case 3.6.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, trivially, to:

          T.

  Case 3.5.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 3.4.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 3.3.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, rewriting with VAR-COVERING-VAR, to:

          T.

  Case 3.2.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 3.1.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (MEMBER VAR
                             (COVERING (CAR EXP) VAR1 0))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (NOT (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))).

    However this again simplifies, appealing to the lemma VAR-COVERING-VAR, to:

          T.

Case 2. (IMPLIES
                (AND (NOT (ZEROP FLG))
                     (LISTP EXP)
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (OR (AND (NOT (EQUAL VAR VAR1))
                                     (MEMBER VAR
                                             (COLLECT-FREE (CAR EXP) 0)))
                                (AND (MEMBER VAR1
                                             (COLLECT-FREE (CAR EXP) 0))
                                     (MEMBER VAR (COLLECT-FREE TERM 0)))))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (OR (AND (NOT (EQUAL VAR VAR1))
                                     (MEMBER VAR
                                             (COLLECT-FREE (CDR EXP) 1)))
                                (AND (MEMBER VAR1
                                             (COLLECT-FREE (CDR EXP) 1))
                                     (MEMBER VAR (COLLECT-FREE TERM 0)))))
                     (VARIABLE VAR)
                     (VARIABLE VAR1)
                     (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                             FLG))
                       (OR (AND (NOT (EQUAL VAR VAR1))
                                (MEMBER VAR (COLLECT-FREE EXP FLG)))
                           (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                (MEMBER VAR
                                        (COLLECT-FREE TERM 0)))))),

  which simplifies, applying the lemmas MEMBER-APPEND, CDR-CONS, CAR-CONS,
  VAR-COVERING-VAR, and SUBST-IDENT, and unfolding the definitions of ZEROP,
  NOT, AND, OR, VARIABLE, COVERING, SUBST, COLLECT-FREE, and EQUAL, to 16 new
  formulas:

  Case 2.16.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)),

    which again simplifies, clearly, to:

          T.

  Case 2.15.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 2.14.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, clearly, to:

          T.

  Case 2.13.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 2.12.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                             0))
                       F)).

    This again simplifies, trivially, to:

          T.

  Case 2.11.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 2.10.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 2.9.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CAR EXP) 0))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    However this again simplifies, opening up the definition of EQUAL, to:

          T.

  Case 2.8.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)),

    which again simplifies, obviously, to:

          T.

  Case 2.7.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (EQUAL VAR VAR1)
                     (MEMBER VAR1
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, obviously, to:

          T.

  Case 2.6.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       F)).

    This again simplifies, trivially, to:

          T.

  Case 2.5.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 2.4.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CAR EXP) 0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                             0))
                       F)).

    This again simplifies, trivially, to:

          T.

  Case 2.3.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (CDR EXP) 1)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            F)
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (CAR EXP) 0)))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                             0))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, trivially, to:

          T.

  Case 2.2.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (NOT (MEMBER VAR
                                  (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                                0))))
                (EQUAL (MEMBER VAR
                               (COLLECT-FREE (SUBST (CDR EXP) VAR TERM 1)
                                             1))
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

  Case 2.1.
          (IMPLIES
                (AND (NOT (EQUAL FLG 0))
                     (NUMBERP FLG)
                     (LISTP EXP)
                     (EQUAL VAR VAR1)
                     (NOT (MEMBER VAR1
                                  (COLLECT-FREE (CAR EXP) 0)))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                  0))
                            F)
                     (MEMBER VAR
                             (COLLECT-FREE (CDR EXP) 1))
                     (EQUAL (MEMBER VAR
                                    (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                  1))
                            (MEMBER VAR (COLLECT-FREE TERM 0)))
                     (NUMBERP VAR)
                     (MEMBER VAR
                             (COLLECT-FREE (SUBST (CAR EXP) VAR TERM 0)
                                           0)))
                (EQUAL T
                       (MEMBER VAR (COLLECT-FREE TERM 0)))).

    This again simplifies, clearly, to:

          T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (VARIABLE VAR)
                      (VARIABLE VAR1)
                      (NOT (MEMBER VAR (COVERING EXP VAR1 FLG))))
                 (EQUAL (MEMBER VAR
                                (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                              FLG))
                        (OR (AND (NOT (EQUAL VAR VAR1))
                                 (MEMBER VAR (COLLECT-FREE EXP FLG)))
                            (AND (MEMBER VAR1 (COLLECT-FREE EXP FLG))
                                 (MEMBER VAR
                                         (COLLECT-FREE TERM 0)))))).

  This simplifies, applying SUBST-IDENT, and opening up the functions ZEROP,
  VARIABLE, COVERING, LISTP, MEMBER, COLLECT-FREE, NOT, AND, OR, and EQUAL, to:

        T.


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


[ 0.0 1.5 0.3 ]

COLLECT-FREE-SUBST


(PROVE-LEMMA FREE-FOR-SUBST
             (REWRITE)
             (IMPLIES (AND (VARIABLE AUX)
                           (VARIABLE VAR)
                           (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                           (NOT (MEMBER AUX (COVERING A VAR FLG))))
                      (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                       AUX FLG)
                             (COVERING A VAR FLG)))
             ((INDUCT (COVERING A VAR FLG))))

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

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (F-NOTP A)
                      (IMPLIES (AND (NUMBERP AUX)
                                    (NUMBERP VAR)
                                    (NOT (MEMBER AUX (COLLECT-FREE (ARG A) 0)))
                                    (NOT (MEMBER AUX
                                                 (COVERING (ARG A) VAR 0))))
                               (EQUAL (COVERING (SUBST (ARG A) VAR AUX 0)
                                                AUX 0)
                                      (COVERING (ARG A) VAR 0)))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))),

  which simplifies, applying ARG-F-NOT, COLLECT-FREE-FLG, COVERING-FLG, and
  SUBST-FLG, and opening up ZEROP, NOT, AND, IMPLIES, VARIABLE, EQUAL,
  COLLECT-FREE, COVERING, and SUBST, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP A))
                      (F-ORP A)
                      (IMPLIES (AND (NUMBERP AUX)
                                    (NUMBERP VAR)
                                    (NOT (MEMBER AUX
                                                 (COLLECT-FREE (ARG2 A) 0)))
                                    (NOT (MEMBER AUX
                                                 (COVERING (ARG2 A) VAR 0))))
                               (EQUAL (COVERING (SUBST (ARG2 A) VAR AUX 0)
                                                AUX 0)
                                      (COVERING (ARG2 A) VAR 0)))
                      (IMPLIES (AND (NUMBERP AUX)
                                    (NUMBERP VAR)
                                    (NOT (MEMBER AUX
                                                 (COLLECT-FREE (ARG1 A) 0)))
                                    (NOT (MEMBER AUX
                                                 (COVERING (ARG1 A) VAR 0))))
                               (EQUAL (COVERING (SUBST (ARG1 A) VAR AUX 0)
                                                AUX 0)
                                      (COVERING (ARG1 A) VAR 0)))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))).

  This simplifies, appealing to the lemmas MEMBER-APPEND, ARG2-F-OR, ARG1-F-OR,
  COLLECT-FREE-FLG, COVERING-FLG, and SUBST-FLG, and unfolding the functions
  ZEROP, NOT, AND, IMPLIES, VARIABLE, EQUAL, COLLECT-FREE, COVERING, and SUBST,
  to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP A))
                      (NOT (F-ORP A))
                      (FORSOMEP A)
                      (MEMB VAR (COLLECT-FREE A 0))
                      (IMPLIES (AND (NUMBERP AUX)
                                    (NUMBERP VAR)
                                    (NOT (MEMBER AUX
                                                 (COLLECT-FREE (BODY A) 0)))
                                    (NOT (MEMBER AUX
                                                 (COVERING (BODY A) VAR 0))))
                               (EQUAL (COVERING (SUBST (BODY A) VAR AUX 0)
                                                AUX 0)
                                      (COVERING (BODY A) VAR 0)))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))).

  This simplifies, appealing to the lemmas MEMB-MEMBER-NUMBERP, CDR-CONS,
  CAR-CONS, NUMBERP-EQL, COLLECT-FREE-FLG, COVERING-FLG, and SUBST-FLG, and
  unfolding the functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE, NOT, AND,
  IMPLIES, COVERING, MEMBER, OR, and SUBST, to the following eight new
  conjectures:

  Case 6.8.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (MEMBER AUX (COLLECT-FREE (BODY A) 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (NOT (EQUAL (BIND A) VAR)))
                   (EQUAL (COVERING (FORSOME (BIND A)
                                             (SUBST (BODY A) VAR AUX 0))
                                    AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))).

    But this again simplifies, applying the lemmas NUMBERP-EQL and MEMBER-DEL1,
    and unfolding the definition of OR, to:

          T.

  Case 6.7.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (MEMBER AUX (COLLECT-FREE (BODY A) 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (EQUAL (BIND A) VAR))
                   (EQUAL (COVERING A AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))),

    which again simplifies, applying MEMBER-DEL, to:

          T.

  Case 6.6.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (EQUAL (COVERING (SUBST (BODY A) VAR AUX 0)
                                         AUX 0)
                               (COVERING (BODY A) VAR 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (NOT (EQUAL (BIND A) VAR)))
                   (EQUAL (COVERING (FORSOME (BIND A)
                                             (SUBST (BODY A) VAR AUX 0))
                                    AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))).

    This again simplifies, rewriting with NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, COLLECT-FREE-SUBST, CAR-CONS, BIND-FORSOME, and
    BODY-FORSOME, and unfolding the definitions of OR, MEMBER, COLLECT-FREE,
    VARIABLE, EQUAL, and COVERING, to:

          (IMPLIES (AND (FORSOMEP A)
                        (MEMBER VAR (COLLECT-FREE (BODY A) 0))
                        (EQUAL (COVERING (SUBST (BODY A) VAR AUX 0)
                                         AUX 0)
                               (COVERING (BODY A) VAR 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (COLLECT-FREE (BODY A) 0)))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (NOT (EQUAL (BIND A) VAR)))
                   (NOT (EQUAL AUX VAR))),

    which again simplifies, trivially, to:

          T.

  Case 6.5.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (EQUAL (COVERING (SUBST (BODY A) VAR AUX 0)
                                         AUX 0)
                               (COVERING (BODY A) VAR 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (EQUAL (BIND A) VAR))
                   (EQUAL (COVERING A AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))).

    But this again simplifies, applying MEMBER-DEL, to:

          T.

  Case 6.4.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (MEMBER AUX (COLLECT-FREE (BODY A) 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (NOT (EQUAL (BIND A) VAR)))
                   (EQUAL (COVERING (FORSOME (BIND A)
                                             (SUBST (BODY A) VAR AUX 0))
                                    AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))).

    But this again simplifies, applying NUMBERP-EQL and MEMBER-DEL1, and
    opening up the function OR, to:

          T.

  Case 6.3.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (MEMBER AUX (COLLECT-FREE (BODY A) 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (EQUAL (BIND A) VAR))
                   (EQUAL (COVERING A AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))).

    However this again simplifies, applying MEMBER-DEL, to:

          T.

  Case 6.2.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (EQUAL (COVERING (SUBST (BODY A) VAR AUX 0)
                                         AUX 0)
                               (COVERING (BODY A) VAR 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (NOT (EQUAL (BIND A) VAR)))
                   (EQUAL (COVERING (FORSOME (BIND A)
                                             (SUBST (BODY A) VAR AUX 0))
                                    AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))).

    This again simplifies, applying NUMBERP-EQL, MEMBER-DEL1,
    MEMB-MEMBER-NUMBERP, COLLECT-FREE-SUBST, CAR-CONS, BIND-FORSOME, and
    BODY-FORSOME, and unfolding OR, MEMBER, COLLECT-FREE, VARIABLE, EQUAL, and
    COVERING, to:

          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP A)
                        (MEMBER VAR (COLLECT-FREE (BODY A) 0))
                        (EQUAL (COVERING (SUBST (BODY A) VAR AUX 0)
                                         AUX 0)
                               (COVERING (BODY A) VAR 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (COLLECT-FREE (BODY A) 0)))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (NOT (EQUAL (BIND A) VAR)))
                   (NOT (EQUAL AUX VAR))),

    which again simplifies, trivially, to:

          T.

  Case 6.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP A)
                        (MEMBER VAR
                                (DEL (BIND A)
                                     (COLLECT-FREE (BODY A) 0)))
                        (EQUAL (COVERING (SUBST (BODY A) VAR AUX 0)
                                         AUX 0)
                               (COVERING (BODY A) VAR 0))
                        (NUMBERP AUX)
                        (NUMBERP VAR)
                        (NOT (MEMBER AUX
                                     (DEL (BIND A)
                                          (COLLECT-FREE (BODY A) 0))))
                        (NOT (EQUAL AUX (BIND A)))
                        (NOT (MEMBER AUX
                                     (COVERING (BODY A) VAR 0)))
                        (EQUAL (BIND A) VAR))
                   (EQUAL (COVERING A AUX 0)
                          (CONS (BIND A)
                                (COVERING (BODY A) VAR 0)))).

    This again simplifies, applying MEMBER-DEL, to:

          T.

Case 5. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP A))
                      (NOT (F-ORP A))
                      (FORSOMEP A)
                      (NOT (MEMB VAR (COLLECT-FREE A 0)))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))).

  This simplifies, applying MEMB-MEMBER-NUMBERP, SUBST-IDENT, COLLECT-FREE-FLG,
  and COVERING-FLG, and opening up the definitions of ZEROP, EQUAL, COVERING,
  LISTP, and MEMBER, to:

        T.

Case 4. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP A))
                      (NOT (F-ORP A))
                      (NOT (FORSOMEP A))
                      (LISTP A)
                      (IMPLIES (AND (NUMBERP AUX)
                                    (NUMBERP VAR)
                                    (NOT (MEMBER AUX (COLLECT-FREE (CDR A) 1)))
                                    (NOT (MEMBER AUX
                                                 (COVERING (CDR A) VAR 1))))
                               (EQUAL (COVERING (SUBST (CDR A) VAR AUX 1)
                                                AUX 1)
                                      (COVERING (CDR A) VAR 1)))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))),

  which simplifies, rewriting with CDR-CONS, COLLECT-FREE-FLG, COVERING-FLG,
  and SUBST-FLG, and unfolding the functions ZEROP, NOT, AND, IMPLIES,
  VARIABLE, EQUAL, COLLECT-FREE, COVERING, and SUBST, to:

        T.

Case 3. (IMPLIES (AND (ZEROP FLG)
                      (NOT (F-NOTP A))
                      (NOT (F-ORP A))
                      (NOT (FORSOMEP A))
                      (NOT (LISTP A))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))).

  This simplifies, applying SUBST-IDENT, COLLECT-FREE-FLG, COVERING-FLG, and
  SUBST-FLG, and opening up the functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE,
  COVERING, LISTP, MEMBER, and SUBST, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL FLG 0))
                      (NUMBERP FLG)
                      (LISTP A)
                      (IMPLIES (AND (NUMBERP AUX)
                                    (NUMBERP VAR)
                                    (NOT (MEMBER AUX (COLLECT-FREE (CDR A) 1)))
                                    (NOT (MEMBER AUX
                                                 (COVERING (CDR A) VAR 1))))
                               (EQUAL (COVERING (SUBST (CDR A) VAR AUX 1)
                                                AUX 1)
                                      (COVERING (CDR A) VAR 1)))
                      (IMPLIES (AND (NUMBERP AUX)
                                    (NUMBERP VAR)
                                    (NOT (MEMBER AUX (COLLECT-FREE (CAR A) 0)))
                                    (NOT (MEMBER AUX
                                                 (COVERING (CAR A) VAR 0))))
                               (EQUAL (COVERING (SUBST (CAR A) VAR AUX 0)
                                                AUX 0)
                                      (COVERING (CAR A) VAR 0)))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))),

  which simplifies, rewriting with MEMBER-APPEND, CDR-CONS, and CAR-CONS, and
  unfolding the functions NOT, AND, IMPLIES, COLLECT-FREE, COVERING, and SUBST,
  to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL FLG 0))
                      (NUMBERP FLG)
                      (NOT (LISTP A))
                      (NUMBERP AUX)
                      (NUMBERP VAR)
                      (NOT (MEMBER AUX (COLLECT-FREE A FLG)))
                      (NOT (MEMBER AUX (COVERING A VAR FLG))))
                 (EQUAL (COVERING (SUBST A VAR AUX FLG)
                                  AUX FLG)
                        (COVERING A VAR FLG))).

  This simplifies, rewriting with the lemma SUBST-IDENT, and opening up the
  definitions of COLLECT-FREE, LISTP, MEMBER, COVERING, and EQUAL, to:

        T.

Q.E.D.


[ 0.0 0.3 0.1 ]

FREE-FOR-SUBST


(PROVE-LEMMA NOT-FREE-COVERING
             (REWRITE)
             (IMPLIES (AND (VARIABLE VAR)
                           (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                      (EQUAL (COVERING EXP VAR FLG) NIL)))

This formula can be simplified, using the abbreviations NOT, AND, IMPLIES, and
VARIABLE, to the new formula:

      (IMPLIES (AND (NUMBERP VAR)
                    (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
               (EQUAL (COVERING EXP VAR FLG) NIL)),

which we will name *1.


     We will appeal to induction.  There are two plausible inductions.
However, they merge into one likely candidate induction.  We will induct
according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG) (VARIABLE EXP))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p (ARG EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p (ARG1 EXP) VAR 0)
                         (p (ARG2 EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (p (BODY EXP) VAR 0))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p (CDR EXP) VAR 1))
                    (p EXP VAR FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p EXP VAR FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p (CAR EXP) VAR 0)
                         (p (CDR EXP) VAR 1))
                    (p EXP VAR FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p EXP VAR FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme leads to the following 17 new formulas:

Case 17.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)).

  This simplifies, rewriting with CDR-CONS, CAR-CONS, COLLECT-FREE-FLG, and
  COVERING-FLG, and opening up ZEROP, VARIABLE, EQUAL, COLLECT-FREE, MEMBER,
  LISTP, and COVERING, to:

        T.

Case 16.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG EXP) 0))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, applying COLLECT-FREE-FLG, and unfolding the functions
  ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 15.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (EQUAL (COVERING (ARG EXP) VAR 0) NIL)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)).

  This simplifies, rewriting with COLLECT-FREE-FLG and COVERING-FLG, and
  unfolding the functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE, and COVERING,
  to:

        T.

Case 14.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG1 EXP) 0))
                      (MEMBER VAR
                              (COLLECT-FREE (ARG2 EXP) 0))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, appealing to the lemmas MEMBER-APPEND and COLLECT-FREE-FLG,
  and expanding the functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 13.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (EQUAL (COVERING (ARG1 EXP) VAR 0)
                             NIL)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG2 EXP) 0))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, rewriting with MEMBER-APPEND and COLLECT-FREE-FLG, and
  opening up the functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 12.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG1 EXP) 0))
                      (EQUAL (COVERING (ARG2 EXP) VAR 0)
                             NIL)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)).

  This simplifies, rewriting with MEMBER-APPEND and COLLECT-FREE-FLG, and
  opening up the definitions of ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 11.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (EQUAL (COVERING (ARG1 EXP) VAR 0)
                             NIL)
                      (EQUAL (COVERING (ARG2 EXP) VAR 0)
                             NIL)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, rewriting with the lemmas MEMBER-APPEND, COLLECT-FREE-FLG,
  and COVERING-FLG, and unfolding ZEROP, VARIABLE, EQUAL, COLLECT-FREE, APPEND,
  LISTP, and COVERING, to:

        T.

Case 10.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (BODY EXP) 0))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, applying MEMB-MEMBER-NUMBERP, COLLECT-FREE-FLG, and
  COVERING-FLG, and expanding the functions ZEROP, VARIABLE, EQUAL,
  COLLECT-FREE, and COVERING, to:

        T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQUAL (COVERING (BODY EXP) VAR 0)
                             NIL)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)).

  This simplifies, rewriting with MEMB-MEMBER-NUMBERP, COLLECT-FREE-FLG, and
  COVERING-FLG, and unfolding ZEROP, VARIABLE, EQUAL, COLLECT-FREE, and
  COVERING, to:

        T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, applying the lemma COLLECT-FREE-FLG, and unfolding the
  definitions of ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (EQUAL (COVERING (CDR EXP) VAR 1) NIL)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, applying COLLECT-FREE-FLG and COVERING-FLG, and opening up
  the definitions of ZEROP, VARIABLE, EQUAL, COLLECT-FREE, and COVERING, to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)).

  This simplifies, applying COLLECT-FREE-FLG and COVERING-FLG, and expanding
  the definitions of ZEROP, VARIABLE, EQUAL, COLLECT-FREE, LISTP, MEMBER, and
  COVERING, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CAR EXP) 0))
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, applying MEMBER-APPEND, and unfolding ZEROP and
  COLLECT-FREE, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL (COVERING (CAR EXP) VAR 0) NIL)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)).

  This simplifies, rewriting with MEMBER-APPEND, and expanding ZEROP and
  COLLECT-FREE, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CAR EXP) 0))
                      (EQUAL (COVERING (CDR EXP) VAR 1) NIL)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, applying MEMBER-APPEND, and opening up ZEROP and
  COLLECT-FREE, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (EQUAL (COVERING (CAR EXP) VAR 0) NIL)
                      (EQUAL (COVERING (CDR EXP) VAR 1) NIL)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)).

  This simplifies, applying MEMBER-APPEND, and opening up ZEROP, COLLECT-FREE,
  COVERING, LISTP, APPEND, and EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG))))
                 (EQUAL (COVERING EXP VAR FLG) NIL)),

  which simplifies, unfolding the definitions of ZEROP, COLLECT-FREE, LISTP,
  MEMBER, COVERING, and EQUAL, to:

        T.


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


[ 0.0 0.1 0.1 ]

NOT-FREE-COVERING


(PROVE-LEMMA NOT-MEMBER-DELETE2
             (REWRITE)
             (EQUAL (MEMBER X (DEL Y Z))
                    (AND (NOT (EQL X Y)) (MEMBER X Z))))

WARNING:  the newly proposed lemma, NOT-MEMBER-DELETE2, could be applied
whenever the previously added lemma MEMBER-DEL1 could.




This formula simplifies, expanding NOT and AND, to two new conjectures:

Case 2. (IMPLIES (NOT (EQL X Y))
                 (EQUAL (MEMBER X (DEL Y Z))
                        (MEMBER X Z))),

  which again simplifies, applying MEMBER-DEL1, to:

        T.

Case 1. (IMPLIES (EQL X Y)
                 (EQUAL (MEMBER X (DEL Y Z)) F)).

  This again simplifies, trivially, to:

        (IMPLIES (EQL X Y)
                 (NOT (MEMBER X (DEL Y Z)))),

  which we will name *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 Z)
                         (EQL Y (CAR Z))
                         (p X Y (CDR Z)))
                    (p X Y Z))
           (IMPLIES (AND (LISTP Z)
                         (NOT (EQL Y (CAR Z)))
                         (p X Y (CDR Z)))
                    (p X Y Z))
           (IMPLIES (NOT (LISTP Z)) (p X Y Z))).
Linear arithmetic and the lemma CDR-LESSP establish that the measure (COUNT Z)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates the following three new
formulas:

Case 3. (IMPLIES (AND (LISTP Z)
                      (EQL Y (CAR Z))
                      (NOT (MEMBER X (DEL Y (CDR Z))))
                      (EQL X Y))
                 (NOT (MEMBER X (DEL Y Z)))).

  This simplifies, opening up DEL, to:

        T.

Case 2. (IMPLIES (AND (LISTP Z)
                      (NOT (EQL Y (CAR Z)))
                      (NOT (MEMBER X (DEL Y (CDR Z))))
                      (EQL X Y))
                 (NOT (MEMBER X (DEL Y Z)))).

  This simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
  unfolding the functions DEL and MEMBER, to:

        (IMPLIES (AND (LISTP Z)
                      (NOT (EQL Y (CAR Z)))
                      (NOT (MEMBER X (DEL Y (CDR Z))))
                      (EQL X Y))
                 (NOT (EQUAL X (CAR Z)))),

  which again simplifies, applying EQL-COMM, to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP Z)) (EQL X Y))
                 (NOT (MEMBER X (DEL Y Z)))).

  This simplifies, opening up the definitions of DEL and MEMBER, to:

        T.


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


[ 0.0 0.0 0.0 ]

NOT-MEMBER-DELETE2


(PROVE-LEMMA COLLECT-FREE-SUBST1
             (REWRITE)
             (IMPLIES (AND (VARIABLE VAR1)
                           (VARIABLE VAR)
                           (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                           (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                                 FLG)))))

This formula can be simplified, using the abbreviations NOT, AND, IMPLIES, and
VARIABLE, to:

      (IMPLIES (AND (NUMBERP VAR1)
                    (NUMBERP VAR)
                    (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                    (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
               (NOT (MEMBER VAR
                            (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                          FLG)))),

which we will name *1.


     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 (ZEROP FLG)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR1)))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p VAR (ARG EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p VAR (ARG2 EXP) VAR1 TERM 0)
                         (p VAR (ARG1 EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR1))
                         (p VAR (BODY EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p VAR (CDR EXP) VAR1 TERM 1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p VAR (CDR EXP) VAR1 TERM 1)
                         (p VAR (CAR EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p VAR EXP VAR1 TERM FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP can be used to show that the measure (COUNT EXP)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instances chosen for FLG.  The
above induction scheme produces 19 new conjectures:

Case 19.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR1)
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying CDR-CONS, CAR-CONS, COLLECT-FREE-FLG, and
  SUBST-FLG, and unfolding ZEROP, VARIABLE, EQUAL, COLLECT-FREE, MEMBER, LISTP,
  and SUBST, to:

        T.

Case 18.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR1))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, rewriting with CDR-CONS, CAR-CONS, SUBST-IDENT, and
  COLLECT-FREE-FLG, and expanding ZEROP, VARIABLE, EQUAL, COLLECT-FREE, MEMBER,
  and LISTP, to:

        T.

Case 17.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG EXP) 0))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying COLLECT-FREE-FLG, and expanding the definitions
  of ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 16.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, appealing to the lemmas ARG-F-NOT, COLLECT-FREE-FLG, and
  SUBST-FLG, and opening up ZEROP, VARIABLE, EQUAL, COLLECT-FREE, and SUBST,
  to:

        T.

Case 15.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG2 EXP) 0))
                      (MEMBER VAR
                              (COLLECT-FREE (ARG1 EXP) 0))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, rewriting with MEMBER-APPEND and COLLECT-FREE-FLG, and
  unfolding the definitions of ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 14.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0)))
                      (MEMBER VAR
                              (COLLECT-FREE (ARG1 EXP) 0))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying MEMBER-APPEND and COLLECT-FREE-FLG, and expanding
  the functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 13.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (ARG2 EXP) 0))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, applying MEMBER-APPEND and COLLECT-FREE-FLG, and opening up
  ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 12.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                                 0)))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (ARG1 EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying MEMBER-APPEND, ARG2-F-OR, ARG1-F-OR,
  COLLECT-FREE-FLG, and SUBST-FLG, and expanding ZEROP, VARIABLE, EQUAL,
  COLLECT-FREE, and SUBST, to:

        T.

Case 11.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (EQL (BIND EXP) VAR1)
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, rewriting with the lemmas NUMBERP-EQL, COLLECT-FREE-FLG,
  and SUBST-FLG, and expanding the functions ZEROP, VARIABLE, OR, EQUAL, and
  SUBST, to:

        T.

Case 10.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR1))
                      (MEMBER VAR
                              (COLLECT-FREE (BODY EXP) 0))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, rewriting with NUMBERP-EQL, NOT-MEMBER-DELETE2,
  COLLECT-FREE-FLG, and SUBST-FLG, and opening up ZEROP, VARIABLE, OR, EQUAL,
  COLLECT-FREE, and SUBST, to four new goals:

  Case 10.4.
          (IMPLIES
            (AND (EQUAL FLG 0)
                 (FORSOMEP EXP)
                 (NOT (EQUAL (BIND EXP) VAR1))
                 (MEMBER VAR
                         (COLLECT-FREE (BODY EXP) 0))
                 (NUMBERP VAR1)
                 (NUMBERP VAR)
                 (EQUAL VAR (BIND EXP))
                 (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                 (NOT (EQUAL VAR VAR1)))
            (NOT (MEMBER VAR
                         (COLLECT-FREE (FORSOME VAR
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0)))),

    which again simplifies, rewriting with BODY-FORSOME, BIND-FORSOME,
    NUMBERP-EQL, and NOT-MEMBER-DELETE2, and opening up the definitions of
    VARIABLE, EQUAL, COLLECT-FREE, and OR, to:

          T.

  Case 10.3.
          (IMPLIES (AND (EQUAL FLG 0)
                        (FORSOMEP EXP)
                        (NOT (EQUAL (BIND EXP) VAR1))
                        (MEMBER VAR
                                (COLLECT-FREE (BODY EXP) 0))
                        (NUMBERP VAR1)
                        (NUMBERP VAR)
                        (EQUAL VAR (BIND EXP))
                        (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                        (EQUAL VAR VAR1))
                   (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))).

    This again simplifies, clearly, to:

          T.

  Case 10.2.
          (IMPLIES
            (AND (NOT (NUMBERP FLG))
                 (FORSOMEP EXP)
                 (NOT (EQUAL (BIND EXP) VAR1))
                 (MEMBER VAR
                         (COLLECT-FREE (BODY EXP) 0))
                 (NUMBERP VAR1)
                 (NUMBERP VAR)
                 (EQUAL VAR (BIND EXP))
                 (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                 (NOT (EQUAL VAR VAR1)))
            (NOT (MEMBER VAR
                         (COLLECT-FREE (FORSOME VAR
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0)))).

    This again simplifies, applying BODY-FORSOME, BIND-FORSOME, NUMBERP-EQL,
    and NOT-MEMBER-DELETE2, and unfolding the definitions of VARIABLE, EQUAL,
    COLLECT-FREE, and OR, to:

          T.

  Case 10.1.
          (IMPLIES (AND (NOT (NUMBERP FLG))
                        (FORSOMEP EXP)
                        (NOT (EQUAL (BIND EXP) VAR1))
                        (MEMBER VAR
                                (COLLECT-FREE (BODY EXP) 0))
                        (NUMBERP VAR1)
                        (NUMBERP VAR)
                        (EQUAL VAR (BIND EXP))
                        (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                        (EQUAL VAR VAR1))
                   (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))).

    This again simplifies, trivially, to:

          T.

Case 9. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (FORSOMEP EXP)
                      (NOT (EQL (BIND EXP) VAR1))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, applying NUMBERP-EQL, NOT-MEMBER-DELETE2, BODY-FORSOME,
  BIND-FORSOME, COLLECT-FREE-FLG, and SUBST-FLG, and expanding the definitions
  of ZEROP, VARIABLE, OR, EQUAL, COLLECT-FREE, and SUBST, to four new goals:

  Case 9.4.
          (IMPLIES
            (AND (EQUAL FLG 0)
                 (FORSOMEP EXP)
                 (NOT (EQUAL (BIND EXP) VAR1))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                            0)))
                 (NUMBERP VAR1)
                 (NUMBERP VAR)
                 (EQUAL VAR (BIND EXP))
                 (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                 (NOT (EQUAL VAR VAR1)))
            (NOT (MEMBER VAR
                         (COLLECT-FREE (FORSOME VAR
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0)))),

    which again simplifies, appealing to the lemmas BODY-FORSOME, BIND-FORSOME,
    NUMBERP-EQL, and NOT-MEMBER-DELETE2, and expanding the definitions of
    VARIABLE, EQUAL, COLLECT-FREE, and OR, to:

          T.

  Case 9.3.
          (IMPLIES
                 (AND (EQUAL FLG 0)
                      (FORSOMEP EXP)
                      (NOT (EQUAL (BIND EXP) VAR1))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (EQUAL VAR (BIND EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                      (EQUAL VAR VAR1))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))),

    which again simplifies, obviously, to:

          T.

  Case 9.2.
          (IMPLIES
            (AND (NOT (NUMBERP FLG))
                 (FORSOMEP EXP)
                 (NOT (EQUAL (BIND EXP) VAR1))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                            0)))
                 (NUMBERP VAR1)
                 (NUMBERP VAR)
                 (EQUAL VAR (BIND EXP))
                 (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                 (NOT (EQUAL VAR VAR1)))
            (NOT (MEMBER VAR
                         (COLLECT-FREE (FORSOME VAR
                                                (SUBST (BODY EXP) VAR1 TERM 0))
                                       0)))).

    However this again simplifies, rewriting with BODY-FORSOME, BIND-FORSOME,
    NUMBERP-EQL, and NOT-MEMBER-DELETE2, and opening up VARIABLE, EQUAL,
    COLLECT-FREE, and OR, to:

          T.

  Case 9.1.
          (IMPLIES
                 (AND (NOT (NUMBERP FLG))
                      (FORSOMEP EXP)
                      (NOT (EQUAL (BIND EXP) VAR1))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (BODY EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (EQUAL VAR (BIND EXP))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0)))
                      (EQUAL VAR VAR1))
                 (NOT (MEMBER VAR (COLLECT-FREE EXP 0)))).

    This again simplifies, trivially, to:

          T.

Case 8. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, rewriting with COLLECT-FREE-FLG, and expanding ZEROP,
  VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 7. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (LISTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                 1)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, rewriting with CDR-CONS, COLLECT-FREE-FLG, and SUBST-FLG,
  and unfolding the functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE, and SUBST,
  to:

        T.

Case 6. (IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (NOT (F-ORP EXP))
                      (NOT (FORSOMEP EXP))
                      (NOT (LISTP EXP))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, rewriting with SUBST-IDENT and COLLECT-FREE-FLG, and
  expanding ZEROP, VARIABLE, EQUAL, COLLECT-FREE, LISTP, and MEMBER, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (MEMBER VAR
                              (COLLECT-FREE (CAR EXP) 0))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying MEMBER-APPEND, and expanding ZEROP and
  COLLECT-FREE, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                 1)))
                      (MEMBER VAR
                              (COLLECT-FREE (CAR EXP) 0))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))).

  This simplifies, rewriting with MEMBER-APPEND, and opening up the functions
  ZEROP and COLLECT-FREE, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (CDR EXP) 1))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying the lemma MEMBER-APPEND, and unfolding the
  definitions of ZEROP and COLLECT-FREE, to:

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP FLG))
                      (LISTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (CDR EXP) VAR1 TERM 1)
                                                 1)))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (SUBST (CAR EXP) VAR1 TERM 0)
                                                 0)))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying the lemmas MEMBER-APPEND, CDR-CONS, and CAR-CONS,
  and opening up the definitions of ZEROP, COLLECT-FREE, and SUBST, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP FLG))
                      (NOT (LISTP EXP))
                      (NUMBERP VAR1)
                      (NUMBERP VAR)
                      (NOT (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (NOT (MEMBER VAR (COLLECT-FREE TERM 0))))
                 (NOT (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG)))),

  which simplifies, applying SUBST-IDENT, and opening up the definitions of
  ZEROP, COLLECT-FREE, LISTP, and MEMBER, to:

        T.


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


[ 0.0 0.2 0.0 ]

COLLECT-FREE-SUBST1


(PROVE-LEMMA COLLECT-FREE-SUBST2
             (REWRITE)
             (IMPLIES (AND (VARIABLE VAR)
                           (VARIABLE VAR1)
                           (NOT (EQUAL VAR VAR1))
                           (MEMBER VAR (COLLECT-FREE EXP FLG)))
                      (MEMBER VAR
                              (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                            FLG))))

This conjecture can be simplified, using the abbreviations NOT, AND, IMPLIES,
and VARIABLE, to the conjecture:

      (IMPLIES (AND (NUMBERP VAR)
                    (NUMBERP VAR1)
                    (NOT (EQUAL VAR VAR1))
                    (MEMBER VAR (COLLECT-FREE EXP FLG)))
               (MEMBER VAR
                       (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                     FLG))).

Call the above conjecture *1.


     We will appeal to induction.  There are two plausible inductions.
However, they merge into one likely candidate induction.  We will induct
according to the following scheme:
      (AND (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (EQUAL EXP VAR1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (VARIABLE EXP)
                         (NOT (EQUAL EXP VAR1)))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (F-NOTP EXP)
                         (p VAR (ARG EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (F-ORP EXP)
                         (p VAR (ARG2 EXP) VAR1 TERM 0)
                         (p VAR (ARG1 EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (EQL (BIND EXP) VAR1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (FORSOMEP EXP)
                         (NOT (EQL (BIND EXP) VAR1))
                         (p VAR (BODY EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (LISTP EXP)
                         (p VAR (CDR EXP) VAR1 TERM 1))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (ZEROP FLG)
                         (NOT (VARIABLE EXP))
                         (NOT (F-NOTP EXP))
                         (NOT (F-ORP EXP))
                         (NOT (FORSOMEP EXP))
                         (NOT (LISTP EXP)))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (LISTP EXP)
                         (p VAR (CDR EXP) VAR1 TERM 1)
                         (p VAR (CAR EXP) VAR1 TERM 0))
                    (p VAR EXP VAR1 TERM FLG))
           (IMPLIES (AND (NOT (ZEROP FLG))
                         (NOT (LISTP EXP)))
                    (p VAR EXP VAR1 TERM FLG))).
Linear arithmetic and the lemmas ARG-LESSP, ARG2-LESSP, ARG1-LESSP, BODY-LESSP,
CDR-LESSP, and CAR-LESSP inform us that the measure (COUNT EXP) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  Note, however, the inductive instances chosen for FLG.  The above
induction scheme leads to the following 19 new formulas:

Case 19.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (EQUAL EXP VAR1)
                      (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (EQUAL VAR VAR1))
                      (MEMBER VAR (COLLECT-FREE EXP FLG)))
                 (MEMBER VAR
                         (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                       FLG))).

  This simplifies, rewriting with CDR-CONS, CAR-CONS, and COLLECT-FREE-FLG,
  and opening up ZEROP, VARIABLE, EQUAL, COLLECT-FREE, MEMBER, and LISTP, to:

        T.

Case 18.(IMPLIES (AND (ZEROP FLG)
                      (VARIABLE EXP)
                      (NOT (EQUAL EXP VAR1))
                      (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (EQUAL VAR VAR1))
                      (MEMBER VAR (COLLECT-FREE EXP FLG)))
                 (MEMBER VAR
                         (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                       FLG))),

  which simplifies, applying CDR-CONS, CAR-CONS, SUBST-IDENT, and
  COLLECT-FREE-FLG, and unfolding the functions ZEROP, VARIABLE, EQUAL,
  COLLECT-FREE, MEMBER, and LISTP, to:

        T.

Case 17.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (ARG EXP) 0)))
                      (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (EQUAL VAR VAR1))
                      (MEMBER VAR (COLLECT-FREE EXP FLG)))
                 (MEMBER VAR
                         (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                       FLG))).

  This simplifies, rewriting with COLLECT-FREE-FLG, and unfolding the
  functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 16.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (F-NOTP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG EXP) VAR1 TERM 0)
                                            0))
                      (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (EQUAL VAR VAR1))
                      (MEMBER VAR (COLLECT-FREE EXP FLG)))
                 (MEMBER VAR
                         (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                       FLG))),

  which simplifies, appealing to the lemmas ARG-F-NOT, COLLECT-FREE-FLG, and
  SUBST-FLG, and expanding the functions ZEROP, VARIABLE, EQUAL, COLLECT-FREE,
  and SUBST, to:

        T.

Case 15.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (ARG2 EXP) 0)))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (ARG1 EXP) 0)))
                      (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (EQUAL VAR VAR1))
                      (MEMBER VAR (COLLECT-FREE EXP FLG)))
                 (MEMBER VAR
                         (COLLECT-FREE (SUBST EXP VAR1 TERM FLG)
                                       FLG))),

  which simplifies, rewriting with MEMBER-APPEND and COLLECT-FREE-FLG, and
  opening up the functions ZEROP, VARIABLE, EQUAL, and COLLECT-FREE, to:

        T.

Case 14.(IMPLIES (AND (ZEROP FLG)
                      (NOT (VARIABLE EXP))
                      (NOT (F-NOTP EXP))
                      (F-ORP EXP)
                      (MEMBER VAR
                              (COLLECT-FREE (SUBST (ARG2 EXP) VAR1 TERM 0)
                                            0))
                      (NOT (MEMBER VAR
                                   (COLLECT-FREE (ARG1 EXP) 0)))
                      (NUMBERP VAR)
                      (NUMBERP VAR1)
                      (NOT (EQUAL VAR VAR1))
                      (MEMBER VAR (COLLECT-FREE EXP FLG)))
                 (MEMBER VAR
                         (COLLECT-FREE