(NOTE-LIB "fortran" T)
Loading ./fortran-vcg/fortran.lib
Finished loading ./fortran-vcg/fortran.lib
Loading ./fortran-vcg/fortran.o
Finished loading ./fortran-vcg/fortran.o

(#./fortran-vcg/fortran.lib #./fortran-vcg/fortran)


(ADD-AXIOM FORTRAN NIL T)

[ 0.0 0.0 0.0 ]

FORTRAN


(DCL A$0 NIL)

[ 0.0 0.0 0.0 ]

A$0


(DCL BLK-DELTA1$0 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$0


(DCL BLK-DELTA1$1 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$1


(DCL BLK-DELTA1$2 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$2


(DCL BLK-DELTA1$3 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$3


(DCL BLK-DELTA1$4 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$4


(DCL C$0 NIL)

[ 0.0 0.0 0.0 ]

C$0


(DCL C$1 NIL)

[ 0.0 0.0 0.0 ]

C$1


(DCL C$2 NIL)

[ 0.0 0.0 0.0 ]

C$2


(DCL C$3 NIL)

[ 0.0 0.0 0.0 ]

C$3


(DCL C$4 NIL)

[ 0.0 0.0 0.0 ]

C$4


(DCL I$1 NIL)

[ 0.0 0.0 0.0 ]

I$1


(DCL I$2 NIL)

[ 0.0 0.0 0.0 ]

I$2


(DCL I$3 NIL)

[ 0.0 0.0 0.0 ]

I$3


(DCL I$4 NIL)

[ 0.0 0.0 0.0 ]

I$4


(DCL MAXI$0 NIL)

[ 0.0 0.0 0.0 ]

MAXI$0


(DCL ASIZE& NIL)

[ 0.0 0.0 0.0 ]

ASIZE&


(ADD-AXIOM ASIZE&-NUMBERP
           (REWRITE)
           (NUMBERP (ASIZE&)))

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


[ 0.0 0.0 0.0 ]

ASIZE&-NUMBERP


(DEFN DELTA1
      (A C MAXI)
      (IF (ZEROP MAXI)
          0
          (IF (EQUAL C (ELT1 A MAXI))
              0
              (ADD1 (DELTA1 A C (SUB1 MAXI))))))

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




[ 0.0 0.0 0.0 ]

DELTA1


(DEFN STRINGP
      (A I SIZE)
      (IF (ZEROP I)
          T
          (AND (NUMBERP (ELT1 A I))
               (NOT (EQUAL (ELT1 A I) 0))
               (NOT (LESSP SIZE (ELT1 A I)))
               (STRINGP A (SUB1 I) SIZE))))

     Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP
can be used to establish that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, STRINGP is
accepted under the definitional principle.  Note that:
      (OR (FALSEP (STRINGP A I SIZE))
          (TRUEP (STRINGP A I SIZE)))
is a theorem.




[ 0.0 0.0 0.0 ]

STRINGP


(ADD-AXIOM INPUT-CONDITIONS
           (REWRITE)
           '*1*TRUE)

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


[ 0.0 0.0 0.0 ]

INPUT-CONDITIONS


(DEFN GLOBAL-HYPS NIL
      (AND (NOT (EQUAL (ASIZE&) '0))
           (AND (STRINGP (A$0) (MAXI$0) (ASIZE&))
                (AND (NOT (EQUAL (MAXI$0) '0))
                     (AND (LESSP (ADD1 (ASIZE&))
                                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                          (AND (LESSP (ADD1 (MAXI$0))
                                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                               (NUMBERP (MAXI$0))))))))

     From the definition we can conclude that:
      (OR (FALSEP (GLOBAL-HYPS))
          (TRUEP (GLOBAL-HYPS)))
is a theorem.




[ 0.0 0.0 0.0 ]

GLOBAL-HYPS


(PROVE-LEMMA STRINGP-IS-A-UNIV-QUANTIFIER
             (REWRITE)
             (IMPLIES (AND (STRINGP A I (ASIZE&))
                           (NOT (EQUAL J 0))
                           (NUMBERP J)
                           (NOT (LESSP I J)))
                      (AND (NUMBERP (ELT1 A J))
                           (NOT (LESSP (ASIZE&) (ELT1 A J)))
                           (NOT (EQUAL (ELT1 A J) 0)))))

WARNING:  Note that STRINGP-IS-A-UNIV-QUANTIFIER contains the free variable I
which will be chosen by instantiating the hypothesis (STRINGP A I (ASIZE&)).


WARNING:  When the linear lemma STRINGP-IS-A-UNIV-QUANTIFIER is stored under
(ELT1 A J) it contains the free variable I which will be chosen by
instantiating the hypothesis (STRINGP A I (ASIZE&)).


WARNING:  When the linear lemma STRINGP-IS-A-UNIV-QUANTIFIER is stored under
(ASIZE&) it contains the free variables J, I, and A which will be chosen by
instantiating the hypotheses (STRINGP A I (ASIZE&)) and (NOT (EQUAL J 0)).


WARNING:  Note that STRINGP-IS-A-UNIV-QUANTIFIER contains the free variable I
which will be chosen by instantiating the hypothesis (STRINGP A I (ASIZE&)).


WARNING:  Note that the proposed lemma STRINGP-IS-A-UNIV-QUANTIFIER is to be
stored as zero type prescription rules, zero compound recognizer rules, two
linear rules, and two replacement rules.


This conjecture simplifies, unfolding the functions NOT and AND, to the
following three new formulas:

Case 3. (IMPLIES (AND (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))).

  Name the above subgoal *1.

Case 2. (IMPLIES (AND (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

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


     So now let us consider:

(AND (IMPLIES (AND (STRINGP A I (ASIZE&))
                   (NOT (EQUAL J 0))
                   (NUMBERP J)
                   (NOT (LESSP I J)))
              (NUMBERP (ELT1 A J)))
     (IMPLIES (AND (STRINGP A I (ASIZE&))
                   (NOT (EQUAL J 0))
                   (NUMBERP J)
                   (NOT (LESSP I J)))
              (NOT (LESSP (ASIZE&) (ELT1 A J))))
     (IMPLIES (AND (STRINGP A I (ASIZE&))
                   (NOT (EQUAL J 0))
                   (NUMBERP J)
                   (NOT (LESSP I J)))
              (NOT (EQUAL (ELT1 A J) 0)))).

We gave this the name *1 above.  Perhaps we can prove it by induction.  There
are three plausible inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP I) (p A J I))
           (IMPLIES (AND (NOT (ZEROP I)) (p A J (SUB1 I)))
                    (p A J I))).
Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP can be
used to prove that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces nine new conjectures:

Case 9. (IMPLIES (AND (ZEROP I)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))),

  which simplifies, expanding the definitions of ZEROP, EQUAL, STRINGP, and
  LESSP, to:

        T.

Case 8. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (STRINGP A (SUB1 I) (ASIZE&)))
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))),

  which simplifies, expanding the functions ZEROP and STRINGP, to:

        T.

Case 7. (IMPLIES (AND (NOT (ZEROP I))
                      (LESSP (SUB1 I) J)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))),

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

  Case 7.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) J)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (LESSP I J)))
                   (NUMBERP (ELT1 A J))),

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

          T.

  Case 7.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) I)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL I 0))
                        (NOT (LESSP I I)))
                   (NUMBERP (ELT1 A I))),

    which again simplifies, unfolding the definitions of ZEROP and STRINGP, to:

          T.

Case 6. (IMPLIES (AND (ZEROP I)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

  which simplifies, opening up the definitions of ZEROP, EQUAL, STRINGP, and
  LESSP, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (STRINGP A (SUB1 I) (ASIZE&)))
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

  which simplifies, expanding ZEROP and STRINGP, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP I))
                      (LESSP (SUB1 I) J)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

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

  Case 4.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) J)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (LESSP I J)))
                   (NOT (LESSP (ASIZE&) (ELT1 A J)))),

    which again simplifies, opening up ZEROP, to:

          T.

  Case 4.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) I)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL I 0))
                        (NOT (LESSP I I)))
                   (NOT (LESSP (ASIZE&) (ELT1 A I)))),

    which again simplifies, unfolding the functions ZEROP and STRINGP, to:

          T.

Case 3. (IMPLIES (AND (ZEROP I)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (EQUAL (ELT1 A J) 0))),

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

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (STRINGP A (SUB1 I) (ASIZE&)))
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (EQUAL (ELT1 A J) 0))),

  which simplifies, unfolding the functions ZEROP and STRINGP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (LESSP (SUB1 I) J)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (EQUAL (ELT1 A J) 0))),

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

  Case 1.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) J)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (LESSP I J)))
                   (NOT (EQUAL (ELT1 A J) 0))),

    which again simplifies, opening up ZEROP, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) I)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL I 0))
                        (NOT (LESSP I I)))
                   (NOT (EQUAL (ELT1 A I) 0))),

    which again simplifies, expanding ZEROP, STRINGP, NUMBERP, and EQUAL, to:

          T.


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


[ 0.0 0.1 0.0 ]

STRINGP-IS-A-UNIV-QUANTIFIER


(PROVE-LEMMA INPUT-DEFINEDNESS NIL
             (IMPLIES (GLOBAL-HYPS) '*1*TRUE))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS and
IMPLIES, to:

      T.

This simplifies, obviously, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INPUT-DEFINEDNESS


(ADD-AXIOM INPUT NIL T)

[ 0.0 0.0 0.0 ]

INPUT


(ADD-AXIOM LOGICAL-IF-F NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-F


(ADD-AXIOM ASSIGNMENT
           (REWRITE)
           (AND (EQUAL (I$1) '1)
                (AND (EQUAL (C$1) (C$0))
                     (EQUAL (BLK-DELTA1$1)
                            (BLK-DELTA1$0)))))

WARNING:  Note that the proposed lemma ASSIGNMENT is to be stored as zero type
prescription rules, zero compound recognizer rules, zero linear rules, and
three replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT


(PROVE-LEMMA PASS1-INVRT NIL
       (IMPLIES (GLOBAL-HYPS)
                (AND (AND (NUMBERP (I$1))
                          (AND (NOT (EQUAL (I$1) '0))
                               (AND (NOT (LESSP (ADD1 (ASIZE&)) (I$1)))
                                    (IMPLIES (AND (NUMBERP J)
                                                  (AND (NOT (EQUAL J '0))
                                                       (LESSP J (I$1))))
                                             (EQUAL (ELT1 (BLK-DELTA1$1) J)
                                                    (MAXI$0))))))
                     (LEX (CONS (DIFFERENCE (PLUS '2 (PLUS (ASIZE&) (MAXI$0)))
                                            (I$1))
                                'NIL)
                          (CONS (PLUS '2 (PLUS (ASIZE&) (MAXI$0)))
                                'NIL)))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS, IMPLIES,
and ASSIGNMENT, to:

      (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0)))
               (AND (AND (NUMBERP 1)
                         (NOT (EQUAL 1 0))
                         (NOT (LESSP (ADD1 (ASIZE&)) 1))
                         (IMPLIES (AND (NUMBERP J)
                                       (NOT (EQUAL J 0))
                                       (LESSP J 1))
                                  (EQUAL (ELT1 (BLK-DELTA1$0) J)
                                         (MAXI$0))))
                    (LEX (LIST (DIFFERENCE (PLUS 2 (ASIZE&) (MAXI$0))
                                           1))
                         (LIST (PLUS 2 (ASIZE&) (MAXI$0)))))),

which simplifies, rewriting with SUB1-ADD1, ADD1-EQUAL, and CAR-CONS, and
unfolding the definitions of LESSP, NUMBERP, EQUAL, NOT, SUB1, AND, IMPLIES,
PLUS, DIFFERENCE, and LEX, to the following two new conjectures:

Case 2. (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (LESSP J 1))
                 (EQUAL (ELT1 (BLK-DELTA1$0) J)
                        (MAXI$0))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NOT (EQUAL (PLUS (ASIZE&) (MAXI$0)) 0)))
                 (LESSP (SUB1 (PLUS (ASIZE&) (MAXI$0)))
                        (PLUS (ASIZE&) (MAXI$0)))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PASS1-INVRT


(UBT INPUT)

INPUT


(ADD-AXIOM PATHS-FROM-PASS1-INVRT
           (REWRITE)
           (IMPLIES (AND (NUMBERP J)
                         (AND (NOT (EQUAL J '0))
                              (LESSP J (I$1))))
                    (EQUAL (ELT1 (BLK-DELTA1$1) J)
                           (MAXI$0))))

[ 0.0 0.0 0.0 ]

PATHS-FROM-PASS1-INVRT


(DEFN PATH-HYPS NIL
      (AND (GLOBAL-HYPS)
           (AND (NUMBERP (I$1))
                (AND (NOT (EQUAL (I$1) '0))
                     (NOT (LESSP (ADD1 (ASIZE&)) (I$1)))))))

     From the definition we can conclude that:
      (OR (FALSEP (PATH-HYPS))
          (TRUEP (PATH-HYPS)))
is a theorem.




[ 0.0 0.0 0.0 ]

PATH-HYPS


(PROVE-LEMMA DEFINEDNESS NIL
             (IMPLIES (PATH-HYPS)
                      (ZNUMBERP (I$1))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATH-HYPS, and IMPLIES, to:

      T,

which simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS


(ADD-AXIOM LOGICAL-IF-T NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-T


(ADD-AXIOM EFFECTS-OF-UNDEFINER
           (REWRITE)
           (AND (EQUAL (C$2) (C$1))
                (EQUAL (BLK-DELTA1$2)
                       (BLK-DELTA1$1))))

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


[ 0.0 0.0 0.0 ]

EFFECTS-OF-UNDEFINER


(ADD-AXIOM LOGICAL-IF-F1 NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-F1


(ADD-AXIOM ASSIGNMENT1
           (REWRITE)
           (AND (EQUAL (I$3) '1)
                (AND (EQUAL (C$3) (C$2))
                     (EQUAL (BLK-DELTA1$3)
                            (BLK-DELTA1$2)))))

WARNING:  Note that the proposed lemma ASSIGNMENT1 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and three replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT1


(PROVE-LEMMA PASS2-INVRT NIL
 (IMPLIES
      (AND (I$1)
           (AND (ZGREATERP (I$1) (ASIZE&))
                (PATH-HYPS)))
      (AND (AND (NUMBERP (I$3))
                (AND (NOT (EQUAL (I$3) '0))
                     (AND (NOT (LESSP (ADD1 (MAXI$0)) (I$3)))
                          (IMPLIES (AND (NOT (ZEROP J))
                                        (NOT (LESSP (ASIZE&) J)))
                                   (EQUAL (ELT1 (BLK-DELTA1$3) J)
                                          (PLUS (DELTA1 (A$0) J (SUB1 (I$3)))
                                                (DIFFERENCE (MAXI$0)
                                                            (SUB1 (I$3)))))))))
           (LEX (CONS (DIFFERENCE (ADD1 (MAXI$0)) (I$3))
                      'NIL)
                (CONS (DIFFERENCE (PLUS '2 (PLUS (ASIZE&) (MAXI$0)))
                                  (I$1))
                      'NIL)))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS, PATH-HYPS,
AND, IMPLIES, EFFECTS-OF-UNDEFINER, ASSIGNMENT1, and ZGREATERP, to:

      (IMPLIES
             (AND (I$1)
                  (ZLESSP (ASIZE&) (I$1))
                  (NOT (EQUAL (ASIZE&) 0))
                  (STRINGP (A$0) (MAXI$0) (ASIZE&))
                  (NOT (EQUAL (MAXI$0) 0))
                  (LESSP (ADD1 (ASIZE&))
                         (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                  (LESSP (ADD1 (MAXI$0))
                         (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                  (NUMBERP (MAXI$0))
                  (NUMBERP (I$1))
                  (NOT (EQUAL (I$1) 0))
                  (NOT (LESSP (ADD1 (ASIZE&)) (I$1))))
             (AND (AND (NUMBERP 1)
                       (NOT (EQUAL 1 0))
                       (NOT (LESSP (ADD1 (MAXI$0)) 1))
                       (IMPLIES (AND (NOT (ZEROP J))
                                     (NOT (LESSP (ASIZE&) J)))
                                (EQUAL (ELT1 (BLK-DELTA1$1) J)
                                       (PLUS (DELTA1 (A$0) J (SUB1 1))
                                             (DIFFERENCE (MAXI$0) (SUB1 1))))))
                  (LEX (LIST (DIFFERENCE (ADD1 (MAXI$0)) 1))
                       (LIST (DIFFERENCE (PLUS 2 (ASIZE&) (MAXI$0))
                                         (I$1)))))),

which simplifies, appealing to the lemmas SUB1-ADD1, CDR-CONS, and CAR-CONS,
and expanding ZLESSP, LESSP, NUMBERP, EQUAL, NOT, SUB1, ZEROP, AND, DELTA1,
DIFFERENCE, PLUS, IMPLIES, and LEX, to three new formulas:

Case 3. (IMPLIES (AND (LESSP (ASIZE&) (I$1))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) (SUB1 (I$1))))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (ASIZE&) J)))
                 (EQUAL (ELT1 (BLK-DELTA1$1) J)
                        (MAXI$0))),

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

        (IMPLIES (AND (EQUAL (I$1) (PLUS 1 (ASIZE&)))
                      (LESSP (ASIZE&) (PLUS 1 (ASIZE&)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (PLUS 1 (ASIZE&)))
                      (NOT (EQUAL (PLUS 1 (ASIZE&)) 0))
                      (NOT (LESSP (ASIZE&)
                                  (SUB1 (PLUS 1 (ASIZE&)))))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (ASIZE&) J)))
                 (EQUAL (ELT1 (BLK-DELTA1$1) J)
                        (MAXI$0))).

  But this again simplifies, using linear arithmetic, applying the lemma
  PATHS-FROM-PASS1-INVRT, and opening up the definitions of SUB1, NUMBERP,
  EQUAL, and PLUS, to:

        T.

Case 2. (IMPLIES (AND (LESSP (ASIZE&) (I$1))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) (SUB1 (I$1))))
                      (NOT (EQUAL (SUB1 (I$1)) 0)))
                 (LESSP (MAXI$0)
                        (DIFFERENCE (PLUS (ASIZE&) (MAXI$0))
                                    (SUB1 (SUB1 (I$1)))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (LESSP (ASIZE&) (I$1))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) (SUB1 (I$1))))
                      (EQUAL (SUB1 (I$1)) 0))
                 (LESSP (MAXI$0)
                        (ADD1 (PLUS (ASIZE&) (MAXI$0))))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PASS2-INVRT


(UBT LOGICAL-IF-T)

LOGICAL-IF-T


(ADD-AXIOM LOGICAL-IF-F1 NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-F1


(PROVE-LEMMA ARRAY-BOUNDS-CHECK-FOR-DELTA1 NIL
             (IMPLIES (AND (NOT (ZGREATERP (I$1) (ASIZE&)))
                           (PATH-HYPS))
                      (AND (LESSP '0 (I$1))
                           (NOT (LESSP (ASIZE&) (I$1))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, NOT, AND, IMPLIES, and ZGREATERP, to the formula:

      (IMPLIES (AND (NOT (ZLESSP (ASIZE&) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (ASIZE&)) (I$1))))
               (AND (LESSP 0 (I$1))
                    (NOT (LESSP (ASIZE&) (I$1))))).

This simplifies, rewriting with SUB1-ADD1, and expanding the functions ZLESSP,
LESSP, EQUAL, NOT, and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ARRAY-BOUNDS-CHECK-FOR-DELTA1


(ADD-AXIOM ASSIGNMENT1
           (REWRITE)
           (AND (EQUAL (I$2) (I$1))
                (AND (EQUAL (C$2) (C$1))
                     (EQUAL (ELT1 (BLK-DELTA1$2) I)
                            (IF (EQUAL I (I$1))
                                (MAXI$0)
                                (ELT1 (BLK-DELTA1$1) I))))))

WARNING:  Note that the proposed lemma ASSIGNMENT1 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and three replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT1


(PROVE-LEMMA INPUT-COND-OF-ZPLUS NIL
             (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                          (BLK-DELTA1$2)
                                          '1
                                          (ASIZE&)
                                          (I$1)
                                          (MAXI$0))
                           (AND (NOT (ZGREATERP (I$1) (ASIZE&)))
                                (PATH-HYPS)))
                      (EXPRESSIBLE-ZNUMBERP (ZPLUS (I$2) '1))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS, PATH-HYPS,
NOT, AND, IMPLIES, ASSIGNMENT1, and ZGREATERP, to:

      (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                   (BLK-DELTA1$2)
                                   1
                                   (ASIZE&)
                                   (I$1)
                                   (MAXI$0))
                    (NOT (ZLESSP (ASIZE&) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (ASIZE&)) (I$1))))
               (EXPRESSIBLE-ZNUMBERP (ZPLUS (I$1) 1))),

which simplifies, applying SUB1-ADD1 and COMMUTATIVITY-OF-PLUS, and unfolding
the functions ZLESSP, LESSP, PLUS, EQUAL, NUMBERP, SUB1, NEGATIVEP, ZPLUS, and
EXPRESSIBLE-ZNUMBERP, to the new formula:

      (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                   (BLK-DELTA1$2)
                                   1
                                   (ASIZE&)
                                   (I$1)
                                   (MAXI$0))
                    (NOT (LESSP (ASIZE&) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ASIZE&) (SUB1 (I$1)))))
               (LESSP (I$1)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))),

which again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INPUT-COND-OF-ZPLUS


(ADD-AXIOM ASSIGNMENT2
           (REWRITE)
           (AND (EQUAL (I$3) (ZPLUS (I$2) '1))
                (AND (EQUAL (C$3) (C$2))
                     (EQUAL (BLK-DELTA1$3)
                            (BLK-DELTA1$2)))))

WARNING:  Note that the proposed lemma ASSIGNMENT2 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and three replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT2


(PROVE-LEMMA PASS1-INVRT1 NIL
       (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                    (BLK-DELTA1$2)
                                    '1
                                    (ASIZE&)
                                    (I$1)
                                    (MAXI$0))
                     (AND (NOT (ZGREATERP (I$1) (ASIZE&)))
                          (PATH-HYPS)))
                (AND (AND (NUMBERP (I$3))
                          (AND (NOT (EQUAL (I$3) '0))
                               (AND (NOT (LESSP (ADD1 (ASIZE&)) (I$3)))
                                    (IMPLIES (AND (NUMBERP J)
                                                  (AND (NOT (EQUAL J '0))
                                                       (LESSP J (I$3))))
                                             (EQUAL (ELT1 (BLK-DELTA1$3) J)
                                                    (MAXI$0))))))
                     (LEX (CONS (DIFFERENCE (PLUS '2 (PLUS (ASIZE&) (MAXI$0)))
                                            (I$3))
                                'NIL)
                          (CONS (DIFFERENCE (PLUS '2 (PLUS (ASIZE&) (MAXI$0)))
                                            (I$1))
                                'NIL)))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, NOT, AND, IMPLIES, ASSIGNMENT1, ASSIGNMENT2, and ZGREATERP, to the
formula:

      (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                   (BLK-DELTA1$2)
                                   1
                                   (ASIZE&)
                                   (I$1)
                                   (MAXI$0))
                    (NOT (ZLESSP (ASIZE&) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (ASIZE&)) (I$1))))
               (AND (AND (NUMBERP (ZPLUS (I$1) 1))
                         (NOT (EQUAL (ZPLUS (I$1) 1) 0))
                         (NOT (LESSP (ADD1 (ASIZE&))
                                     (ZPLUS (I$1) 1)))
                         (IMPLIES (AND (NUMBERP J)
                                       (NOT (EQUAL J 0))
                                       (LESSP J (ZPLUS (I$1) 1)))
                                  (EQUAL (ELT1 (BLK-DELTA1$2) J)
                                         (MAXI$0))))
                    (LEX (LIST (DIFFERENCE (PLUS 2 (ASIZE&) (MAXI$0))
                                           (ZPLUS (I$1) 1)))
                         (LIST (DIFFERENCE (PLUS 2 (ASIZE&) (MAXI$0))
                                           (I$1)))))).

This simplifies, applying SUB1-ADD1, COMMUTATIVITY-OF-PLUS, ASSIGNMENT1,
CDR-CONS, and CAR-CONS, and unfolding the functions ZLESSP, LESSP, PLUS, EQUAL,
NUMBERP, SUB1, NEGATIVEP, ZPLUS, NOT, AND, IMPLIES, DIFFERENCE, and LEX, to
three new conjectures:

Case 3. (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$2)
                                     1
                                     (ASIZE&)
                                     (I$1)
                                     (MAXI$0))
                      (NOT (LESSP (ASIZE&) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) (SUB1 (I$1))))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (LESSP (SUB1 J) (I$1))
                      (NOT (EQUAL J (I$1))))
                 (EQUAL (ELT1 (BLK-DELTA1$1) J)
                        (MAXI$0))),

  which again simplifies, using linear arithmetic and applying
  PATHS-FROM-PASS1-INVRT, to:

        T.

Case 2. (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$2)
                                     1
                                     (ASIZE&)
                                     (I$1)
                                     (MAXI$0))
                      (NOT (LESSP (ASIZE&) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) (SUB1 (I$1))))
                      (NOT (EQUAL (SUB1 (I$1)) 0)))
                 (LESSP (DIFFERENCE (PLUS (ASIZE&) (MAXI$0))
                                    (SUB1 (I$1)))
                        (DIFFERENCE (PLUS (ASIZE&) (MAXI$0))
                                    (SUB1 (SUB1 (I$1)))))).

  This again simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP (PLUS (ASIZE&) (MAXI$0))
                             (SUB1 (I$1)))
                      (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$2)
                                     1
                                     (ASIZE&)
                                     (I$1)
                                     (MAXI$0))
                      (NOT (LESSP (ASIZE&) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) (SUB1 (I$1))))
                      (NOT (EQUAL (SUB1 (I$1)) 0)))
                 (LESSP (DIFFERENCE (PLUS (ASIZE&) (MAXI$0))
                                    (SUB1 (I$1)))
                        (DIFFERENCE (PLUS (ASIZE&) (MAXI$0))
                                    (SUB1 (SUB1 (I$1)))))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$2)
                                     1
                                     (ASIZE&)
                                     (I$1)
                                     (MAXI$0))
                      (NOT (LESSP (ASIZE&) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) (SUB1 (I$1))))
                      (EQUAL (SUB1 (I$1)) 0))
                 (LESSP (DIFFERENCE (PLUS (ASIZE&) (MAXI$0))
                                    (SUB1 (I$1)))
                        (ADD1 (PLUS (ASIZE&) (MAXI$0))))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP (PLUS (ASIZE&) (MAXI$0)) 0)
                      (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$2)
                                     1
                                     (ASIZE&)
                                     (I$1)
                                     (MAXI$0))
                      (NOT (LESSP (ASIZE&) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (ASIZE&) 0))
                      (EQUAL (SUB1 (I$1)) 0))
                 (LESSP (DIFFERENCE (PLUS (ASIZE&) (MAXI$0))
                                    0)
                        (ADD1 (PLUS (ASIZE&) (MAXI$0))))).

  But this again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

PASS1-INVRT1


(UBT PATHS-FROM-PASS1-INVRT)

PATHS-FROM-PASS1-INVRT


(ADD-AXIOM PATHS-FROM-PASS2-INVRT
           (REWRITE)
           (IMPLIES (AND (NOT (ZEROP J))
                         (NOT (LESSP (ASIZE&) J)))
                    (EQUAL (ELT1 (BLK-DELTA1$1) J)
                           (PLUS (DELTA1 (A$0) J (SUB1 (I$1)))
                                 (DIFFERENCE (MAXI$0) (SUB1 (I$1)))))))

[ 0.0 0.0 0.0 ]

PATHS-FROM-PASS2-INVRT


(DEFN PATH-HYPS NIL
      (AND (GLOBAL-HYPS)
           (AND (NUMBERP (I$1))
                (AND (NOT (EQUAL (I$1) '0))
                     (NOT (LESSP (ADD1 (MAXI$0)) (I$1)))))))

     From the definition we can conclude that:
      (OR (FALSEP (PATH-HYPS))
          (TRUEP (PATH-HYPS)))
is a theorem.




[ 0.0 0.0 0.0 ]

PATH-HYPS


(PROVE-LEMMA DEFINEDNESS NIL
             (IMPLIES (PATH-HYPS)
                      (ZNUMBERP (I$1))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATH-HYPS, and IMPLIES, to:

      T,

which simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS


(ADD-AXIOM LOGICAL-IF-T NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-T


(ADD-AXIOM EFFECTS-OF-UNDEFINER
           (REWRITE)
           (AND (EQUAL (C$2) (C$1))
                (EQUAL (BLK-DELTA1$2)
                       (BLK-DELTA1$1))))

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


[ 0.0 0.0 0.0 ]

EFFECTS-OF-UNDEFINER


(PROVE-LEMMA OUTPUT NIL
             (IMPLIES (AND (I$1)
                           (AND (ZGREATERP (I$1) (MAXI$0))
                                (PATH-HYPS)))
                      (IMPLIES (AND (NUMBERP C)
                                    (AND (NOT (EQUAL C '0))
                                         (NOT (LESSP (ASIZE&) C))))
                               (EQUAL (ELT1 (BLK-DELTA1$2) C)
                                      (DELTA1 (A$0) C (MAXI$0))))))

This formula can be simplified, using the abbreviations NOT, GLOBAL-HYPS,
PATH-HYPS, AND, IMPLIES, EFFECTS-OF-UNDEFINER, and ZGREATERP, to:

      (IMPLIES (AND (I$1)
                    (ZLESSP (MAXI$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (MAXI$0)) (I$1)))
                    (NUMBERP C)
                    (NOT (EQUAL C 0))
                    (NOT (LESSP (ASIZE&) C)))
               (EQUAL (ELT1 (BLK-DELTA1$1) C)
                      (DELTA1 (A$0) C (MAXI$0)))),

which simplifies, applying the lemmas SUB1-ADD1, COMMUTATIVITY-OF-PLUS, and
PATHS-FROM-PASS2-INVRT, and opening up the definitions of ZLESSP and LESSP, to
the goal:

      (IMPLIES (AND (LESSP (MAXI$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                    (NUMBERP C)
                    (NOT (EQUAL C 0))
                    (NOT (LESSP (ASIZE&) C)))
               (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                            (DELTA1 (A$0) C (SUB1 (I$1))))
                      (DELTA1 (A$0) C (MAXI$0)))).

This again simplifies, using linear arithmetic, to:

      (IMPLIES (AND (EQUAL (I$1) (PLUS 1 (MAXI$0)))
                    (LESSP (MAXI$0) (PLUS 1 (MAXI$0)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (PLUS 1 (MAXI$0)))
                    (NOT (EQUAL (PLUS 1 (MAXI$0)) 0))
                    (NOT (LESSP (MAXI$0)
                                (SUB1 (PLUS 1 (MAXI$0)))))
                    (NUMBERP C)
                    (NOT (EQUAL C 0))
                    (NOT (LESSP (ASIZE&) C)))
               (EQUAL (PLUS (DIFFERENCE (MAXI$0)
                                        (SUB1 (PLUS 1 (MAXI$0))))
                            (DELTA1 (A$0)
                                    C
                                    (SUB1 (PLUS 1 (MAXI$0)))))
                      (DELTA1 (A$0) C (MAXI$0)))).

However this again simplifies, opening up SUB1, NUMBERP, EQUAL, and PLUS, to
the conjecture:

      (IMPLIES (AND (EQUAL (I$1) (ADD1 (MAXI$0)))
                    (LESSP (MAXI$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                    (NUMBERP C)
                    (NOT (EQUAL C 0))
                    (NOT (LESSP (ASIZE&) C)))
               (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                            (DELTA1 (A$0) C (SUB1 (I$1))))
                      (DELTA1 (A$0) C (MAXI$0)))).

We now use the above equality hypothesis by substituting (ADD1 (MAXI$0)) for
(I$1) and keeping the equality hypothesis.  This produces:

      (IMPLIES (AND (EQUAL (I$1) (ADD1 (MAXI$0)))
                    (LESSP (MAXI$0) (ADD1 (MAXI$0)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NOT (EQUAL (ADD1 (MAXI$0)) 0))
                    (NOT (LESSP (MAXI$0)
                                (SUB1 (ADD1 (MAXI$0)))))
                    (NUMBERP C)
                    (NOT (EQUAL C 0))
                    (NOT (LESSP (ASIZE&) C)))
               (EQUAL (PLUS (DIFFERENCE (MAXI$0)
                                        (SUB1 (ADD1 (MAXI$0))))
                            (DELTA1 (A$0)
                                    C
                                    (SUB1 (ADD1 (MAXI$0)))))
                      (DELTA1 (A$0) C (MAXI$0)))),

which further simplifies, obviously, to the new goal:

      (IMPLIES (AND (EQUAL (I$1) (ADD1 (MAXI$0)))
                    (LESSP (MAXI$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                    (NUMBERP C)
                    (NOT (EQUAL C 0))
                    (NOT (LESSP (ASIZE&) C)))
               (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                            (DELTA1 (A$0) C (SUB1 (I$1))))
                      (DELTA1 (A$0) C (MAXI$0)))),

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 (I$1)
              (ZGREATERP (I$1) (MAXI$0))
              (PATH-HYPS)
              (NUMBERP C)
              (NOT (EQUAL C 0))
              (NOT (LESSP (ASIZE&) C)))
         (EQUAL (ELT1 (BLK-DELTA1$2) C)
                (DELTA1 (A$0) C (MAXI$0)))).

We named this *1.  We will try to prove it by induction.  There is only one
suggested induction.  We will induct according to the following scheme:
      (AND (IMPLIES (OR (EQUAL C 0) (NOT (NUMBERP C)))
                    (p C))
           (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                         (OR (EQUAL (ASIZE&) 0)
                             (NOT (NUMBERP (ASIZE&)))))
                    (p C))
           (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                         (NOT (OR (EQUAL (ASIZE&) 0)
                                  (NOT (NUMBERP (ASIZE&)))))
                         (p (SUB1 C)))
                    (p C))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT inform us that the measure (COUNT C) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces five new conjectures:

Case 5. (IMPLIES (AND (OR (EQUAL C 0) (NOT (NUMBERP C)))
                      (I$1)
                      (ZGREATERP (I$1) (MAXI$0))
                      (PATH-HYPS)
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$2) C)
                        (DELTA1 (A$0) C (MAXI$0)))),

  which simplifies, expanding the definitions of NOT and OR, to:

        T.

Case 4. (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (OR (EQUAL (ASIZE&) 0)
                          (NOT (NUMBERP (ASIZE&))))
                      (I$1)
                      (ZGREATERP (I$1) (MAXI$0))
                      (PATH-HYPS)
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$2) C)
                        (DELTA1 (A$0) C (MAXI$0)))),

  which simplifies, unfolding the definitions of NOT, OR, ZLESSP, ZGREATERP,
  GLOBAL-HYPS, EQUAL, and PATH-HYPS, to:

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (NOT (OR (EQUAL (ASIZE&) 0)
                               (NOT (NUMBERP (ASIZE&)))))
                      (EQUAL (SUB1 C) 0)
                      (I$1)
                      (ZGREATERP (I$1) (MAXI$0))
                      (PATH-HYPS)
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$2) C)
                        (DELTA1 (A$0) C (MAXI$0)))),

  which simplifies, applying SUB1-ADD1, EFFECTS-OF-UNDEFINER,
  COMMUTATIVITY-OF-PLUS, PATHS-FROM-PASS2-INVRT, and SUB1-TYPE-RESTRICTION,
  and opening up the functions NOT, OR, ZLESSP, ZGREATERP, GLOBAL-HYPS, LESSP,
  PATH-HYPS, EQUAL, and STRINGP, to:

        (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (SUB1 C) 0)
                      (I$1)
                      (NOT (NEGATIVEP (MAXI$0)))
                      (NOT (NEGATIVEP (I$1)))
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NUMBERP C)
                      (NOT (EQUAL C 0)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) C (SUB1 (I$1))))
                        (DELTA1 (A$0) C (MAXI$0)))),

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

        (IMPLIES (AND (EQUAL (I$1) (PLUS 1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (SUB1 C) 0)
                      (PLUS 1 (MAXI$0))
                      (NOT (NEGATIVEP (MAXI$0)))
                      (NOT (NEGATIVEP (PLUS 1 (MAXI$0))))
                      (LESSP (MAXI$0) (PLUS 1 (MAXI$0)))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (PLUS 1 (MAXI$0)))
                      (NOT (EQUAL (PLUS 1 (MAXI$0)) 0))
                      (NOT (LESSP (MAXI$0)
                                  (SUB1 (PLUS 1 (MAXI$0)))))
                      (NUMBERP C)
                      (NOT (EQUAL C 0)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0)
                                          (SUB1 (PLUS 1 (MAXI$0))))
                              (DELTA1 (A$0)
                                      C
                                      (SUB1 (PLUS 1 (MAXI$0)))))
                        (DELTA1 (A$0) C (MAXI$0)))).

  However this again simplifies, expanding the definitions of SUB1, NUMBERP,
  EQUAL, and PLUS, to:

        (IMPLIES (AND (EQUAL (I$1) (ADD1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (SUB1 C) 0)
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NUMBERP C)
                      (NOT (EQUAL C 0)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) C (SUB1 (I$1))))
                        (DELTA1 (A$0) C (MAXI$0)))).

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

        (IMPLIES (AND (NUMBERP X)
                      (EQUAL (I$1) (ADD1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL X 0)
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NOT (EQUAL (ADD1 X) 0)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) (ADD1 X) (SUB1 (I$1))))
                        (DELTA1 (A$0) (ADD1 X) (MAXI$0)))).

  This further simplifies, expanding the definitions of NUMBERP and EQUAL, to
  the goal:

        (IMPLIES (AND (EQUAL (I$1) (ADD1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1)))))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) 1 (SUB1 (I$1))))
                        (DELTA1 (A$0) 1 (MAXI$0)))).

  We now use the above equality hypothesis by substituting (ADD1 (MAXI$0)) for
  (I$1) and throwing away the equality.  This produces:

        (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (LESSP (MAXI$0) (ADD1 (MAXI$0)))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (ADD1 (MAXI$0)) 0))
                      (NOT (LESSP (MAXI$0)
                                  (SUB1 (ADD1 (MAXI$0))))))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0)
                                          (SUB1 (ADD1 (MAXI$0))))
                              (DELTA1 (A$0)
                                      1
                                      (SUB1 (ADD1 (MAXI$0)))))
                        (DELTA1 (A$0) 1 (MAXI$0)))),

  which further simplifies, applying SUB1-ADD1, and unfolding the definition
  of LESSP, to:

        (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (LESSP (SUB1 (MAXI$0)) (MAXI$0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (LESSP (MAXI$0) (MAXI$0))))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (MAXI$0))
                              (DELTA1 (A$0) 1 (MAXI$0)))
                        (DELTA1 (A$0) 1 (MAXI$0)))),

  which finally simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (NOT (OR (EQUAL (ASIZE&) 0)
                               (NOT (NUMBERP (ASIZE&)))))
                      (LESSP (ASIZE&) (SUB1 C))
                      (I$1)
                      (ZGREATERP (I$1) (MAXI$0))
                      (PATH-HYPS)
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$2) C)
                        (DELTA1 (A$0) C (MAXI$0)))),

  which simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (OR (EQUAL C 0) (NOT (NUMBERP C))))
                      (NOT (OR (EQUAL (ASIZE&) 0)
                               (NOT (NUMBERP (ASIZE&)))))
                      (EQUAL (ELT1 (BLK-DELTA1$2) (SUB1 C))
                             (DELTA1 (A$0) (SUB1 C) (MAXI$0)))
                      (I$1)
                      (ZGREATERP (I$1) (MAXI$0))
                      (PATH-HYPS)
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$2) C)
                        (DELTA1 (A$0) C (MAXI$0)))),

  which simplifies, using linear arithmetic, rewriting with
  EFFECTS-OF-UNDEFINER, SUB1-ADD1, COMMUTATIVITY-OF-PLUS,
  PATHS-FROM-PASS2-INVRT, and SUB1-TYPE-RESTRICTION, and opening up the
  definitions of NOT, OR, ZLESSP, ZGREATERP, GLOBAL-HYPS, LESSP, PATH-HYPS,
  and STRINGP, to:

        (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (ELT1 (BLK-DELTA1$1) (SUB1 C))
                             (DELTA1 (A$0) (SUB1 C) (MAXI$0)))
                      (I$1)
                      (NOT (NEGATIVEP (MAXI$0)))
                      (NOT (NEGATIVEP (I$1)))
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (SUB1 (ASIZE&)) (SUB1 C))))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) C (SUB1 (I$1))))
                        (DELTA1 (A$0) C (MAXI$0)))),

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

        (IMPLIES (AND (EQUAL (I$1) (PLUS 1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (ELT1 (BLK-DELTA1$1) (SUB1 C))
                             (DELTA1 (A$0) (SUB1 C) (MAXI$0)))
                      (PLUS 1 (MAXI$0))
                      (NOT (NEGATIVEP (MAXI$0)))
                      (NOT (NEGATIVEP (PLUS 1 (MAXI$0))))
                      (LESSP (MAXI$0) (PLUS 1 (MAXI$0)))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (PLUS 1 (MAXI$0)))
                      (NOT (EQUAL (PLUS 1 (MAXI$0)) 0))
                      (NOT (LESSP (MAXI$0)
                                  (SUB1 (PLUS 1 (MAXI$0)))))
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (SUB1 (ASIZE&)) (SUB1 C))))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0)
                                          (SUB1 (PLUS 1 (MAXI$0))))
                              (DELTA1 (A$0)
                                      C
                                      (SUB1 (PLUS 1 (MAXI$0)))))
                        (DELTA1 (A$0) C (MAXI$0)))).

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

        (IMPLIES (AND (EQUAL (I$1) (ADD1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (ELT1 (BLK-DELTA1$1) (SUB1 C))
                             (DELTA1 (A$0) (SUB1 C) (MAXI$0)))
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (SUB1 (ASIZE&)) (SUB1 C))))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) C (SUB1 (I$1))))
                        (DELTA1 (A$0) C (MAXI$0)))).

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

        (IMPLIES (AND (NUMBERP X)
                      (EQUAL (I$1) (ADD1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (ELT1 (BLK-DELTA1$1) X)
                             (DELTA1 (A$0) X (MAXI$0)))
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NOT (EQUAL (ADD1 X) 0))
                      (NOT (LESSP (SUB1 (ASIZE&)) X)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) (ADD1 X) (SUB1 (I$1))))
                        (DELTA1 (A$0) (ADD1 X) (MAXI$0)))).

  This further simplifies, obviously, to the new conjecture:

        (IMPLIES (AND (NUMBERP X)
                      (EQUAL (I$1) (ADD1 (MAXI$0)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (ELT1 (BLK-DELTA1$1) X)
                             (DELTA1 (A$0) X (MAXI$0)))
                      (LESSP (MAXI$0) (I$1))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NOT (LESSP (SUB1 (ASIZE&)) X)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) (ADD1 X) (SUB1 (I$1))))
                        (DELTA1 (A$0) (ADD1 X) (MAXI$0)))).

  We use the first equality hypothesis by substituting (ADD1 (MAXI$0)) for
  (I$1) and throwing away the equality.  We must thus prove:

        (IMPLIES (AND (NUMBERP X)
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (ELT1 (BLK-DELTA1$1) X)
                             (DELTA1 (A$0) X (MAXI$0)))
                      (LESSP (MAXI$0) (ADD1 (MAXI$0)))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (EQUAL (ADD1 (MAXI$0)) 0))
                      (NOT (LESSP (MAXI$0)
                                  (SUB1 (ADD1 (MAXI$0)))))
                      (NOT (LESSP (SUB1 (ASIZE&)) X)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0)
                                          (SUB1 (ADD1 (MAXI$0))))
                              (DELTA1 (A$0)
                                      (ADD1 X)
                                      (SUB1 (ADD1 (MAXI$0)))))
                        (DELTA1 (A$0) (ADD1 X) (MAXI$0)))).

  This further simplifies, appealing to the lemma SUB1-ADD1, and unfolding the
  definition of LESSP, to the goal:

        (IMPLIES (AND (NUMBERP X)
                      (NOT (EQUAL (ASIZE&) 0))
                      (EQUAL (ELT1 (BLK-DELTA1$1) X)
                             (DELTA1 (A$0) X (MAXI$0)))
                      (LESSP (SUB1 (MAXI$0)) (MAXI$0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NOT (LESSP (MAXI$0) (MAXI$0)))
                      (NOT (LESSP (SUB1 (ASIZE&)) X)))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (MAXI$0))
                              (DELTA1 (A$0) (ADD1 X) (MAXI$0)))
                        (DELTA1 (A$0) (ADD1 X) (MAXI$0)))).

  This finally simplifies, using linear arithmetic, to:

        T.


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


[ 0.0 0.2 0.0 ]

OUTPUT


(UBT LOGICAL-IF-T)

LOGICAL-IF-T


(ADD-AXIOM LOGICAL-IF-F1 NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-F1


(PROVE-LEMMA ARRAY-BOUNDS-CHECK-FOR-A NIL
             (IMPLIES (AND (NOT (ZGREATERP (I$1) (MAXI$0)))
                           (PATH-HYPS))
                      (AND (LESSP '0 (I$1))
                           (NOT (LESSP (MAXI$0) (I$1))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, NOT, AND, IMPLIES, and ZGREATERP, to the formula:

      (IMPLIES (AND (NOT (ZLESSP (MAXI$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (MAXI$0)) (I$1))))
               (AND (LESSP 0 (I$1))
                    (NOT (LESSP (MAXI$0) (I$1))))).

This simplifies, rewriting with SUB1-ADD1, and expanding the functions ZLESSP,
LESSP, EQUAL, NOT, and AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ARRAY-BOUNDS-CHECK-FOR-A


(PROVE-LEMMA DEFINEDNESS1 NIL
             (IMPLIES (AND (NOT (ZGREATERP (I$1) (MAXI$0)))
                           (PATH-HYPS))
                      (ZNUMBERP (ELT1 (A$0) (I$1)))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATH-HYPS, NOT, AND, IMPLIES, and ZGREATERP, to:

      (IMPLIES (AND (NOT (ZLESSP (MAXI$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (MAXI$0)) (I$1)))
                    (NOT (NEGATIVEP (ELT1 (A$0) (I$1)))))
               (NUMBERP (ELT1 (A$0) (I$1)))),

which simplifies, rewriting with SUB1-ADD1 and STRINGP-IS-A-UNIV-QUANTIFIER,
and expanding the functions ZLESSP and LESSP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS1


(ADD-AXIOM ASSIGNMENT1
           (REWRITE)
           (AND (EQUAL (I$2) (I$1))
                (AND (EQUAL (C$2) (ELT1 (A$0) (I$1)))
                     (EQUAL (BLK-DELTA1$2)
                            (BLK-DELTA1$1)))))

WARNING:  Note that the proposed lemma ASSIGNMENT1 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and three replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT1


(PROVE-LEMMA INPUT-COND-OF-ZDIFFERENCE NIL
             (IMPLIES (AND (NOT (ZGREATERP (I$1) (MAXI$0)))
                           (PATH-HYPS))
                      (EXPRESSIBLE-ZNUMBERP (ZDIFFERENCE (MAXI$0) (I$2)))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS, PATH-HYPS,
NOT, AND, IMPLIES, ASSIGNMENT1, and ZGREATERP, to:

      (IMPLIES (AND (NOT (ZLESSP (MAXI$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (MAXI$0)) (I$1))))
               (EXPRESSIBLE-ZNUMBERP (ZDIFFERENCE (MAXI$0) (I$1)))),

which simplifies, rewriting with SUB1-ADD1, and expanding the functions ZLESSP,
LESSP, ZDIFFERENCE, and EXPRESSIBLE-ZNUMBERP, to the following two new goals:

Case 2. (IMPLIES
          (AND (NOT (LESSP (MAXI$0) (I$1)))
               (NOT (EQUAL (ASIZE&) 0))
               (STRINGP (A$0) (MAXI$0) (ASIZE&))
               (NOT (EQUAL (MAXI$0) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (LESSP (MAXI$0)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (NUMBERP (MAXI$0))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
               (EQUAL (NEGATIVE-GUTS (GREATEST-INEXPRESSIBLE-NEGATIVE-INTEGER))
                      0))
          (NOT (EQUAL (DIFFERENCE (MAXI$0) (I$1))
                      0))).

  This again simplifies, using linear arithmetic and applying the lemma
  INTEGER-SIZE, to:

        T.

Case 1. (IMPLIES (AND (NOT (LESSP (MAXI$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1)))))
                 (LESSP (DIFFERENCE (MAXI$0) (I$1))
                        (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INPUT-COND-OF-ZDIFFERENCE


(PROVE-LEMMA ARRAY-BOUNDS-CHECK-FOR-DELTA1 NIL
             (IMPLIES (AND (NOT (ZGREATERP (I$1) (MAXI$0)))
                           (PATH-HYPS))
                      (AND (LESSP '0 (C$2))
                           (NOT (LESSP (ASIZE&) (C$2))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, NOT, AND, IMPLIES, ASSIGNMENT1, and ZGREATERP, to the formula:

      (IMPLIES (AND (NOT (ZLESSP (MAXI$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (MAXI$0)) (I$1))))
               (AND (LESSP 0 (ELT1 (A$0) (I$1)))
                    (NOT (LESSP (ASIZE&)
                                (ELT1 (A$0) (I$1)))))).

This simplifies, rewriting with SUB1-ADD1 and STRINGP-IS-A-UNIV-QUANTIFIER,
and expanding the functions ZLESSP, LESSP, EQUAL, NOT, and AND, to:

      (IMPLIES (AND (NOT (LESSP (MAXI$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (MAXI$0) (SUB1 (I$1)))))
               (NOT (LESSP (ASIZE&) (ELT1 (A$0) (I$1))))).

But this again simplifies, using linear arithmetic and rewriting with
STRINGP-IS-A-UNIV-QUANTIFIER, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ARRAY-BOUNDS-CHECK-FOR-DELTA1


(ADD-AXIOM ASSIGNMENT2
           (REWRITE)
           (AND (EQUAL (I$3) (I$2))
                (AND (EQUAL (C$3) (C$2))
                     (EQUAL (ELT1 (BLK-DELTA1$3) I)
                            (IF (EQUAL I (C$2))
                                (ZDIFFERENCE (MAXI$0) (I$2))
                                (ELT1 (BLK-DELTA1$2) I))))))

WARNING:  Note that the proposed lemma ASSIGNMENT2 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and three replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT2


(PROVE-LEMMA INPUT-COND-OF-ZPLUS NIL
             (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$2)
                                          (BLK-DELTA1$3)
                                          '1
                                          (ASIZE&)
                                          (C$2)
                                          (ZDIFFERENCE (MAXI$0) (I$2)))
                           (AND (NOT (ZGREATERP (I$1) (MAXI$0)))
                                (PATH-HYPS)))
                      (EXPRESSIBLE-ZNUMBERP (ZPLUS (I$3) '1))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS, PATH-HYPS,
NOT, AND, IMPLIES, ASSIGNMENT2, ZGREATERP, and ASSIGNMENT1, to the new
conjecture:

      (IMPLIES (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                   (BLK-DELTA1$3)
                                   1
                                   (ASIZE&)
                                   (ELT1 (A$0) (I$1))
                                   (ZDIFFERENCE (MAXI$0) (I$1)))
                    (NOT (ZLESSP (MAXI$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (MAXI$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (ADD1 (MAXI$0)) (I$1))))
               (EXPRESSIBLE-ZNUMBERP (ZPLUS (I$1) 1))),

which simplifies, applying SUB1-ADD1 and COMMUTATIVITY-OF-PLUS, and unfolding
the definitions of ZDIFFERENCE, ZLESSP, LESSP, PLUS, EQUAL, NUMBERP, SUB1,
NEGATIVEP, ZPLUS, and EXPRESSIBLE-ZNUMBERP, to:

      (IMPLIES (AND (NOT (LESSP (MAXI$0) (I$1)))
                    (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                   (BLK-DELTA1$3)
                                   1
                                   (ASIZE&)
                                   (ELT1 (A$0) (I$1))
                                   (DIFFERENCE (MAXI$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (STRINGP (A$0) (MAXI$0) (ASIZE&))
                    (NOT (EQUAL (MAXI$0) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (LESSP (MAXI$0)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (NUMBERP (MAXI$0))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NOT (LESSP (MAXI$0) (SUB1 (I$1)))))
               (LESSP (I$1)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))),

which again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INPUT-COND-OF-ZPLUS


(ADD-AXIOM ASSIGNMENT3
           (REWRITE)
           (AND (EQUAL (I$4) (ZPLUS (I$3) '1))
                (AND (EQUAL (C$4) (C$3))
                     (EQUAL (BLK-DELTA1$4)
                            (BLK-DELTA1$3)))))

WARNING:  Note that the proposed lemma ASSIGNMENT3 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and three replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT3


(PROVE-LEMMA DELTA1-SKIP
             (REWRITE)
             (IMPLIES (AND (NOT (EQUAL J (ELT1 PAT I)))
                           (NOT (ZEROP I)))
                      (EQUAL (DELTA1 PAT J I)
                             (ADD1 (DELTA1 PAT J (SUB1 I))))))

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

      (IMPLIES (AND (NOT (EQUAL J (ELT1 PAT I)))
                    (NOT (EQUAL I 0))
                    (NUMBERP I))
               (EQUAL (DELTA1 PAT J I)
                      (ADD1 (DELTA1 PAT J (SUB1 I))))),

which simplifies, expanding the function DELTA1, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DELTA1-SKIP


(PROVE-LEMMA PASS2-INVRT1 NIL
 (IMPLIES
      (AND (ALMOST-EQUAL1 (BLK-DELTA1$2)
                          (BLK-DELTA1$3)
                          '1
                          (ASIZE&)
                          (C$2)
                          (ZDIFFERENCE (MAXI$0) (I$2)))
           (AND (NOT (ZGREATERP (I$1) (MAXI$0)))
                (PATH-HYPS)))
      (AND (AND (NUMBERP (I$4))
                (AND (NOT (EQUAL (I$4) '0))
                     (AND (NOT (LESSP (ADD1 (MAXI$0)) (I$4)))
                          (IMPLIES (AND (NOT (ZEROP J))
                                        (NOT (LESSP (ASIZE&) J)))
                                   (EQUAL (ELT1 (BLK-DELTA1$4) J)
                                          (PLUS (DELTA1 (A$0) J (SUB1 (I$4)))
                                                (DIFFERENCE (MAXI$0)
                                                            (SUB1 (I$4)))))))))
           (LEX (CONS (DIFFERENCE (ADD1 (MAXI$0)) (I$4))
                      'NIL)
                (CONS (DIFFERENCE (ADD1 (MAXI$0)) (I$1))
                      'NIL)))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS, PATH-HYPS,
NOT, AND, IMPLIES, ASSIGNMENT2, ASSIGNMENT3, ZGREATERP, and ASSIGNMENT1, to:

      (IMPLIES
        (AND (ALMOST-EQUAL1 (BLK-DELTA1$1)
                            (BLK-DELTA1$3)
                            1
                            (ASIZE&)
                            (ELT1 (A$0) (I$1))
                            (ZDIFFERENCE (MAXI$0) (I$1)))
             (NOT (ZLESSP (MAXI$0) (I$1)))
             (NOT (EQUAL (ASIZE&) 0))
             (STRINGP (A$0) (MAXI$0) (ASIZE&))
             (NOT (EQUAL (MAXI$0) 0))
             (LESSP (ADD1 (ASIZE&))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (LESSP (ADD1 (MAXI$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (MAXI$0))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NOT (LESSP (ADD1 (MAXI$0)) (I$1))))
        (AND (AND (NUMBERP (ZPLUS (I$1) 1))
                  (NOT (EQUAL (ZPLUS (I$1) 1) 0))
                  (NOT (LESSP (ADD1 (MAXI$0))
                              (ZPLUS (I$1) 1)))
                  (IMPLIES (AND (NOT (ZEROP J))
                                (NOT (LESSP (ASIZE&) J)))
                           (EQUAL (ELT1 (BLK-DELTA1$3) J)
                                  (PLUS (DELTA1 (A$0)
                                                J
                                                (SUB1 (ZPLUS (I$1) 1)))
                                        (DIFFERENCE (MAXI$0)
                                                    (SUB1 (ZPLUS (I$1) 1)))))))
             (LEX (LIST (DIFFERENCE (ADD1 (MAXI$0))
                                    (ZPLUS (I$1) 1)))
                  (LIST (DIFFERENCE (ADD1 (MAXI$0))
                                    (I$1)))))),

which simplifies, rewriting with SUB1-ADD1, COMMUTATIVITY-OF-PLUS, ASSIGNMENT1,
ASSIGNMENT2, CDR-CONS, and CAR-CONS, and opening up ZDIFFERENCE, ZLESSP, LESSP,
PLUS, EQUAL, NUMBERP, SUB1, NEGATIVEP, ZPLUS, NOT, ZEROP, AND, IMPLIES,
DIFFERENCE, and LEX, to the following three new goals:

Case 3. (IMPLIES (AND (NOT (LESSP (MAXI$0) (I$1)))
                      (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$3)
                                     1
                                     (ASIZE&)
                                     (ELT1 (A$0) (I$1))
                                     (DIFFERENCE (MAXI$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (ASIZE&) J))
                      (EQUAL J (ELT1 (A$0) (I$1))))
                 (EQUAL (DIFFERENCE (MAXI$0) (I$1))
                        (PLUS (DIFFERENCE (MAXI$0) (I$1))
                              (DELTA1 (A$0) J (I$1))))).

  However this again simplifies, rewriting with the lemmas
  STRINGP-IS-A-UNIV-QUANTIFIER and COMMUTATIVITY-OF-PLUS, and unfolding the
  definitions of DELTA1, EQUAL, and PLUS, to:

        T.

Case 2. (IMPLIES (AND (NOT (LESSP (MAXI$0) (I$1)))
                      (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$3)
                                     1
                                     (ASIZE&)
                                     (ELT1 (A$0) (I$1))
                                     (DIFFERENCE (MAXI$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (ASIZE&) J))
                      (NOT (EQUAL J (ELT1 (A$0) (I$1)))))
                 (EQUAL (ELT1 (BLK-DELTA1$1) J)
                        (PLUS (DIFFERENCE (MAXI$0) (I$1))
                              (DELTA1 (A$0) J (I$1))))),

  which again simplifies, applying COMMUTATIVITY-OF-PLUS,
  PATHS-FROM-PASS2-INVRT, DELTA1-SKIP, and PLUS-ADD1, to the new goal:

        (IMPLIES (AND (NOT (LESSP (MAXI$0) (I$1)))
                      (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$3)
                                     1
                                     (ASIZE&)
                                     (ELT1 (A$0) (I$1))
                                     (DIFFERENCE (MAXI$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1))))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (ASIZE&) J))
                      (NOT (EQUAL J (ELT1 (A$0) (I$1)))))
                 (EQUAL (PLUS (DIFFERENCE (MAXI$0) (SUB1 (I$1)))
                              (DELTA1 (A$0) J (SUB1 (I$1))))
                        (ADD1 (PLUS (DIFFERENCE (MAXI$0) (I$1))
                                    (DELTA1 (A$0) J (SUB1 (I$1))))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (LESSP (MAXI$0) (I$1)))
                      (ALMOST-EQUAL1 (BLK-DELTA1$1)
                                     (BLK-DELTA1$3)
                                     1
                                     (ASIZE&)
                                     (ELT1 (A$0) (I$1))
                                     (DIFFERENCE (MAXI$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (STRINGP (A$0) (MAXI$0) (ASIZE&))
                      (NOT (EQUAL (MAXI$0) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (LESSP (MAXI$0)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (NUMBERP (MAXI$0))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (MAXI$0) (SUB1 (I$1)))))
                 (LESSP (DIFFERENCE (MAXI$0) (I$1))
                        (DIFFERENCE (MAXI$0) (SUB1 (I$1))))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

PASS2-INVRT1


(UBT PATHS-FROM-PASS2-INVRT)

PATHS-FROM-PASS2-INVRT


(UBT FORTRAN)

FORTRAN


(ADD-AXIOM FORTRAN NIL T)

[ 0.0 0.0 0.0 ]

FORTRAN


(DCL BLK-DELTA1$1 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$1


(DCL BLK-DELTA1$2 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$2


(DCL BLK-DELTA1$3 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$3


(DCL BLK-DELTA1$4 NIL)

[ 0.0 0.0 0.0 ]

BLK-DELTA1$4


(DCL C$0 NIL)

[ 0.0 0.0 0.0 ]

C$0


(DCL C$1 NIL)

[ 0.0 0.0 0.0 ]

C$1


(DCL C$2 NIL)

[ 0.0 0.0 0.0 ]

C$2


(DCL C$3 NIL)

[ 0.0 0.0 0.0 ]

C$3


(DCL C$4 NIL)

[ 0.0 0.0 0.0 ]

C$4


(DCL I$0 NIL)

[ 0.0 0.0 0.0 ]

I$0


(DCL I$1 NIL)

[ 0.0 0.0 0.0 ]

I$1


(DCL I$2 NIL)

[ 0.0 0.0 0.0 ]

I$2


(DCL I$3 NIL)

[ 0.0 0.0 0.0 ]

I$3


(DCL I$4 NIL)

[ 0.0 0.0 0.0 ]

I$4


(DCL J$0 NIL)

[ 0.3 0.0 0.0 ]

J$0


(DCL J$1 NIL)

[ 0.0 0.0 0.0 ]

J$1


(DCL J$2 NIL)

[ 0.0 0.0 0.0 ]

J$2


(DCL J$3 NIL)

[ 0.0 0.0 0.0 ]

J$3


(DCL J$4 NIL)

[ 0.0 0.0 0.0 ]

J$4


(DCL NEXTI$0 NIL)

[ 0.0 0.0 0.0 ]

NEXTI$0


(DCL NEXTI$1 NIL)

[ 0.0 0.0 0.0 ]

NEXTI$1


(DCL NEXTI$2 NIL)

[ 0.0 0.0 0.0 ]

NEXTI$2


(DCL NEXTI$3 NIL)

[ 0.0 0.0 0.0 ]

NEXTI$3


(DCL NEXTI$4 NIL)

[ 0.0 0.0 0.0 ]

NEXTI$4


(DCL PAT$0 NIL)

[ 0.0 0.0 0.0 ]

PAT$0


(DCL PATLEN$0 NIL)

[ 0.0 0.0 0.0 ]

PATLEN$0


(DCL STR$0 NIL)

[ 0.0 0.0 0.0 ]

STR$0


(DCL STRLEN$0 NIL)

[ 0.0 0.0 0.0 ]

STRLEN$0


(DCL X$0 NIL)

[ 0.0 0.0 0.0 ]

X$0


(DCL X$1 NIL)

[ 0.0 0.0 0.0 ]

X$1


(DCL X$2 NIL)

[ 0.0 0.0 0.0 ]

X$2


(DCL X$3 NIL)

[ 0.0 0.0 0.0 ]

X$3


(DCL X$4 NIL)

[ 0.0 0.0 0.0 ]

X$4


(DCL ASIZE& NIL)

[ 0.0 0.0 0.0 ]

ASIZE&


(ADD-AXIOM ASIZE&-NUMBERP
           (REWRITE)
           (NUMBERP (ASIZE&)))

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


[ 0.0 0.0 0.0 ]

ASIZE&-NUMBERP


(DEFN DELTA1
      (A C MAXI)
      (IF (ZEROP MAXI)
          0
          (IF (EQUAL C (ELT1 A MAXI))
              0
              (ADD1 (DELTA1 A C (SUB1 MAXI))))))

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




[ 0.0 0.0 0.0 ]

DELTA1


(DEFN STRINGP
      (A I SIZE)
      (IF (ZEROP I)
          T
          (AND (NUMBERP (ELT1 A I))
               (NOT (EQUAL (ELT1 A I) 0))
               (NOT (LESSP SIZE (ELT1 A I)))
               (STRINGP A (SUB1 I) SIZE))))

     Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP
can be used to establish that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each recursive call.  Hence, STRINGP is
accepted under the definitional principle.  Note that:
      (OR (FALSEP (STRINGP A I SIZE))
          (TRUEP (STRINGP A I SIZE)))
is a theorem.




[ 0.0 0.0 0.0 ]

STRINGP


(PROVE-LEMMA STRINGP-IS-A-UNIV-QUANTIFIER
             (REWRITE)
             (IMPLIES (AND (STRINGP A I (ASIZE&))
                           (NOT (EQUAL J 0))
                           (NUMBERP J)
                           (NOT (LESSP I J)))
                      (AND (NUMBERP (ELT1 A J))
                           (NOT (LESSP (ASIZE&) (ELT1 A J)))
                           (NOT (EQUAL (ELT1 A J) 0)))))

WARNING:  Note that STRINGP-IS-A-UNIV-QUANTIFIER contains the free variable I
which will be chosen by instantiating the hypothesis (STRINGP A I (ASIZE&)).


WARNING:  When the linear lemma STRINGP-IS-A-UNIV-QUANTIFIER is stored under
(ELT1 A J) it contains the free variable I which will be chosen by
instantiating the hypothesis (STRINGP A I (ASIZE&)).


WARNING:  When the linear lemma STRINGP-IS-A-UNIV-QUANTIFIER is stored under
(ASIZE&) it contains the free variables J, I, and A which will be chosen by
instantiating the hypotheses (STRINGP A I (ASIZE&)) and (NOT (EQUAL J 0)).


WARNING:  Note that STRINGP-IS-A-UNIV-QUANTIFIER contains the free variable I
which will be chosen by instantiating the hypothesis (STRINGP A I (ASIZE&)).


WARNING:  Note that the proposed lemma STRINGP-IS-A-UNIV-QUANTIFIER is to be
stored as zero type prescription rules, zero compound recognizer rules, two
linear rules, and two replacement rules.


This conjecture simplifies, unfolding the functions NOT and AND, to the
following three new formulas:

Case 3. (IMPLIES (AND (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))).

  Name the above subgoal *1.

Case 2. (IMPLIES (AND (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

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


     So now let us consider:

(AND (IMPLIES (AND (STRINGP A I (ASIZE&))
                   (NOT (EQUAL J 0))
                   (NUMBERP J)
                   (NOT (LESSP I J)))
              (NUMBERP (ELT1 A J)))
     (IMPLIES (AND (STRINGP A I (ASIZE&))
                   (NOT (EQUAL J 0))
                   (NUMBERP J)
                   (NOT (LESSP I J)))
              (NOT (LESSP (ASIZE&) (ELT1 A J))))
     (IMPLIES (AND (STRINGP A I (ASIZE&))
                   (NOT (EQUAL J 0))
                   (NUMBERP J)
                   (NOT (LESSP I J)))
              (NOT (EQUAL (ELT1 A J) 0)))).

We gave this the name *1 above.  Perhaps we can prove it by induction.  There
are three plausible inductions.  However, they merge into one likely candidate
induction.  We will induct according to the following scheme:
      (AND (IMPLIES (ZEROP I) (p A J I))
           (IMPLIES (AND (NOT (ZEROP I)) (p A J (SUB1 I)))
                    (p A J I))).
Linear arithmetic, the lemma COUNT-NUMBERP, and the definition of ZEROP can be
used to prove that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces nine new conjectures:

Case 9. (IMPLIES (AND (ZEROP I)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))),

  which simplifies, expanding the definitions of ZEROP, EQUAL, STRINGP, and
  LESSP, to:

        T.

Case 8. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (STRINGP A (SUB1 I) (ASIZE&)))
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))),

  which simplifies, expanding the functions ZEROP and STRINGP, to:

        T.

Case 7. (IMPLIES (AND (NOT (ZEROP I))
                      (LESSP (SUB1 I) J)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NUMBERP (ELT1 A J))),

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

  Case 7.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) J)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (LESSP I J)))
                   (NUMBERP (ELT1 A J))),

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

          T.

  Case 7.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) I)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL I 0))
                        (NOT (LESSP I I)))
                   (NUMBERP (ELT1 A I))),

    which again simplifies, unfolding the definitions of ZEROP and STRINGP, to:

          T.

Case 6. (IMPLIES (AND (ZEROP I)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

  which simplifies, opening up the definitions of ZEROP, EQUAL, STRINGP, and
  LESSP, to:

        T.

Case 5. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (STRINGP A (SUB1 I) (ASIZE&)))
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

  which simplifies, expanding ZEROP and STRINGP, to:

        T.

Case 4. (IMPLIES (AND (NOT (ZEROP I))
                      (LESSP (SUB1 I) J)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (LESSP (ASIZE&) (ELT1 A J)))),

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

  Case 4.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) J)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (LESSP I J)))
                   (NOT (LESSP (ASIZE&) (ELT1 A J)))),

    which again simplifies, opening up ZEROP, to:

          T.

  Case 4.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) I)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL I 0))
                        (NOT (LESSP I I)))
                   (NOT (LESSP (ASIZE&) (ELT1 A I)))),

    which again simplifies, unfolding the functions ZEROP and STRINGP, to:

          T.

Case 3. (IMPLIES (AND (ZEROP I)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (EQUAL (ELT1 A J) 0))),

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

        T.

Case 2. (IMPLIES (AND (NOT (ZEROP I))
                      (NOT (STRINGP A (SUB1 I) (ASIZE&)))
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (EQUAL (ELT1 A J) 0))),

  which simplifies, unfolding the functions ZEROP and STRINGP, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP I))
                      (LESSP (SUB1 I) J)
                      (STRINGP A I (ASIZE&))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP I J)))
                 (NOT (EQUAL (ELT1 A J) 0))),

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

  Case 1.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) J)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (LESSP I J)))
                   (NOT (EQUAL (ELT1 A J) 0))),

    which again simplifies, opening up ZEROP, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (ZEROP I))
                        (LESSP (SUB1 I) I)
                        (STRINGP A I (ASIZE&))
                        (NOT (EQUAL I 0))
                        (NOT (LESSP I I)))
                   (NOT (EQUAL (ELT1 A I) 0))),

    which again simplifies, expanding ZEROP, STRINGP, NUMBERP, and EQUAL, to:

          T.


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


[ 0.0 0.1 0.0 ]

STRINGP-IS-A-UNIV-QUANTIFIER


(DEFN MATCH
      (PAT J PATLEN STR I STRLEN)
      (IF (LESSP PATLEN J)
          T
          (IF (LESSP STRLEN I)
              F
              (AND (EQUAL (ELT1 PAT J) (ELT1 STR I))
                   (MATCH PAT
                          (ADD1 J)
                          PATLEN STR
                          (ADD1 I)
                          STRLEN))))
      ((LESSP (DIFFERENCE (ADD1 PATLEN) J))
       (LESSP (DIFFERENCE (ADD1 STRLEN) I))))

     Linear arithmetic can be used to establish that the measure:
      (DIFFERENCE (ADD1 PATLEN) J)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, MATCH is accepted under the definitional principle.  The definition of
MATCH can be justified in another way.  Linear arithmetic informs us that the
measure (DIFFERENCE (ADD1 STRLEN) I) decreases according to the well-founded
relation LESSP in each recursive call.  Note that:
      (OR (FALSEP (MATCH PAT J PATLEN STR I STRLEN))
          (TRUEP (MATCH PAT J PATLEN STR I STRLEN)))
is a theorem.




[ 0.0 0.0 0.0 ]

MATCH


(DEFN SEARCH
      (PAT STR PATLEN STRLEN I)
      (IF (LESSP STRLEN I)
          (ADD1 STRLEN)
          (IF (MATCH PAT 1 PATLEN STR I STRLEN)
              I
              (SEARCH PAT STR PATLEN STRLEN
                      (ADD1 I))))
      ((LESSP (DIFFERENCE (ADD1 STRLEN) I))))

     Linear arithmetic establishes that the measure:
      (DIFFERENCE (ADD1 STRLEN) I)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, SEARCH is accepted under the principle of definition.  Note that:
      (OR (NUMBERP (SEARCH PAT STR PATLEN STRLEN I))
          (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                 I))
is a theorem.




[ 0.0 0.0 0.0 ]

SEARCH


(ADD-AXIOM INPUT-CONDITIONS
           (REWRITE)
           '*1*TRUE)

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


[ 0.0 0.0 0.0 ]

INPUT-CONDITIONS


(DEFN GLOBAL-HYPS NIL
 (AND
   (NOT (EQUAL (ASIZE&) '0))
   (AND (LESSP (ADD1 (ASIZE&))
               (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
        (AND (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (AND (LESSP '0 (PATLEN$0))
                  (AND (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                       (AND (LESSP '0 (STRLEN$0))
                            (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                                        (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                                 (AND (NUMBERP (PATLEN$0))
                                      (NUMBERP (STRLEN$0)))))))))))

     From the definition we can conclude that:
      (OR (FALSEP (GLOBAL-HYPS))
          (TRUEP (GLOBAL-HYPS)))
is a theorem.




[ 0.0 0.0 0.0 ]

GLOBAL-HYPS


(PROVE-LEMMA SEARCH-NON-ZERO
             (REWRITE)
             (IMPLIES (NOT (ZEROP I))
                      (LESSP 0
                             (SEARCH PAT STR PATLEN STRLEN I))))

WARNING:  Note that the proposed lemma SEARCH-NON-ZERO 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 ZEROP, NOT, and
IMPLIES, to the goal:

      (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I))
               (LESSP 0
                      (SEARCH PAT STR PATLEN STRLEN I))).

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

      (IMPLIES (AND (NOT (EQUAL I 0)) (NUMBERP I))
               (NOT (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                           0))),

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 (LESSP STRLEN I)
                    (p PAT STR PATLEN STRLEN I))
           (IMPLIES (AND (NOT (LESSP STRLEN I))
                         (MATCH PAT 1 PATLEN STR I STRLEN))
                    (p PAT STR PATLEN STRLEN I))
           (IMPLIES (AND (NOT (LESSP STRLEN I))
                         (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                         (p PAT STR PATLEN STRLEN (ADD1 I)))
                    (p PAT STR PATLEN STRLEN I))).
Linear arithmetic can be used to show that the measure:
      (DIFFERENCE (ADD1 STRLEN) I)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme leads to four new formulas:

Case 4. (IMPLIES (AND (LESSP STRLEN I)
                      (NOT (EQUAL I 0))
                      (NUMBERP I))
                 (NOT (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                             0))),

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

        T.

Case 3. (IMPLIES (AND (NOT (LESSP STRLEN I))
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NOT (EQUAL I 0))
                      (NUMBERP I))
                 (NOT (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                             0))),

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

        T.

Case 2. (IMPLIES (AND (NOT (LESSP STRLEN I))
                      (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                      (EQUAL (ADD1 I) 0)
                      (NOT (EQUAL I 0))
                      (NUMBERP I))
                 (NOT (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                             0))),

  which simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (LESSP STRLEN I))
                      (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                      (NOT (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                          (ADD1 I))
                                  0))
                      (NOT (EQUAL I 0))
                      (NUMBERP I))
                 (NOT (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                             0))),

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

        T.


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


[ 0.0 0.0 0.0 ]

SEARCH-NON-ZERO


(PROVE-LEMMA MATCH-AT-PATLEN
             (REWRITE)
             (IMPLIES (LESSP PATLEN J)
                      (MATCH PAT J PATLEN STR I STRLEN)))

This conjecture simplifies, expanding MATCH, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

MATCH-AT-PATLEN


(PROVE-LEMMA MATCH-AT-STRLEN
             (REWRITE)
             (IMPLIES (LESSP STRLEN I)
                      (EQUAL (MATCH PAT J PATLEN STR I STRLEN)
                             (LESSP PATLEN J))))

This conjecture simplifies, expanding the definition of MATCH, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

MATCH-AT-STRLEN


(PROVE-LEMMA MATCH-NEEDS-PATLEN-CHARS
             (REWRITE)
             (IMPLIES (AND (NUMBERP PATLEN)
                           (NUMBERP STRLEN)
                           (NOT (LESSP PATLEN J))
                           (NOT (LESSP STRLEN I))
                           (LESSP (PLUS J STRLEN)
                                  (PLUS I PATLEN)))
                      (NOT (MATCH PAT J PATLEN STR I STRLEN))))


     Name the conjecture *1.


     Perhaps we can prove it by induction.  There are eight plausible
inductions.  They merge into three likely candidate inductions.  However, only
one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (LESSP PATLEN J)
                    (p PAT J PATLEN STR I STRLEN))
           (IMPLIES (AND (NOT (LESSP PATLEN J))
                         (LESSP STRLEN I))
                    (p PAT J PATLEN STR I STRLEN))
           (IMPLIES (AND (NOT (LESSP PATLEN J))
                         (NOT (LESSP STRLEN I))
                         (p PAT
                            (ADD1 J)
                            PATLEN STR
                            (ADD1 I)
                            STRLEN))
                    (p PAT J PATLEN STR I STRLEN))).
Linear arithmetic can be used to prove that the measure:
      (DIFFERENCE (ADD1 PATLEN) J)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instance chosen for I.  The above
induction scheme leads to four new goals:

Case 4. (IMPLIES (AND (LESSP PATLEN (ADD1 J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP STRLEN I))
                      (LESSP (PLUS J STRLEN)
                             (PLUS I PATLEN)))
                 (NOT (MATCH PAT J PATLEN STR I STRLEN))),

  which simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES (AND (LESSP STRLEN (ADD1 I))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP STRLEN I))
                      (LESSP (PLUS J STRLEN)
                             (PLUS I PATLEN)))
                 (NOT (MATCH PAT J PATLEN STR I STRLEN))),

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

  Case 3.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (LESSP STRLEN (ADD1 I))
                        (NUMBERP PATLEN)
                        (NUMBERP STRLEN)
                        (NOT (LESSP PATLEN J))
                        (NOT (LESSP STRLEN I))
                        (LESSP (PLUS J STRLEN)
                               (PLUS I PATLEN)))
                   (NOT (MATCH PAT J PATLEN STR I STRLEN))),

    which again simplifies, rewriting with SUB1-TYPE-RESTRICTION, and
    unfolding the definitions of LESSP, PLUS, and MATCH, to:

          (IMPLIES (AND (NOT (NUMBERP I))
                        (LESSP STRLEN 1)
                        (NUMBERP PATLEN)
                        (NUMBERP STRLEN)
                        (NOT (LESSP PATLEN J))
                        (LESSP (PLUS J STRLEN) PATLEN)
                        (EQUAL (ELT1 PAT J) (ELT1 STR I)))
                   (NOT (MATCH PAT
                               (ADD1 J)
                               PATLEN STR
                               (ADD1 I)
                               STRLEN))),

    which further simplifies, applying SUB1-TYPE-RESTRICTION, SUB1-ADD1, and
    MATCH-AT-STRLEN, and expanding the definition of LESSP, to the following
    three new conjectures:

    Case 3.2.3.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (LESSP STRLEN 1)
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (NOT (LESSP PATLEN J))
                          (LESSP (PLUS J STRLEN) PATLEN)
                          (EQUAL (ELT1 PAT J) (ELT1 STR I)))
                     (NOT (EQUAL PATLEN 0))).

      But this again simplifies, using linear arithmetic, to:

            T.

    Case 3.2.2.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (LESSP STRLEN 1)
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (NOT (LESSP PATLEN J))
                          (LESSP (PLUS J STRLEN) PATLEN)
                          (EQUAL (ELT1 PAT J) (ELT1 STR I))
                          (NOT (NUMBERP J)))
                     (NOT (LESSP (SUB1 PATLEN) 0))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 3.2.1.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (LESSP STRLEN 1)
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (NOT (LESSP PATLEN J))
                          (LESSP (PLUS J STRLEN) PATLEN)
                          (EQUAL (ELT1 PAT J) (ELT1 STR I))
                          (NUMBERP J))
                     (NOT (LESSP (SUB1 PATLEN) J))),

      which again simplifies, using linear arithmetic, to:

            T.

  Case 3.1.
          (IMPLIES (AND (NUMBERP I)
                        (LESSP I (ADD1 I))
                        (NUMBERP PATLEN)
                        (NOT (LESSP PATLEN J))
                        (NOT (LESSP I I))
                        (LESSP (PLUS J I) (PLUS I PATLEN)))
                   (NOT (MATCH PAT J PATLEN STR I I))),

    which again simplifies, using linear arithmetic, applying SUB1-ADD1,
    COMMUTATIVITY-OF-PLUS, MATCH-AT-STRLEN, and SUB1-TYPE-RESTRICTION, and
    unfolding the definitions of LESSP, EQUAL, PLUS, ADD1, and MATCH, to the
    following six new goals:

    Case 3.1.6.
            (IMPLIES (AND (NUMBERP I)
                          (EQUAL I 0)
                          (NUMBERP PATLEN)
                          (NOT (LESSP PATLEN J))
                          (NOT (NUMBERP J))
                          (LESSP 0 PATLEN)
                          (EQUAL (ELT1 PAT J) (ELT1 STR 0)))
                     (NOT (LESSP PATLEN 1))).

      But this again simplifies, using linear arithmetic, to:

            T.

    Case 3.1.5.
            (IMPLIES (AND (NUMBERP I)
                          (EQUAL I 0)
                          (NUMBERP PATLEN)
                          (NOT (LESSP PATLEN J))
                          (NUMBERP J)
                          (LESSP J PATLEN)
                          (EQUAL (ELT1 PAT J) (ELT1 STR 0)))
                     (NOT (LESSP (SUB1 PATLEN) J))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 3.1.4.
            (IMPLIES (AND (NUMBERP I)
                          (EQUAL I 0)
                          (NUMBERP PATLEN)
                          (NOT (LESSP PATLEN J))
                          (NUMBERP J)
                          (LESSP J PATLEN)
                          (EQUAL (ELT1 PAT J) (ELT1 STR 0)))
                     (NOT (EQUAL PATLEN 0))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 3.1.3.
            (IMPLIES (AND (NUMBERP I)
                          (LESSP (SUB1 I) I)
                          (NUMBERP PATLEN)
                          (NOT (LESSP PATLEN J))
                          (NOT (LESSP I I))
                          (LESSP (PLUS I J) (PLUS I PATLEN))
                          (EQUAL (ELT1 PAT J) (ELT1 STR I))
                          (NUMBERP J))
                     (NOT (LESSP (SUB1 PATLEN) J))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 3.1.2.
            (IMPLIES (AND (NUMBERP I)
                          (LESSP (SUB1 I) I)
                          (NUMBERP PATLEN)
                          (NOT (LESSP PATLEN J))
                          (NOT (LESSP I I))
                          (LESSP (PLUS I J) (PLUS I PATLEN))
                          (EQUAL (ELT1 PAT J) (ELT1 STR I))
                          (NOT (NUMBERP J)))
                     (NOT (LESSP (SUB1 PATLEN) 0))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 3.1.1.
            (IMPLIES (AND (NUMBERP I)
                          (LESSP (SUB1 I) I)
                          (NUMBERP PATLEN)
                          (NOT (LESSP PATLEN J))
                          (NOT (LESSP I I))
                          (LESSP (PLUS I J) (PLUS I PATLEN))
                          (EQUAL (ELT1 PAT J) (ELT1 STR I)))
                     (NOT (EQUAL PATLEN 0))),

      which again simplifies, using linear arithmetic, to:

            T.

Case 2. (IMPLIES (AND (NOT (LESSP (PLUS (ADD1 J) STRLEN)
                                  (PLUS (ADD1 I) PATLEN)))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP STRLEN I))
                      (LESSP (PLUS J STRLEN)
                             (PLUS I PATLEN)))
                 (NOT (MATCH PAT J PATLEN STR I STRLEN))),

  which simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (MATCH PAT
                                  (ADD1 J)
                                  PATLEN STR
                                  (ADD1 I)
                                  STRLEN))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP STRLEN I))
                      (LESSP (PLUS J STRLEN)
                             (PLUS I PATLEN)))
                 (NOT (MATCH PAT J PATLEN STR I STRLEN))),

  which simplifies, opening up MATCH, to:

        T.


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


[ 0.0 0.0 0.0 ]

MATCH-NEEDS-PATLEN-CHARS


(PROVE-LEMMA SEARCH-BOUNDARY
             (REWRITE)
             (IMPLIES (AND (NOT (ZEROP PATLEN))
                           (NUMBERP STRLEN)
                           (NOT (LESSP STRLEN I))
                           (LESSP (ADD1 STRLEN)
                                  (PLUS PATLEN
                                        (SEARCH PAT STR PATLEN STRLEN I))))
                      (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                             (ADD1 STRLEN))))

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

      (IMPLIES (AND (NOT (EQUAL PATLEN 0))
                    (NUMBERP PATLEN)
                    (NUMBERP STRLEN)
                    (NOT (LESSP STRLEN I))
                    (LESSP (ADD1 STRLEN)
                           (PLUS PATLEN
                                 (SEARCH PAT STR PATLEN STRLEN I))))
               (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                      (ADD1 STRLEN))).

This simplifies, rewriting with SUB1-ADD1, and unfolding LESSP, to the
conjecture:

      (IMPLIES (AND (NOT (EQUAL PATLEN 0))
                    (NUMBERP PATLEN)
                    (NUMBERP STRLEN)
                    (NOT (LESSP STRLEN I))
                    (NOT (EQUAL (PLUS PATLEN
                                      (SEARCH PAT STR PATLEN STRLEN I))
                                0))
                    (LESSP STRLEN
                           (SUB1 (PLUS PATLEN
                                       (SEARCH PAT STR PATLEN STRLEN I)))))
               (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                      (ADD1 STRLEN))).

Name the above subgoal *1.


     We will appeal to induction.  There are eight plausible inductions.  They
merge into three likely candidate inductions.  However, only one is unflawed.
We will induct according to the following scheme:
      (AND (IMPLIES (LESSP STRLEN I)
                    (p PAT STR PATLEN STRLEN I))
           (IMPLIES (AND (NOT (LESSP STRLEN I))
                         (MATCH PAT 1 PATLEN STR I STRLEN))
                    (p PAT STR PATLEN STRLEN I))
           (IMPLIES (AND (NOT (LESSP STRLEN I))
                         (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                         (p PAT STR PATLEN STRLEN (ADD1 I)))
                    (p PAT STR PATLEN STRLEN I))).
Linear arithmetic informs us that the measure (DIFFERENCE (ADD1 STRLEN) I)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces the following five new
formulas:

Case 5. (IMPLIES (AND (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NOT (EQUAL PATLEN 0))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NOT (EQUAL (PLUS PATLEN
                                        (SEARCH PAT STR PATLEN STRLEN I))
                                  0))
                      (LESSP STRLEN
                             (SUB1 (PLUS PATLEN
                                         (SEARCH PAT STR PATLEN STRLEN I)))))
                 (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                        (ADD1 STRLEN))).

  This simplifies, using linear arithmetic, rewriting with the lemmas
  COMMUTATIVITY-OF-PLUS, SUB1-ADD1, and MATCH-NEEDS-PATLEN-CHARS, and opening
  up SEARCH, LESSP, PLUS, EQUAL, NUMBERP, and SUB1, to:

        (IMPLIES (AND (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NOT (EQUAL PATLEN 0))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NOT (EQUAL (PLUS I PATLEN) 0))
                      (LESSP STRLEN (SUB1 (PLUS I PATLEN))))
                 (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                (ADD1 I))
                        (ADD1 STRLEN))),

  which again simplifies, using linear arithmetic, rewriting with
  MATCH-NEEDS-PATLEN-CHARS, and expanding the functions PLUS, EQUAL, NUMBERP,
  and SUB1, to:

        T.

Case 4. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                      (LESSP STRLEN (ADD1 I))
                      (NOT (EQUAL PATLEN 0))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NOT (EQUAL (PLUS PATLEN
                                        (SEARCH PAT STR PATLEN STRLEN I))
                                  0))
                      (LESSP STRLEN
                             (SUB1 (PLUS PATLEN
                                         (SEARCH PAT STR PATLEN STRLEN I)))))
                 (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                        (ADD1 STRLEN))).

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

  Case 4.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                        (LESSP STRLEN (ADD1 I))
                        (NOT (EQUAL PATLEN 0))
                        (NUMBERP PATLEN)
                        (NUMBERP STRLEN)
                        (NOT (LESSP STRLEN I))
                        (NOT (EQUAL (PLUS PATLEN
                                          (SEARCH PAT STR PATLEN STRLEN I))
                                    0))
                        (LESSP STRLEN
                               (SUB1 (PLUS PATLEN
                                           (SEARCH PAT STR PATLEN STRLEN I)))))
                   (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                          (ADD1 STRLEN))).

    But this again simplifies, using linear arithmetic, rewriting with
    SUB1-TYPE-RESTRICTION, MATCH-AT-STRLEN, COMMUTATIVITY-OF-PLUS, SUB1-ADD1,
    MATCH-NEEDS-PATLEN-CHARS, and MATCH-AT-PATLEN, and opening up the
    functions LESSP, SEARCH, ADD1, MATCH, PLUS, EQUAL, NUMBERP, and SUB1, to
    the following four new formulas:

    Case 4.2.4.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                          (LESSP STRLEN 1)
                          (NOT (EQUAL PATLEN 0))
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (EQUAL (ELT1 PAT 1) (ELT1 STR I))
                          (LESSP PATLEN 2)
                          (NOT (EQUAL (PLUS PATLEN I) 0))
                          (LESSP STRLEN (SUB1 PATLEN)))
                     (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                    (ADD1 I))
                            (ADD1 STRLEN))).

      This again simplifies, using linear arithmetic, to:

            T.

    Case 4.2.3.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                          (LESSP STRLEN 1)
                          (NOT (EQUAL PATLEN 0))
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (LESSP PATLEN 1)
                          (NOT (EQUAL (PLUS PATLEN I) 0)))
                     (NOT (LESSP STRLEN (SUB1 PATLEN)))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 4.2.2.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                          (LESSP STRLEN 1)
                          (NOT (EQUAL PATLEN 0))
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (NOT (LESSP PATLEN 1))
                          (NOT (LESSP PATLEN 2))
                          (NOT (EQUAL (PLUS PATLEN
                                            (SEARCH PAT STR PATLEN STRLEN
                                                    (ADD1 I)))
                                      0))
                          (LESSP STRLEN
                                 (SUB1 (PLUS PATLEN
                                             (SEARCH PAT STR PATLEN STRLEN
                                                     (ADD1 I))))))
                     (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                    (ADD1 I))
                            (ADD1 STRLEN))),

      which again simplifies, using linear arithmetic, appealing to the lemma
      MATCH-NEEDS-PATLEN-CHARS, and opening up PLUS, EQUAL, NUMBERP, and SUB1,
      to:

            (IMPLIES (AND (NOT (NUMBERP I))
                          (LESSP STRLEN 1)
                          (NOT (EQUAL PATLEN 0))
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (NOT (LESSP PATLEN 1))
                          (NOT (LESSP PATLEN 2))
                          (NOT (EQUAL (PLUS PATLEN
                                            (SEARCH PAT STR PATLEN STRLEN
                                                    (ADD1 I)))
                                      0))
                          (LESSP STRLEN
                                 (SUB1 (PLUS PATLEN
                                             (SEARCH PAT STR PATLEN STRLEN
                                                     (ADD1 I))))))
                     (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                    (ADD1 I))
                            (ADD1 STRLEN))).

      This further simplifies, appealing to the lemmas SUB1-TYPE-RESTRICTION,
      PLUS-ADD1, and SUB1-ADD1, and expanding the definition of SEARCH, to:

            T.

    Case 4.2.1.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                          (LESSP STRLEN 1)
                          (NOT (EQUAL PATLEN 0))
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (NOT (LESSP PATLEN 1))
                          (NOT (EQUAL (ELT1 PAT 1) (ELT1 STR I)))
                          (NOT (EQUAL (PLUS PATLEN
                                            (SEARCH PAT STR PATLEN STRLEN
                                                    (ADD1 I)))
                                      0))
                          (LESSP STRLEN
                                 (SUB1 (PLUS PATLEN
                                             (SEARCH PAT STR PATLEN STRLEN
                                                     (ADD1 I))))))
                     (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                    (ADD1 I))
                            (ADD1 STRLEN))),

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

            (IMPLIES (AND (NOT (NUMBERP I))
                          (LESSP STRLEN 1)
                          (NOT (EQUAL PATLEN 0))
                          (NUMBERP PATLEN)
                          (NUMBERP STRLEN)
                          (NOT (LESSP PATLEN 1))
                          (NOT (EQUAL (ELT1 PAT 1) (ELT1 STR I)))
                          (NOT (EQUAL (PLUS PATLEN
                                            (SEARCH PAT STR PATLEN STRLEN
                                                    (ADD1 I)))
                                      0))
                          (LESSP STRLEN
                                 (SUB1 (PLUS PATLEN
                                             (SEARCH PAT STR PATLEN STRLEN
                                                     (ADD1 I))))))
                     (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                    (ADD1 I))
                            (ADD1 STRLEN))).

      But this further simplifies, appealing to the lemmas
      SUB1-TYPE-RESTRICTION, PLUS-ADD1, and SUB1-ADD1, and unfolding the
      function SEARCH, to:

            T.

  Case 4.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (MATCH PAT 1 PATLEN STR I I))
                        (LESSP I (ADD1 I))
                        (NOT (EQUAL PATLEN 0))
                        (NUMBERP PATLEN)
                        (NOT (LESSP I I))
                        (NOT (EQUAL (PLUS PATLEN
                                          (SEARCH PAT STR PATLEN I I))
                                    0))
                        (LESSP I
                               (SUB1 (PLUS PATLEN
                                           (SEARCH PAT STR PATLEN I I)))))
                   (EQUAL (SEARCH PAT STR PATLEN I I)
                          (ADD1 I))),

    which again simplifies, using linear arithmetic, applying MATCH-AT-STRLEN,
    SUB1-ADD1, COMMUTATIVITY-OF-PLUS, and PLUS-ADD1, and opening up ADD1,
    MATCH, LESSP, SEARCH, SUB1, NUMBERP, EQUAL, and PLUS, to the new goal:

          (IMPLIES (AND (NUMBERP I)
                        (NOT (LESSP PATLEN 1))
                        (NOT (EQUAL (ELT1 PAT 1) (ELT1 STR I)))
                        (EQUAL I 0)
                        (NOT (EQUAL PATLEN 0))
                        (NUMBERP PATLEN)
                        (EQUAL (ELT1 PAT 1) (ELT1 STR 0))
                        (LESSP PATLEN 2)
                        (NOT (EQUAL (PLUS PATLEN 0) 0)))
                   (EQUAL (SUB1 PATLEN) 0)),

    which again simplifies, trivially, to:

          T.

Case 3. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                      (EQUAL (PLUS PATLEN
                                   (SEARCH PAT STR PATLEN STRLEN
                                           (ADD1 I)))
                             0)
                      (NOT (EQUAL PATLEN 0))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NOT (EQUAL (PLUS PATLEN
                                        (SEARCH PAT STR PATLEN STRLEN I))
                                  0))
                      (LESSP STRLEN
                             (SUB1 (PLUS PATLEN
                                         (SEARCH PAT STR PATLEN STRLEN I)))))
                 (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                        (ADD1 STRLEN))).

  This simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                      (NOT (LESSP STRLEN
                                  (SUB1 (PLUS PATLEN
                                              (SEARCH PAT STR PATLEN
                                                      STRLEN
                                                      (ADD1 I))))))
                      (NOT (EQUAL PATLEN 0))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NOT (EQUAL (PLUS PATLEN
                                        (SEARCH PAT STR PATLEN STRLEN I))
                                  0))
                      (LESSP STRLEN
                             (SUB1 (PLUS PATLEN
                                         (SEARCH PAT STR PATLEN STRLEN I)))))
                 (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                        (ADD1 STRLEN))).

  This simplifies, opening up SEARCH, to:

        T.

Case 1. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                      (EQUAL (SEARCH PAT STR PATLEN STRLEN
                                     (ADD1 I))
                             (ADD1 STRLEN))
                      (NOT (EQUAL PATLEN 0))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NOT (EQUAL (PLUS PATLEN
                                        (SEARCH PAT STR PATLEN STRLEN I))
                                  0))
                      (LESSP STRLEN
                             (SUB1 (PLUS PATLEN
                                         (SEARCH PAT STR PATLEN STRLEN I)))))
                 (EQUAL (SEARCH PAT STR PATLEN STRLEN I)
                        (ADD1 STRLEN))).

  This simplifies, rewriting with the lemmas PLUS-ADD1 and SUB1-ADD1, and
  expanding the function SEARCH, to:

        T.


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


[ 0.0 0.2 0.0 ]

SEARCH-BOUNDARY


(PROVE-LEMMA DELTA1-LESSEQP-PATLEN
             (REWRITE)
             (NOT (LESSP PATLEN
                         (DELTA1 PAT CHAR PATLEN))))

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



     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 (OR (EQUAL (DELTA1 PAT CHAR PATLEN) 0)
                        (NOT (NUMBERP (DELTA1 PAT CHAR PATLEN))))
                    (p PATLEN PAT CHAR))
           (IMPLIES (AND (NOT (OR (EQUAL (DELTA1 PAT CHAR PATLEN) 0)
                                  (NOT (NUMBERP (DELTA1 PAT CHAR PATLEN)))))
                         (OR (EQUAL PATLEN 0)
                             (NOT (NUMBERP PATLEN))))
                    (p PATLEN PAT CHAR))
           (IMPLIES (AND (NOT (OR (EQUAL (DELTA1 PAT CHAR PATLEN) 0)
                                  (NOT (NUMBERP (DELTA1 PAT CHAR PATLEN)))))
                         (NOT (OR (EQUAL PATLEN 0)
                                  (NOT (NUMBERP PATLEN))))
                         (p (SUB1 PATLEN) PAT CHAR))
                    (p PATLEN PAT CHAR))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT inform us that the measure (COUNT PATLEN) 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 (OR (EQUAL (DELTA1 PAT CHAR PATLEN) 0)
                     (NOT (NUMBERP (DELTA1 PAT CHAR PATLEN))))
                 (NOT (LESSP PATLEN
                             (DELTA1 PAT CHAR PATLEN)))).

  This simplifies, expanding the functions DELTA1, NOT, OR, EQUAL, and LESSP,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL (DELTA1 PAT CHAR PATLEN) 0)
                               (NOT (NUMBERP (DELTA1 PAT CHAR PATLEN)))))
                      (OR (EQUAL PATLEN 0)
                          (NOT (NUMBERP PATLEN))))
                 (NOT (LESSP PATLEN
                             (DELTA1 PAT CHAR PATLEN)))).

  This simplifies, opening up DELTA1, NOT, and OR, to:

        T.

Case 1. (IMPLIES (AND (NOT (OR (EQUAL (DELTA1 PAT CHAR PATLEN) 0)
                               (NOT (NUMBERP (DELTA1 PAT CHAR PATLEN)))))
                      (NOT (OR (EQUAL PATLEN 0)
                               (NOT (NUMBERP PATLEN))))
                      (NOT (LESSP (SUB1 PATLEN)
                                  (DELTA1 PAT CHAR (SUB1 PATLEN)))))
                 (NOT (LESSP PATLEN
                             (DELTA1 PAT CHAR PATLEN)))).

  This simplifies, rewriting with SUB1-ADD1, and expanding DELTA1, NOT, OR,
  and LESSP, to:

        T.


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


[ 0.0 0.0 0.0 ]

DELTA1-LESSEQP-PATLEN


(PROVE-LEMMA INPUT-DEFINEDNESS NIL
             (IMPLIES (GLOBAL-HYPS) '*1*TRUE))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS and
IMPLIES, to:

      T.

This simplifies, obviously, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INPUT-DEFINEDNESS


(ADD-AXIOM INPUT NIL T)

[ 0.0 0.0 0.0 ]

INPUT


(PROVE-LEMMA CALL-OF-SETUP NIL
 (IMPLIES
       (AND (PATLEN$0) (GLOBAL-HYPS))
       (AND (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
            (AND (NOT (EQUAL (PATLEN$0) '0))
                 (AND (NUMBERP (PATLEN$0))
                      (AND (LESSP (ADD1 (ASIZE&))
                                  (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                           (LESSP (ADD1 (PATLEN$0))
                                  (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS, AND,
and IMPLIES, to:

      (IMPLIES (AND (PATLEN$0)
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0)))
               (AND (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (NOT (EQUAL (PATLEN$0) 0))
                    (NUMBERP (PATLEN$0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (LESSP (ADD1 (PATLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))).

This simplifies, applying SUB1-ADD1, and expanding LESSP, EQUAL, NOT, and AND,
to:

      (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (NOT (EQUAL (PATLEN$0) 0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (NOT (EQUAL (STRLEN$0) 0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0)))
               (LESSP (PATLEN$0)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))).

This again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

CALL-OF-SETUP


(ADD-AXIOM EFFECTS-OF-SETUP
           (REWRITE)
           (AND (IMPLIES (AND (NUMBERP C)
                              (AND (NOT (EQUAL C '0))
                                   (NOT (LESSP (ASIZE&) C))))
                         (EQUAL (ELT1 (BLK-DELTA1$1) C)
                                (DELTA1 (PAT$0) C (PATLEN$0))))
                (AND (EQUAL (I$1) (I$0))
                     (AND (EQUAL (J$1) (J$0))
                          (AND (EQUAL (C$1) (C$0))
                               (AND (EQUAL (NEXTI$1) (NEXTI$0))
                                    (EQUAL (X$1) (X$0))))))))

WARNING:  Note that the proposed lemma EFFECTS-OF-SETUP is to be stored as
zero type prescription rules, zero compound recognizer rules, zero linear
rules, and six replacement rules.


[ 0.0 0.0 0.0 ]

EFFECTS-OF-SETUP


(ADD-AXIOM ASSIGNMENT
           (REWRITE)
           (AND (EQUAL (I$2) (PATLEN$0))
                (AND (EQUAL (J$2) (J$1))
                     (AND (EQUAL (C$2) (C$1))
                          (AND (EQUAL (NEXTI$2) (NEXTI$1))
                               (AND (EQUAL (X$2) (X$1))
                                    (EQUAL (BLK-DELTA1$2)
                                           (BLK-DELTA1$1))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT is to be stored as zero type
prescription rules, zero compound recognizer rules, zero linear rules, and six
replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT


(PROVE-LEMMA OUTER-INVRT NIL
 (IMPLIES
         (AND (PATLEN$0) (GLOBAL-HYPS))
         (AND (AND (NUMBERP (I$2))
                   (AND (NOT (LESSP (I$2) (PATLEN$0)))
                        (AND (LESSP (I$2)
                                    (PLUS (PATLEN$0)
                                          (SEARCH (PAT$0)
                                                  (STR$0)
                                                  (PATLEN$0)
                                                  (STRLEN$0)
                                                  '1)))
                             (IMPLIES (AND (NUMBERP C)
                                           (AND (NOT (EQUAL C '0))
                                                (NOT (LESSP (ASIZE&) C))))
                                      (EQUAL (ELT1 (BLK-DELTA1$2) C)
                                             (DELTA1 (PAT$0) C (PATLEN$0)))))))
              (LEX (CONS (DIFFERENCE (PLUS '1
                                           (PLUS (STRLEN$0) (PATLEN$0)))
                                     (I$2))
                         (CONS (ADD1 (PATLEN$0)) 'NIL))
                   (CONS (PLUS '1
                               (PLUS (STRLEN$0) (PATLEN$0)))
                         (CONS (ADD1 (PATLEN$0)) 'NIL))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS, AND,
IMPLIES, and ASSIGNMENT, to:

      (IMPLIES (AND (PATLEN$0)
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0)))
               (AND (AND (NUMBERP (PATLEN$0))
                         (NOT (LESSP (PATLEN$0) (PATLEN$0)))
                         (LESSP (PATLEN$0)
                                (PLUS (PATLEN$0)
                                      (SEARCH (PAT$0)
                                              (STR$0)
                                              (PATLEN$0)
                                              (STRLEN$0)
                                              1)))
                         (IMPLIES (AND (NUMBERP C)
                                       (NOT (EQUAL C 0))
                                       (NOT (LESSP (ASIZE&) C)))
                                  (EQUAL (ELT1 (BLK-DELTA1$1) C)
                                         (DELTA1 (PAT$0) C (PATLEN$0)))))
                    (LEX (LIST (DIFFERENCE (PLUS 1 (STRLEN$0) (PATLEN$0))
                                           (PATLEN$0))
                               (ADD1 (PATLEN$0)))
                         (LIST (PLUS 1 (STRLEN$0) (PATLEN$0))
                               (ADD1 (PATLEN$0)))))).

This simplifies, rewriting with the lemmas SUB1-ADD1, COMMUTATIVITY-OF-PLUS,
CDR-CONS, and CAR-CONS, and opening up the functions LESSP, EQUAL, NOT, AND,
IMPLIES, SUB1, NUMBERP, PLUS, DIFFERENCE, and LEX, to the following four new
conjectures:

Case 4. (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                              (SUB1 (PATLEN$0)))
                                  0)))
                 (LESSP (SUB1 (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                          (SUB1 (PATLEN$0))))
                        (PLUS (PATLEN$0) (STRLEN$0)))).

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

  Case 4.2.
          (IMPLIES (AND (NOT (LESSP (SUB1 (PATLEN$0))
                                    (PLUS (PATLEN$0) (STRLEN$0))))
                        (NOT (EQUAL (ASIZE&) 0))
                        (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                    0))
                        (LESSP (ASIZE&)
                               (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                        (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                        (NOT (EQUAL (PATLEN$0) 0))
                        (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                        (NOT (EQUAL (STRLEN$0) 0))
                        (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                               (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                        (NUMBERP (PATLEN$0))
                        (NUMBERP (STRLEN$0))
                        (NOT (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                                (SUB1 (PATLEN$0)))
                                    0)))
                   (LESSP (SUB1 (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                            (SUB1 (PATLEN$0))))
                          (PLUS (PATLEN$0) (STRLEN$0)))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 4.1.
          (IMPLIES (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                               (SUB1 (PATLEN$0)))
                        (NOT (EQUAL (ASIZE&) 0))
                        (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                    0))
                        (LESSP (ASIZE&)
                               (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                        (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                        (NOT (EQUAL (PATLEN$0) 0))
                        (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                        (NOT (EQUAL (STRLEN$0) 0))
                        (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                               (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                        (NUMBERP (PATLEN$0))
                        (NUMBERP (STRLEN$0))
                        (NOT (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                                (SUB1 (PATLEN$0)))
                                    0)))
                   (LESSP (SUB1 (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                            (SUB1 (PATLEN$0))))
                          (PLUS (PATLEN$0) (STRLEN$0)))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 3. (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$1) C)
                        (DELTA1 (PAT$0) C (PATLEN$0)))),

  which again simplifies, applying the lemma EFFECTS-OF-SETUP, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0)))
                 (LESSP (PATLEN$0)
                        (PLUS (PATLEN$0)
                              (SEARCH (PAT$0)
                                      (STR$0)
                                      (PATLEN$0)
                                      (STRLEN$0)
                                      1)))),

  which again simplifies, using linear arithmetic, rewriting with
  SEARCH-NON-ZERO, and expanding EQUAL, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0)))
                 (NOT (LESSP (PATLEN$0) (PATLEN$0)))).

  However this again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

OUTER-INVRT


(UBT INPUT)

INPUT


(ADD-AXIOM PATHS-FROM-OUTER-INVRT
           (REWRITE)
           (IMPLIES (AND (NUMBERP C)
                         (AND (NOT (EQUAL C '0))
                              (NOT (LESSP (ASIZE&) C))))
                    (EQUAL (ELT1 (BLK-DELTA1$1) C)
                           (DELTA1 (PAT$0) C (PATLEN$0)))))

[ 0.0 0.0 0.0 ]

PATHS-FROM-OUTER-INVRT


(DEFN PATH-HYPS NIL
      (AND (GLOBAL-HYPS)
           (AND (NUMBERP (I$1))
                (AND (NOT (LESSP (I$1) (PATLEN$0)))
                     (LESSP (I$1)
                            (PLUS (PATLEN$0)
                                  (SEARCH (PAT$0)
                                          (STR$0)
                                          (PATLEN$0)
                                          (STRLEN$0)
                                          '1)))))))

     Note that (OR (FALSEP (PATH-HYPS)) (TRUEP (PATH-HYPS))) is a theorem.




[ 0.0 0.0 0.0 ]

PATH-HYPS


(PROVE-LEMMA DEFINEDNESS NIL
             (IMPLIES (PATH-HYPS)
                      (ZNUMBERP (I$1))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATH-HYPS, and IMPLIES, to:

      T,

which simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS


(ADD-AXIOM LOGICAL-IF-T NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-T


(PROVE-LEMMA INPUT-COND-OF-ZPLUS NIL
             (IMPLIES (AND (ZGREATERP (I$1) (STRLEN$0))
                           (PATH-HYPS))
                      (EXPRESSIBLE-ZNUMBERP (ZPLUS (STRLEN$0) '1))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, AND, IMPLIES, and ZGREATERP, to:

      (IMPLIES (AND (ZLESSP (STRLEN$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NUMBERP (I$1))
                    (NOT (LESSP (I$1) (PATLEN$0)))
                    (LESSP (I$1)
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1))))
               (EXPRESSIBLE-ZNUMBERP (ZPLUS (STRLEN$0) 1))).

This simplifies, applying SUB1-ADD1 and COMMUTATIVITY-OF-PLUS, and expanding
ZLESSP, LESSP, EQUAL, PLUS, NUMBERP, SUB1, NEGATIVEP, ZPLUS, and
EXPRESSIBLE-ZNUMBERP, to:

      (IMPLIES (AND (LESSP (STRLEN$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (NOT (EQUAL (PATLEN$0) 0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (NOT (EQUAL (STRLEN$0) 0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NUMBERP (I$1))
                    (NOT (LESSP (I$1) (PATLEN$0)))
                    (LESSP (I$1)
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1))))
               (LESSP (STRLEN$0)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))).

But this again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

INPUT-COND-OF-ZPLUS


(ADD-AXIOM ASSIGNMENT1
           (REWRITE)
           (AND (EQUAL (I$2) (I$1))
                (AND (EQUAL (J$2) (J$1))
                     (AND (EQUAL (C$2) (C$1))
                          (AND (EQUAL (NEXTI$2) (NEXTI$1))
                               (AND (EQUAL (X$2) (ZPLUS (STRLEN$0) '1))
                                    (EQUAL (BLK-DELTA1$2)
                                           (BLK-DELTA1$1))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT1 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT1


(PROVE-LEMMA OUTPUT NIL
             (IMPLIES (AND (ZGREATERP (I$1) (STRLEN$0))
                           (PATH-HYPS))
                      (EQUAL (X$2)
                             (SEARCH (PAT$0)
                                     (STR$0)
                                     (PATLEN$0)
                                     (STRLEN$0)
                                     '1))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, AND, IMPLIES, ASSIGNMENT1, and ZGREATERP, to:

      (IMPLIES (AND (ZLESSP (STRLEN$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NUMBERP (I$1))
                    (NOT (LESSP (I$1) (PATLEN$0)))
                    (LESSP (I$1)
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1))))
               (EQUAL (ZPLUS (STRLEN$0) 1)
                      (SEARCH (PAT$0)
                              (STR$0)
                              (PATLEN$0)
                              (STRLEN$0)
                              1))).

This simplifies, rewriting with the lemmas SUB1-ADD1 and COMMUTATIVITY-OF-PLUS,
and opening up the functions ZLESSP, LESSP, EQUAL, PLUS, NUMBERP, SUB1,
NEGATIVEP, and ZPLUS, to:

      (IMPLIES (AND (LESSP (STRLEN$0) (I$1))
                    (NOT (EQUAL (ASIZE&) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (NOT (EQUAL (PATLEN$0) 0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (NOT (EQUAL (STRLEN$0) 0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NUMBERP (I$1))
                    (NOT (LESSP (I$1) (PATLEN$0)))
                    (LESSP (I$1)
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1))))
               (EQUAL (ADD1 (STRLEN$0))
                      (SEARCH (PAT$0)
                              (STR$0)
                              (PATLEN$0)
                              (STRLEN$0)
                              1))),

which again simplifies, using linear arithmetic and rewriting with
SEARCH-BOUNDARY, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

OUTPUT


(UBT LOGICAL-IF-T)

LOGICAL-IF-T


(ADD-AXIOM LOGICAL-IF-F NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-F


(ADD-AXIOM ASSIGNMENT1
           (REWRITE)
           (AND (EQUAL (I$2) (I$1))
                (AND (EQUAL (J$2) (PATLEN$0))
                     (AND (EQUAL (C$2) (C$1))
                          (AND (EQUAL (NEXTI$2) (NEXTI$1))
                               (AND (EQUAL (X$2) (X$1))
                                    (EQUAL (BLK-DELTA1$2)
                                           (BLK-DELTA1$1))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT1 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT1


(PROVE-LEMMA INPUT-COND-OF-ZPLUS NIL
             (IMPLIES (AND (NOT (ZGREATERP (I$1) (STRLEN$0)))
                           (PATH-HYPS))
                      (EXPRESSIBLE-ZNUMBERP (ZPLUS '1 (I$2)))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, NOT, AND, IMPLIES, ASSIGNMENT1, and ZGREATERP, to:

      (IMPLIES (AND (NOT (ZLESSP (STRLEN$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NUMBERP (I$1))
                    (NOT (LESSP (I$1) (PATLEN$0)))
                    (LESSP (I$1)
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1))))
               (EXPRESSIBLE-ZNUMBERP (ZPLUS 1 (I$1)))).

This simplifies, applying SUB1-ADD1, and opening up the definitions of ZLESSP,
LESSP, EQUAL, PLUS, NUMBERP, SUB1, NEGATIVEP, ZPLUS, and EXPRESSIBLE-ZNUMBERP,
to:

      (IMPLIES (AND (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (NOT (EQUAL (PATLEN$0) 0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (NOT (EQUAL (STRLEN$0) 0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NUMBERP (I$1))
                    (NOT (LESSP (I$1) (PATLEN$0)))
                    (LESSP (I$1)
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1))))
               (LESSP (I$1)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))).

But this again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

INPUT-COND-OF-ZPLUS


(ADD-AXIOM ASSIGNMENT2
           (REWRITE)
           (AND (EQUAL (I$3) (I$2))
                (AND (EQUAL (J$3) (J$2))
                     (AND (EQUAL (C$3) (C$2))
                          (AND (EQUAL (NEXTI$3) (ZPLUS '1 (I$2)))
                               (AND (EQUAL (X$3) (X$2))
                                    (EQUAL (BLK-DELTA1$3)
                                           (BLK-DELTA1$2))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT2 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT2


(PROVE-LEMMA INNER-INVRT NIL
 (IMPLIES
  (AND (NOT (ZGREATERP (I$1) (STRLEN$0)))
       (PATH-HYPS))
  (AND
   (AND
    (NOT (LESSP (NEXTI$3) (ADD1 (PATLEN$0))))
    (AND
     (LESSP (NEXTI$3)
            (ADD1 (PLUS (PATLEN$0)
                        (SEARCH (PAT$0)
                                (STR$0)
                                (PATLEN$0)
                                (STRLEN$0)
                                '1))))
     (AND
      (IMPLIES (AND (NUMBERP C)
                    (AND (NOT (EQUAL C '0))
                         (NOT (LESSP (ASIZE&) C))))
               (EQUAL (ELT1 (BLK-DELTA1$3) C)
                      (DELTA1 (PAT$0) C (PATLEN$0))))
      (AND
       (NUMBERP (I$3))
       (AND
        (NOT (EQUAL (I$3) '0))
        (AND
         (NUMBERP (J$3))
         (AND
          (NOT (EQUAL (J$3) '0))
          (AND
           (NUMBERP (NEXTI$3))
           (AND
            (NOT (LESSP (PATLEN$0) (J$3)))
            (AND
             (NOT (LESSP (STRLEN$0) (I$3)))
             (AND
              (EQUAL (NEXTI$3)
                     (PLUS (ADD1 (PATLEN$0))
                           (DIFFERENCE (I$3) (J$3))))
              (AND
               (NOT (LESSP (ADD1 (STRLEN$0)) (NEXTI$3)))
               (AND
                  (NOT (LESSP (I$3) (J$3)))
                  (AND (MATCH (PAT$0)
                              (ADD1 (J$3))
                              (PATLEN$0)
                              (STR$0)
                              (ADD1 (I$3))
                              (STRLEN$0))
                       (AND (NUMBERP (ELT1 (BLK-DELTA1$3)
                                           (ELT1 (STR$0) (I$3))))
                            (AND (NUMBERP (ELT1 (STR$0) (I$3)))
                                 (NUMBERP (ELT1 (PAT$0) (J$3)))))))))))))))))))
   (LEX (CONS (DIFFERENCE (PLUS '1
                                (PLUS (STRLEN$0) (PATLEN$0)))
                          (SUB1 (NEXTI$3)))
              (CONS (J$3) 'NIL))
        (CONS (DIFFERENCE (PLUS '1
                                (PLUS (STRLEN$0) (PATLEN$0)))
                          (I$1))
              (CONS (ADD1 (PATLEN$0)) 'NIL))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, NOT, AND, IMPLIES, ASSIGNMENT1, ASSIGNMENT2, and ZGREATERP, to:

      (IMPLIES (AND (NOT (ZLESSP (STRLEN$0) (I$1)))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NUMBERP (I$1))
                    (NOT (LESSP (I$1) (PATLEN$0)))
                    (LESSP (I$1)
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1))))
               (AND (AND (NOT (LESSP (ZPLUS 1 (I$1))
                                     (ADD1 (PATLEN$0))))
                         (LESSP (ZPLUS 1 (I$1))
                                (ADD1 (PLUS (PATLEN$0)
                                            (SEARCH (PAT$0)
                                                    (STR$0)
                                                    (PATLEN$0)
                                                    (STRLEN$0)
                                                    1))))
                         (IMPLIES (AND (NUMBERP C)
                                       (NOT (EQUAL C 0))
                                       (NOT (LESSP (ASIZE&) C)))
                                  (EQUAL (ELT1 (BLK-DELTA1$1) C)
                                         (DELTA1 (PAT$0) C (PATLEN$0))))
                         (NUMBERP (I$1))
                         (NOT (EQUAL (I$1) 0))
                         (NUMBERP (PATLEN$0))
                         (NOT (EQUAL (PATLEN$0) 0))
                         (NUMBERP (ZPLUS 1 (I$1)))
                         (NOT (LESSP (PATLEN$0) (PATLEN$0)))
                         (NOT (LESSP (STRLEN$0) (I$1)))
                         (EQUAL (ZPLUS 1 (I$1))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (PATLEN$0))))
                         (NOT (LESSP (ADD1 (STRLEN$0))
                                     (ZPLUS 1 (I$1))))
                         (NOT (LESSP (I$1) (PATLEN$0)))
                         (MATCH (PAT$0)
                                (ADD1 (PATLEN$0))
                                (PATLEN$0)
                                (STR$0)
                                (ADD1 (I$1))
                                (STRLEN$0))
                         (NUMBERP (ELT1 (BLK-DELTA1$1)
                                        (ELT1 (STR$0) (I$1))))
                         (NUMBERP (ELT1 (STR$0) (I$1)))
                         (NUMBERP (ELT1 (PAT$0) (PATLEN$0))))
                    (LEX (LIST (DIFFERENCE (PLUS 1 (STRLEN$0) (PATLEN$0))
                                           (SUB1 (ZPLUS 1 (I$1))))
                               (PATLEN$0))
                         (LIST (DIFFERENCE (PLUS 1 (STRLEN$0) (PATLEN$0))
                                           (I$1))
                               (ADD1 (PATLEN$0)))))).

This simplifies, using linear arithmetic, rewriting with SUB1-ADD1, ADD1-EQUAL,
MATCH-AT-PATLEN, STRINGP-IS-A-UNIV-QUANTIFIER, PATHS-FROM-OUTER-INVRT,
COMMUTATIVITY-OF-PLUS, CDR-CONS, and CAR-CONS, and opening up ZLESSP, LESSP,
EQUAL, PLUS, NUMBERP, SUB1, NEGATIVEP, ZPLUS, NOT, AND, IMPLIES, DIFFERENCE,
and LEX, to five new conjectures:

Case 5. (IMPLIES (AND (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NUMBERP (I$1))
                      (NOT (LESSP (I$1) (PATLEN$0)))
                      (LESSP (I$1)
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                              (SUB1 (I$1)))
                                  (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                              (SUB1 (I$1))))))
                 (LESSP (SUB1 (PATLEN$0)) (PATLEN$0))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 4. (IMPLIES (AND (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NUMBERP (I$1))
                      (NOT (LESSP (I$1) (PATLEN$0)))
                      (LESSP (I$1)
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1))))
                 (EQUAL (I$1)
                        (PLUS (PATLEN$0)
                              (DIFFERENCE (I$1) (PATLEN$0))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES (AND (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NUMBERP (I$1))
                      (NOT (LESSP (I$1) (PATLEN$0)))
                      (LESSP (I$1)
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1))))
                 (NOT (LESSP (PATLEN$0) (PATLEN$0)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NUMBERP (I$1))
                      (NOT (LESSP (I$1) (PATLEN$0)))
                      (LESSP (I$1)
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$1) C)
                        (DELTA1 (PAT$0) C (PATLEN$0)))),

  which again simplifies, rewriting with the lemma PATHS-FROM-OUTER-INVRT, to:

        T.

Case 1. (IMPLIES (AND (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NUMBERP (I$1))
                      (NOT (LESSP (I$1) (PATLEN$0)))
                      (LESSP (I$1)
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1))))
                 (NOT (EQUAL (I$1) 0))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.2 0.0 ]

INNER-INVRT


(UBT PATHS-FROM-OUTER-INVRT)

PATHS-FROM-OUTER-INVRT


(ADD-AXIOM PATHS-FROM-INNER-INVRT
           (REWRITE)
           (AND (IMPLIES (AND (NUMBERP C)
                              (AND (NOT (EQUAL C '0))
                                   (NOT (LESSP (ASIZE&) C))))
                         (EQUAL (ELT1 (BLK-DELTA1$1) C)
                                (DELTA1 (PAT$0) C (PATLEN$0))))
                (EQUAL (NEXTI$1)
                       (PLUS (ADD1 (PATLEN$0))
                             (DIFFERENCE (I$1) (J$1))))))

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


[ 0.0 0.0 0.0 ]

PATHS-FROM-INNER-INVRT


(DEFN PATH-HYPS NIL
 (AND
  (GLOBAL-HYPS)
  (AND
   (NOT (LESSP (NEXTI$1) (ADD1 (PATLEN$0))))
   (AND
    (LESSP (NEXTI$1)
           (ADD1 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               '1))))
    (AND
     (NUMBERP (I$1))
     (AND
      (NOT (EQUAL (I$1) '0))
      (AND
       (NUMBERP (J$1))
       (AND
        (NOT (EQUAL (J$1) '0))
        (AND
         (NUMBERP (NEXTI$1))
         (AND
          (NOT (LESSP (PATLEN$0) (J$1)))
          (AND
           (NOT (LESSP (STRLEN$0) (I$1)))
           (AND
             (NOT (LESSP (ADD1 (STRLEN$0)) (NEXTI$1)))
             (AND (NOT (LESSP (I$1) (J$1)))
                  (AND (MATCH (PAT$0)
                              (ADD1 (J$1))
                              (PATLEN$0)
                              (STR$0)
                              (ADD1 (I$1))
                              (STRLEN$0))
                       (AND (NUMBERP (ELT1 (BLK-DELTA1$1)
                                           (ELT1 (STR$0) (I$1))))
                            (AND (NUMBERP (ELT1 (STR$0) (I$1)))
                                 (NUMBERP (ELT1 (PAT$0) (J$1)))))))))))))))))))

     Note that (OR (FALSEP (PATH-HYPS)) (TRUEP (PATH-HYPS))) is a theorem.




[ 0.0 0.0 0.0 ]

PATH-HYPS


(PROVE-LEMMA ARRAY-BOUNDS-CHECK-FOR-STR NIL
             (IMPLIES (PATH-HYPS)
                      (AND (LESSP '0 (I$1))
                           (NOT (LESSP (STRLEN$0) (I$1))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, and IMPLIES, to:

      (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))
                                (ADD1 (PATLEN$0))))
                    (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PLUS (PATLEN$0)
                                       (SEARCH (PAT$0)
                                               (STR$0)
                                               (PATLEN$0)
                                               (STRLEN$0)
                                               1))))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1))))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (ADD1 (STRLEN$0))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0))
                    (NUMBERP (ELT1 (BLK-DELTA1$1)
                                   (ELT1 (STR$0) (I$1))))
                    (NUMBERP (ELT1 (STR$0) (I$1)))
                    (NUMBERP (ELT1 (PAT$0) (J$1))))
               (AND (LESSP 0 (I$1))
                    (NOT (LESSP (STRLEN$0) (I$1))))).

This simplifies, using linear arithmetic, applying SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, and PATHS-FROM-INNER-INVRT, and expanding LESSP,
EQUAL, PLUS, NOT, and AND, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

ARRAY-BOUNDS-CHECK-FOR-STR


(PROVE-LEMMA DEFINEDNESS NIL
             (IMPLIES (PATH-HYPS)
                      (ZNUMBERP (ELT1 (STR$0) (I$1)))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, and IMPLIES, to the new conjecture:

      T,

which simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS


(ADD-AXIOM ASSIGNMENT1
           (REWRITE)
           (AND (EQUAL (I$2) (I$1))
                (AND (EQUAL (J$2) (J$1))
                     (AND (EQUAL (C$2) (ELT1 (STR$0) (I$1)))
                          (AND (EQUAL (NEXTI$2) (NEXTI$1))
                               (AND (EQUAL (X$2) (X$1))
                                    (EQUAL (BLK-DELTA1$2)
                                           (BLK-DELTA1$1))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT1 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT1


(PROVE-LEMMA ARRAY-BOUNDS-CHECK-FOR-PAT NIL
             (IMPLIES (PATH-HYPS)
                      (AND (LESSP '0 (J$2))
                           (NOT (LESSP (PATLEN$0) (J$2))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, IMPLIES, and ASSIGNMENT1, to:

      (IMPLIES (AND (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))
                                (ADD1 (PATLEN$0))))
                    (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PLUS (PATLEN$0)
                                       (SEARCH (PAT$0)
                                               (STR$0)
                                               (PATLEN$0)
                                               (STRLEN$0)
                                               1))))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1))))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (ADD1 (STRLEN$0))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0))
                    (NUMBERP (ELT1 (BLK-DELTA1$1)
                                   (ELT1 (STR$0) (I$1))))
                    (NUMBERP (ELT1 (STR$0) (I$1)))
                    (NUMBERP (ELT1 (PAT$0) (J$1))))
               (AND (LESSP 0 (J$1))
                    (NOT (LESSP (PATLEN$0) (J$1))))).

This simplifies, using linear arithmetic, applying SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, and PATHS-FROM-INNER-INVRT, and expanding LESSP,
EQUAL, PLUS, NOT, and AND, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

ARRAY-BOUNDS-CHECK-FOR-PAT


(PROVE-LEMMA DEFINEDNESS1 NIL
             (IMPLIES (PATH-HYPS)
                      (ZNUMBERP (ELT1 (PAT$0) (J$2)))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, IMPLIES, and ASSIGNMENT1, to the new
conjecture:

      T,

which simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS1


(ADD-AXIOM LOGICAL-IF-T NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-T


(PROVE-LEMMA ARRAY-BOUNDS-CHECK-FOR-DELTA1 NIL
             (IMPLIES (AND (ZNEQP (C$2) (ELT1 (PAT$0) (J$2)))
                           (PATH-HYPS))
                      (AND (LESSP '0 (C$2))
                           (NOT (LESSP (ASIZE&) (C$2))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, ZEQP, ZNEQP, AND, IMPLIES, and ASSIGNMENT1,
to:

      (IMPLIES (AND (NOT (EQUAL (ZNORMALIZE (ELT1 (STR$0) (I$1)))
                                (ZNORMALIZE (ELT1 (PAT$0) (J$1)))))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))
                                (ADD1 (PATLEN$0))))
                    (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PLUS (PATLEN$0)
                                       (SEARCH (PAT$0)
                                               (STR$0)
                                               (PATLEN$0)
                                               (STRLEN$0)
                                               1))))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1))))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (ADD1 (STRLEN$0))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0))
                    (NUMBERP (ELT1 (BLK-DELTA1$1)
                                   (ELT1 (STR$0) (I$1))))
                    (NUMBERP (ELT1 (STR$0) (I$1)))
                    (NUMBERP (ELT1 (PAT$0) (J$1))))
               (AND (LESSP 0 (ELT1 (STR$0) (I$1)))
                    (NOT (LESSP (ASIZE&)
                                (ELT1 (STR$0) (I$1)))))).

This simplifies, using linear arithmetic, applying the lemmas SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, and PATHS-FROM-INNER-INVRT, and opening up
ZNORMALIZE, LESSP, EQUAL, PLUS, NOT, and AND, to:

      (IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                (ELT1 (PAT$0) (J$1))))
                    (NOT (EQUAL (ASIZE&) 0))
                    (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                0))
                    (LESSP (ASIZE&)
                           (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (NOT (EQUAL (PATLEN$0) 0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (NOT (EQUAL (STRLEN$0) 0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (PATLEN$0)
                                      (DIFFERENCE (I$1) (J$1)))
                                (PATLEN$0)))
                    (LESSP (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1)))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (STRLEN$0)
                                (PLUS (PATLEN$0)
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0)))
               (NOT (LESSP (ASIZE&)
                           (ELT1 (STR$0) (I$1))))),

which again simplifies, using linear arithmetic and applying
STRINGP-IS-A-UNIV-QUANTIFIER, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

ARRAY-BOUNDS-CHECK-FOR-DELTA1


(PROVE-LEMMA DEFINEDNESS2 NIL
             (IMPLIES (AND (ZNEQP (C$2) (ELT1 (PAT$0) (J$2)))
                           (PATH-HYPS))
                      (ZNUMBERP (ELT1 (BLK-DELTA1$2) (C$2)))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, ZEQP, ZNEQP, AND, IMPLIES, and ASSIGNMENT1,
to the new conjecture:

      T,

which simplifies, clearly, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS2


(PROVE-LEMMA INPUT-COND-OF-ZPLUS NIL
          (IMPLIES (AND (ZNEQP (C$2) (ELT1 (PAT$0) (J$2)))
                        (PATH-HYPS))
                   (EXPRESSIBLE-ZNUMBERP (ZPLUS (I$2)
                                                (ELT1 (BLK-DELTA1$2) (C$2))))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, ZEQP, ZNEQP, AND, IMPLIES, and ASSIGNMENT1,
to:

      (IMPLIES (AND (NOT (EQUAL (ZNORMALIZE (ELT1 (STR$0) (I$1)))
                                (ZNORMALIZE (ELT1 (PAT$0) (J$1)))))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))
                                (ADD1 (PATLEN$0))))
                    (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PLUS (PATLEN$0)
                                       (SEARCH (PAT$0)
                                               (STR$0)
                                               (PATLEN$0)
                                               (STRLEN$0)
                                               1))))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1))))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (ADD1 (STRLEN$0))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0))
                    (NUMBERP (ELT1 (BLK-DELTA1$1)
                                   (ELT1 (STR$0) (I$1))))
                    (NUMBERP (ELT1 (STR$0) (I$1)))
                    (NUMBERP (ELT1 (PAT$0) (J$1))))
               (EXPRESSIBLE-ZNUMBERP (ZPLUS (I$1)
                                            (ELT1 (BLK-DELTA1$1)
                                                  (ELT1 (STR$0) (I$1)))))),

which simplifies, using linear arithmetic, rewriting with SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, and PATHS-FROM-INNER-INVRT, and unfolding
ZNORMALIZE, LESSP, EQUAL, PLUS, ZPLUS, ZLESSP, and EXPRESSIBLE-ZNUMBERP, to
the following two new conjectures:

Case 2. (IMPLIES
          (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                           (ELT1 (PAT$0) (J$1))))
               (NOT (EQUAL (ASIZE&) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (NOT (EQUAL (PATLEN$0) 0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (NOT (EQUAL (STRLEN$0) 0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))
                           (PATLEN$0)))
               (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PLUS (PATLEN$0)
                            (SEARCH (PAT$0)
                                    (STR$0)
                                    (PATLEN$0)
                                    (STRLEN$0)
                                    1)))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (STRLEN$0)
                           (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (EQUAL (NEGATIVE-GUTS (GREATEST-INEXPRESSIBLE-NEGATIVE-INTEGER))
                      0))
          (NOT (EQUAL (PLUS (I$1)
                            (DELTA1 (PAT$0)
                                    (ELT1 (STR$0) (I$1))
                                    (PATLEN$0)))
                      0))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (LESSP (PLUS (I$1)
                              (DELTA1 (PAT$0)
                                      (ELT1 (STR$0) (I$1))
                                      (PATLEN$0)))
                        (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))),

  which again simplifies, using linear arithmetic and rewriting with
  DELTA1-LESSEQP-PATLEN, to:

        T.

Q.E.D.


[ 0.0 0.2 0.0 ]

INPUT-COND-OF-ZPLUS


(PROVE-LEMMA DEFINEDNESS3 NIL
             (IMPLIES (AND (ZNEQP (C$2) (ELT1 (PAT$0) (J$2)))
                           (PATH-HYPS))
                      (ZNUMBERP (NEXTI$2))))

This formula can be simplified, using the abbreviations ZNUMBERP, GLOBAL-HYPS,
PATH-HYPS, ZEQP, ZNEQP, AND, IMPLIES, PATHS-FROM-INNER-INVRT, and ASSIGNMENT1,
to:

      T,

which simplifies, obviously, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DEFINEDNESS3


(ADD-AXIOM ASSIGNMENT2
           (REWRITE)
           (AND (EQUAL (I$3)
                       (MAX0 (ZPLUS (I$2)
                                    (ELT1 (BLK-DELTA1$2) (C$2)))
                             (NEXTI$2)))
                (AND (EQUAL (J$3) (J$2))
                     (AND (EQUAL (C$3) (C$2))
                          (AND (EQUAL (NEXTI$3) (NEXTI$2))
                               (AND (EQUAL (X$3) (X$2))
                                    (EQUAL (BLK-DELTA1$3)
                                           (BLK-DELTA1$2))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT2 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT2


(PROVE-LEMMA DELTA1-PLUS-J-LESSEQP-PATLEN
             (REWRITE)
             (IMPLIES (AND (NUMBERP J)
                           (NOT (EQUAL J 0))
                           (NOT (LESSP PATLEN J)))
                      (NOT (LESSP PATLEN
                                  (PLUS J
                                        (DELTA1 PAT (ELT1 PAT J) PATLEN))))))

WARNING:  Note that the proposed lemma DELTA1-PLUS-J-LESSEQP-PATLEN is to be
stored as zero type prescription rules, zero compound recognizer rules, one
linear rule, and zero replacement rules.



     Name 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 (OR (EQUAL (PLUS J
                                 (DELTA1 PAT (ELT1 PAT J) PATLEN))
                           0)
                    (NOT (NUMBERP (PLUS J
                                        (DELTA1 PAT (ELT1 PAT J) PATLEN)))))
                (p PATLEN J PAT))
       (IMPLIES
        (AND (NOT (OR (EQUAL (PLUS J
                                   (DELTA1 PAT (ELT1 PAT J) PATLEN))
                             0)
                      (NOT (NUMBERP (PLUS J
                                          (DELTA1 PAT (ELT1 PAT J) PATLEN))))))
             (OR (EQUAL PATLEN 0)
                 (NOT (NUMBERP PATLEN))))
        (p PATLEN J PAT))
       (IMPLIES
        (AND (NOT (OR (EQUAL (PLUS J
                                   (DELTA1 PAT (ELT1 PAT J) PATLEN))
                             0)
                      (NOT (NUMBERP (PLUS J
                                          (DELTA1 PAT (ELT1 PAT J) PATLEN))))))
             (NOT (OR (EQUAL PATLEN 0)
                      (NOT (NUMBERP PATLEN))))
             (p (SUB1 PATLEN) J PAT))
        (p PATLEN J PAT))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT establish that the measure (COUNT PATLEN) decreases according to
the well-founded relation LESSP in each induction step of the scheme.  The
above induction scheme leads to four new formulas:

Case 4. (IMPLIES
              (AND (OR (EQUAL (PLUS J
                                    (DELTA1 PAT (ELT1 PAT J) PATLEN))
                              0)
                       (NOT (NUMBERP (PLUS J
                                           (DELTA1 PAT (ELT1 PAT J) PATLEN)))))
                   (NUMBERP J)
                   (NOT (EQUAL J 0))
                   (NOT (LESSP PATLEN J)))
              (NOT (LESSP PATLEN
                          (PLUS J
                                (DELTA1 PAT (ELT1 PAT J) PATLEN))))),

  which simplifies, rewriting with PLUS-ADD1, SUB1-ADD1, and
  COMMUTATIVITY-OF-PLUS, and opening up DELTA1, NOT, OR, LESSP, EQUAL, and
  PLUS, to the new formula:

        (IMPLIES (AND (NOT (EQUAL PATLEN 0))
                      (NUMBERP PATLEN)
                      (NOT (EQUAL (ELT1 PAT J)
                                  (ELT1 PAT PATLEN)))
                      (EQUAL (PLUS J
                                   (ADD1 (DELTA1 PAT
                                                 (ELT1 PAT J)
                                                 (SUB1 PATLEN))))
                             0)
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NOT (LESSP PATLEN J)))
                 (NOT (LESSP (SUB1 PATLEN)
                             (PLUS J
                                   (DELTA1 PAT
                                           (ELT1 PAT J)
                                           (SUB1 PATLEN)))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES
         (AND
             (NOT (OR (EQUAL (PLUS J
                                   (DELTA1 PAT (ELT1 PAT J) PATLEN))
                             0)
                      (NOT (NUMBERP (PLUS J
                                          (DELTA1 PAT (ELT1 PAT J) PATLEN))))))
             (OR (EQUAL PATLEN 0)
                 (NOT (NUMBERP PATLEN)))
             (NUMBERP J)
             (NOT (EQUAL J 0))
             (NOT (LESSP PATLEN J)))
         (NOT (LESSP PATLEN
                     (PLUS J
                           (DELTA1 PAT (ELT1 PAT J) PATLEN))))),

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

        T.

Case 2. (IMPLIES
         (AND
             (NOT (OR (EQUAL (PLUS J
                                   (DELTA1 PAT (ELT1 PAT J) PATLEN))
                             0)
                      (NOT (NUMBERP (PLUS J
                                          (DELTA1 PAT (ELT1 PAT J) PATLEN))))))
             (NOT (OR (EQUAL PATLEN 0)
                      (NOT (NUMBERP PATLEN))))
             (LESSP (SUB1 PATLEN) J)
             (NUMBERP J)
             (NOT (EQUAL J 0))
             (NOT (LESSP PATLEN J)))
         (NOT (LESSP PATLEN
                     (PLUS J
                           (DELTA1 PAT (ELT1 PAT J) PATLEN))))),

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

  Case 2.2.
          (IMPLIES
           (AND
             (NOT (NUMBERP PATLEN))
             (NOT (OR (EQUAL (PLUS J
                                   (DELTA1 PAT (ELT1 PAT J) PATLEN))
                             0)
                      (NOT (NUMBERP (PLUS J
                                          (DELTA1 PAT (ELT1 PAT J) PATLEN))))))
             (NOT (OR (EQUAL PATLEN 0)
                      (NOT (NUMBERP PATLEN))))
             (LESSP (SUB1 PATLEN) J)
             (NUMBERP J)
             (NOT (EQUAL J 0))
             (NOT (LESSP PATLEN J)))
           (NOT (LESSP PATLEN
                       (PLUS J
                             (DELTA1 PAT (ELT1 PAT J) PATLEN))))),

    which again simplifies, rewriting with COMMUTATIVITY-OF-PLUS, and
    unfolding the functions DELTA1, EQUAL, PLUS, NOT, and OR, to:

          T.

  Case 2.1.
          (IMPLIES
             (AND (NUMBERP PATLEN)
                  (NOT (OR (EQUAL (PLUS J (DELTA1 PAT (ELT1 PAT J) J))
                                  0)
                           (NOT (NUMBERP (PLUS J
                                               (DELTA1 PAT (ELT1 PAT J) J))))))
                  (NOT (OR (EQUAL J 0) (NOT (NUMBERP J))))
                  (LESSP (SUB1 J) J)
                  (NUMBERP J)
                  (NOT (EQUAL J 0))
                  (NOT (LESSP J J)))
             (NOT (LESSP J
                         (PLUS J
                               (DELTA1 PAT (ELT1 PAT J) J))))).

    This again simplifies, applying COMMUTATIVITY-OF-PLUS, and opening up
    DELTA1, EQUAL, PLUS, NOT, and OR, to:

          T.

Case 1. (IMPLIES
         (AND
             (NOT (OR (EQUAL (PLUS J
                                   (DELTA1 PAT (ELT1 PAT J) PATLEN))
                             0)
                      (NOT (NUMBERP (PLUS J
                                          (DELTA1 PAT (ELT1 PAT J) PATLEN))))))
             (NOT (OR (EQUAL PATLEN 0)
                      (NOT (NUMBERP PATLEN))))
             (NOT (LESSP (SUB1 PATLEN)
                         (PLUS J
                               (DELTA1 PAT
                                       (ELT1 PAT J)
                                       (SUB1 PATLEN)))))
             (NUMBERP J)
             (NOT (EQUAL J 0))
             (NOT (LESSP PATLEN J)))
         (NOT (LESSP PATLEN
                     (PLUS J
                           (DELTA1 PAT (ELT1 PAT J) PATLEN))))).

  This simplifies, applying PLUS-ADD1, SUB1-ADD1, and COMMUTATIVITY-OF-PLUS,
  and unfolding DELTA1, NOT, OR, LESSP, EQUAL, PLUS, and NUMBERP, to:

        T.


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


[ 0.0 0.0 0.0 ]

DELTA1-PLUS-J-LESSEQP-PATLEN


(PROVE-LEMMA DIFFERENCE-PLUS-ID
             (REWRITE)
             (EQUAL (DIFFERENCE (PLUS K J) J)
                    (FIX K)))

This conjecture simplifies, appealing to the lemma COMMUTATIVITY-OF-PLUS, and
expanding the function FIX, to the following two new goals:

Case 2. (IMPLIES (NOT (NUMBERP K))
                 (EQUAL (DIFFERENCE (PLUS J K) J) 0)).

  This again simplifies, rewriting with PLUS-NON-NUMBERP, to the following two
  new formulas:

  Case 2.2.
          (IMPLIES (AND (NOT (NUMBERP K))
                        (NOT (NUMBERP J)))
                   (EQUAL (DIFFERENCE 0 J) 0)).

    However this again simplifies, expanding the functions EQUAL and
    DIFFERENCE, to:

          T.

  Case 2.1.
          (IMPLIES (AND (NOT (NUMBERP K)) (NUMBERP J))
                   (EQUAL (DIFFERENCE J J) 0)),

    which again simplifies, using linear arithmetic, to:

          (IMPLIES (AND (LESSP J J)
                        (NOT (NUMBERP K))
                        (NUMBERP J))
                   (EQUAL (DIFFERENCE J J) 0)).

    But this again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES (NUMBERP K)
                 (EQUAL (DIFFERENCE (PLUS J K) J) K)),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP (PLUS J K) J) (NUMBERP K))
                 (EQUAL (DIFFERENCE (PLUS J K) J) K)).

  But this again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

DIFFERENCE-PLUS-ID


(PROVE-LEMMA MATCH-IMPLIES-EQ-CHARS
             (REWRITE)
             (IMPLIES (AND (MATCH PAT J PATLEN STR K STRLEN)
                           (NUMBERP K)
                           (NUMBERP J)
                           (NUMBERP PATLEN)
                           (NUMBERP STRLEN)
                           (NOT (LESSP STRLEN K))
                           (NOT (LESSP PATLEN J))
                           (NOT (EQUAL K 0))
                           (NOT (EQUAL J 0))
                           (NUMBERP L)
                           (NOT (LESSP L K))
                           (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                      (EQUAL (ELT1 STR L)
                             (ELT1 PAT
                                   (DIFFERENCE (PLUS J L) K)))))

WARNING:  Note that MATCH-IMPLIES-EQ-CHARS contains the free variables STRLEN,
K, PATLEN, J, and PAT which will be chosen by instantiating the hypothesis:
      (MATCH PAT J PATLEN STR K STRLEN).




     Name the conjecture *1.


     Let us appeal to the induction principle.  There are ten plausible
inductions.  They merge into three likely candidate inductions.  However, only
one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (LESSP PATLEN J)
                    (p STR L PAT J K PATLEN STRLEN))
           (IMPLIES (AND (NOT (LESSP PATLEN J))
                         (LESSP STRLEN K))
                    (p STR L PAT J K PATLEN STRLEN))
           (IMPLIES (AND (NOT (LESSP PATLEN J))
                         (NOT (LESSP STRLEN K))
                         (p STR L PAT
                            (ADD1 J)
                            (ADD1 K)
                            PATLEN STRLEN))
                    (p STR L PAT J K PATLEN STRLEN))).
Linear arithmetic can be used to prove that the measure:
      (DIFFERENCE (ADD1 PATLEN) J)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  Note, however, the inductive instance chosen for K.  The above
induction scheme generates the following eight new conjectures:

Case 8. (IMPLIES (AND (NOT (MATCH PAT
                                  (ADD1 J)
                                  PATLEN STR
                                  (ADD1 K)
                                  STRLEN))
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))).

  This simplifies, unfolding MATCH, to:

        T.

Case 7. (IMPLIES (AND (LESSP STRLEN (ADD1 K))
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))).

  This simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP K (ADD1 K))
                      (MATCH PAT J PATLEN STR K K)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP K)
                      (NOT (LESSP K K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))),

  which again simplifies, using linear arithmetic, applying SUB1-ADD1 and
  MATCH-AT-STRLEN, and expanding the functions LESSP, MATCH, NUMBERP, and
  EQUAL, to:

        (IMPLIES (AND (LESSP (SUB1 K) K)
                      (EQUAL (ELT1 PAT J) (ELT1 STR K))
                      (LESSP (SUB1 PATLEN) J)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP K)
                      (NOT (LESSP K K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP (SUB1 K) K)
                      (EQUAL (ELT1 PAT J) (ELT1 STR K))
                      (LESSP (SUB1 J) J)
                      (NUMBERP J)
                      (NUMBERP J)
                      (NUMBERP K)
                      (NOT (LESSP K K))
                      (NOT (LESSP J J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP K)
                      (NOT (LESSP K K))
                      (NOT (LESSP (PLUS K J) (PLUS J K))))
                 (EQUAL (ELT1 STR K)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J K) K)))).

  This again simplifies, appealing to the lemmas COMMUTATIVITY-OF-PLUS and
  DIFFERENCE-PLUS-ID, to:

        T.

Case 6. (IMPLIES (AND (LESSP PATLEN (ADD1 J))
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))),

  which simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP J (ADD1 J))
                      (MATCH PAT J J STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP J)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP J J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP K)
                      (NOT (LESSP K K))
                      (NOT (LESSP (PLUS K J) (PLUS J K))))
                 (EQUAL (ELT1 STR K)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J K) K)))).

  But this again simplifies, using linear arithmetic, applying SUB1-ADD1,
  MATCH-AT-PATLEN, COMMUTATIVITY-OF-PLUS, and DIFFERENCE-PLUS-ID, and
  expanding the definitions of LESSP and MATCH, to:

        T.

Case 5. (IMPLIES (AND (EQUAL (ADD1 K) 0)
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))).

  This simplifies, using linear arithmetic, to:

        T.

Case 4. (IMPLIES (AND (EQUAL (ADD1 J) 0)
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))).

  This simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES (AND (LESSP L (ADD1 K))
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))).

  This simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP K (ADD1 K))
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP K)
                      (NOT (LESSP K K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J K))))
                 (EQUAL (ELT1 STR K)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J K) K)))),

  which again simplifies, appealing to the lemmas SUB1-ADD1 and
  DIFFERENCE-PLUS-ID, and unfolding the functions LESSP and MATCH, to:

        T.

Case 2. (IMPLIES (AND (LESSP (PLUS (ADD1 K) PATLEN)
                             (PLUS (ADD1 J) L))
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))),

  which simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (ELT1 STR L)
                             (ELT1 PAT
                                   (DIFFERENCE (PLUS (ADD1 J) L)
                                               (ADD1 K))))
                      (MATCH PAT J PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NUMBERP J)
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP PATLEN J))
                      (NOT (EQUAL K 0))
                      (NOT (EQUAL J 0))
                      (NUMBERP L)
                      (NOT (LESSP L K))
                      (NOT (LESSP (PLUS K PATLEN) (PLUS J L))))
                 (EQUAL (ELT1 STR L)
                        (ELT1 PAT
                              (DIFFERENCE (PLUS J L) K)))),

  which simplifies, rewriting with COMMUTATIVITY-OF-PLUS, PLUS-ADD1, and
  SUB1-ADD1, and expanding the function DIFFERENCE, to:

        T.


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


[ 0.0 0.1 0.0 ]

MATCH-IMPLIES-EQ-CHARS


(PROVE-LEMMA NEQ-CHARS-IN-REGION-MEANS-SEARCH-SKIPS
             (REWRITE)
             (IMPLIES (AND (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                           (NUMBERP I)
                           (NOT (EQUAL I 0))
                           (NUMBERP STRLEN)
                           (NOT (LESSP STRLEN I))
                           (NUMBERP J)
                           (NOT (EQUAL J 0))
                           (NUMBERP PATLEN)
                           (NOT (LESSP PATLEN J))
                           (NOT (LESSP I J))
                           (NUMBERP K)
                           (NOT (EQUAL K 0))
                           (NOT (LESSP STRLEN K))
                           (NOT (LESSP (SUB1 (SEARCH PAT STR PATLEN STRLEN K))
                                       (DIFFERENCE I J))))
                      (LESSP (DIFFERENCE I J)
                             (SUB1 (SEARCH PAT STR PATLEN STRLEN K)))))

WARNING:  When the linear lemma NEQ-CHARS-IN-REGION-MEANS-SEARCH-SKIPS is
stored under (SEARCH PAT STR PATLEN STRLEN K) it contains the free variables J
and I which will be chosen by instantiating the hypothesis:
      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J))).



WARNING:  Note that the proposed lemma NEQ-CHARS-IN-REGION-MEANS-SEARCH-SKIPS
is to be stored as zero type prescription rules, zero compound recognizer
rules, one linear rule, and zero replacement rules.



     Give the conjecture the name *1.


     We will try to prove it by induction.  There are four plausible
inductions.  They merge into two likely candidate inductions.  However, only
one is unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (LESSP STRLEN K)
                    (p I J PAT STR PATLEN STRLEN K))
           (IMPLIES (AND (NOT (LESSP STRLEN K))
                         (MATCH PAT 1 PATLEN STR K STRLEN))
                    (p I J PAT STR PATLEN STRLEN K))
           (IMPLIES (AND (NOT (LESSP STRLEN K))
                         (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                         (p I J PAT STR PATLEN STRLEN
                            (ADD1 K)))
                    (p I J PAT STR PATLEN STRLEN K))).
Linear arithmetic can be used to show that the measure:
      (DIFFERENCE (ADD1 STRLEN) K)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces the following five new
formulas:

Case 5. (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP (SUB1 (SEARCH PAT STR PATLEN STRLEN K))
                                  (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J)
                        (SUB1 (SEARCH PAT STR PATLEN STRLEN K)))).

  This simplifies, expanding SEARCH, to:

        (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP (SUB1 K) (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J) (SUB1 K))),

  which again simplifies, using linear arithmetic, applying SUB1-ADD1 and
  MATCH-IMPLIES-EQ-CHARS, and unfolding PLUS, NUMBERP, SUB1, EQUAL, and
  DIFFERENCE, to:

        (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (EQUAL (ELT1 PAT (DIFFERENCE I (SUB1 K)))
                                  (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP (SUB1 K) (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J) (SUB1 K))).

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

        (IMPLIES (AND (NUMBERP X)
                      (MATCH PAT 1 PATLEN STR
                             (ADD1 X)
                             STRLEN)
                      (NOT (EQUAL (ELT1 PAT (DIFFERENCE I X))
                                  (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NOT (EQUAL (ADD1 X) 0))
                      (NOT (LESSP STRLEN (ADD1 X)))
                      (NOT (LESSP X (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J) X)),

  which further simplifies, using linear arithmetic, to:

        (IMPLIES (AND (NUMBERP X)
                      (MATCH PAT 1 PATLEN STR
                             (ADD1 X)
                             STRLEN)
                      (NOT (EQUAL (ELT1 PAT (DIFFERENCE (PLUS X J) X))
                                  (ELT1 PAT J)))
                      (NUMBERP (PLUS X J))
                      (NOT (EQUAL (PLUS X J) 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN (PLUS X J)))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP (PLUS X J) J))
                      (NOT (EQUAL (ADD1 X) 0))
                      (NOT (LESSP STRLEN (ADD1 X)))
                      (NOT (LESSP X (DIFFERENCE (PLUS X J) J))))
                 (LESSP (DIFFERENCE (PLUS X J) J) X)).

  However this again simplifies, applying COMMUTATIVITY-OF-PLUS and
  DIFFERENCE-PLUS-ID, to:

        T.

Case 4. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (EQUAL (ADD1 K) 0)
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP (SUB1 (SEARCH PAT STR PATLEN STRLEN K))
                                  (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J)
                        (SUB1 (SEARCH PAT STR PATLEN STRLEN K)))).

  This simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (LESSP STRLEN (ADD1 K))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP (SUB1 (SEARCH PAT STR PATLEN STRLEN K))
                                  (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J)
                        (SUB1 (SEARCH PAT STR PATLEN STRLEN K)))).

  This simplifies, using linear arithmetic, to:

        (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K K))
                      (LESSP K (ADD1 K))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP K)
                      (NOT (LESSP K I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP K K))
                      (NOT (LESSP (SUB1 (SEARCH PAT STR PATLEN K K))
                                  (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J)
                        (SUB1 (SEARCH PAT STR PATLEN K K)))),

  which again simplifies, using linear arithmetic, applying MATCH-AT-STRLEN,
  SUB1-ADD1, PLUS-ADD1, COMMUTATIVITY-OF-PLUS, and SEARCH-BOUNDARY, and
  opening up ADD1, MATCH, LESSP, and SEARCH, to the following two new
  conjectures:

  Case 3.2.
          (IMPLIES (AND (NOT (LESSP PATLEN 1))
                        (NOT (LESSP PATLEN 2))
                        (LESSP (SUB1 K) K)
                        (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                        (NUMBERP I)
                        (NOT (EQUAL I 0))
                        (NOT (LESSP K I))
                        (NUMBERP J)
                        (NOT (EQUAL J 0))
                        (NUMBERP PATLEN)
                        (NOT (LESSP PATLEN J))
                        (NOT (LESSP I J))
                        (NUMBERP K)
                        (NOT (EQUAL K 0))
                        (NOT (LESSP K K))
                        (NOT (LESSP K (DIFFERENCE I J))))
                   (LESSP (DIFFERENCE I J) K)).

    But this again simplifies, using linear arithmetic, to:

          T.

  Case 3.1.
          (IMPLIES (AND (NOT (LESSP PATLEN 1))
                        (NOT (EQUAL (ELT1 PAT 1) (ELT1 STR K)))
                        (LESSP (SUB1 K) K)
                        (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                        (NUMBERP I)
                        (NOT (EQUAL I 0))
                        (NOT (LESSP K I))
                        (NUMBERP J)
                        (NOT (EQUAL J 0))
                        (NUMBERP PATLEN)
                        (NOT (LESSP PATLEN J))
                        (NOT (LESSP I J))
                        (NUMBERP K)
                        (NOT (EQUAL K 0))
                        (NOT (LESSP K K))
                        (NOT (LESSP K (DIFFERENCE I J))))
                   (LESSP (DIFFERENCE I J) K)),

    which again simplifies, using linear arithmetic, to:

          T.

Case 2. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (LESSP (SUB1 (SEARCH PAT STR PATLEN STRLEN
                                           (ADD1 K)))
                             (DIFFERENCE I J))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP (SUB1 (SEARCH PAT STR PATLEN STRLEN K))
                                  (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J)
                        (SUB1 (SEARCH PAT STR PATLEN STRLEN K)))),

  which simplifies, expanding the function SEARCH, to:

        T.

Case 1. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (LESSP (DIFFERENCE I J)
                             (SUB1 (SEARCH PAT STR PATLEN STRLEN
                                           (ADD1 K))))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (EQUAL I 0))
                      (NUMBERP STRLEN)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP PATLEN)
                      (NOT (LESSP PATLEN J))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP (SUB1 (SEARCH PAT STR PATLEN STRLEN K))
                                  (DIFFERENCE I J))))
                 (LESSP (DIFFERENCE I J)
                        (SUB1 (SEARCH PAT STR PATLEN STRLEN K)))),

  which simplifies, unfolding SEARCH, to:

        T.


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


[ 0.0 0.5 0.0 ]

NEQ-CHARS-IN-REGION-MEANS-SEARCH-SKIPS


(PROVE-LEMMA DELTA1-DOESNT-GO-BEYOND-END-OF-MATCH
             (REWRITE)
             (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                           (NUMBERP I)
                           (NOT (LESSP STRLEN I))
                           (NUMBERP PATLEN)
                           (NUMBERP STRLEN)
                           (NUMBERP K)
                           (NOT (EQUAL K 0))
                           (LESSP I (PLUS K PATLEN)))
                      (EQUAL (LESSP (PLUS I
                                          (DELTA1 PAT (ELT1 STR I) PATLEN))
                                    (PLUS K PATLEN))
                             (OR (LESSP I K)
                                 (EQUAL I K)
                                 (LESSP K I)))))

WARNING:  Note that DELTA1-DOESNT-GO-BEYOND-END-OF-MATCH contains the free
variable STRLEN which will be chosen by instantiating the hypothesis:
      (MATCH PAT 1 PATLEN STR K STRLEN).



This simplifies, rewriting with EQUAL-LESSP, and unfolding OR, to four new
formulas:

Case 4. (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (LESSP I (PLUS K PATLEN))
                      (NOT (LESSP (PLUS I
                                        (DELTA1 PAT (ELT1 STR I) PATLEN))
                                  (PLUS K PATLEN))))
                 (NOT (LESSP K I))),

  which again simplifies, using linear arithmetic, rewriting with SUB1-ADD1
  and MATCH-IMPLIES-EQ-CHARS, and expanding PLUS, NUMBERP, SUB1, EQUAL, and
  DIFFERENCE, to the new goal:

        (IMPLIES
              (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                   (NUMBERP I)
                   (NOT (LESSP STRLEN I))
                   (NUMBERP PATLEN)
                   (NUMBERP STRLEN)
                   (NUMBERP K)
                   (NOT (EQUAL K 0))
                   (LESSP I (PLUS K PATLEN))
                   (NOT (LESSP (PLUS I
                                     (DELTA1 PAT
                                             (ELT1 PAT (DIFFERENCE I (SUB1 K)))
                                             PATLEN))
                               (PLUS K PATLEN))))
              (NOT (LESSP K I))),

  which again simplifies, using linear arithmetic and rewriting with
  DELTA1-PLUS-J-LESSEQP-PATLEN, to:

        (IMPLIES
              (AND (LESSP I (SUB1 K))
                   (MATCH PAT 1 PATLEN STR K STRLEN)
                   (NUMBERP I)
                   (NOT (LESSP STRLEN I))
                   (NUMBERP PATLEN)
                   (NUMBERP STRLEN)
                   (NUMBERP K)
                   (NOT (EQUAL K 0))
                   (LESSP I (PLUS K PATLEN))
                   (NOT (LESSP (PLUS I
                                     (DELTA1 PAT
                                             (ELT1 PAT (DIFFERENCE I (SUB1 K)))
                                             PATLEN))
                               (PLUS K PATLEN))))
              (NOT (LESSP K I))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (LESSP I (PLUS K PATLEN))
                      (NOT (LESSP (PLUS I
                                        (DELTA1 PAT (ELT1 STR I) PATLEN))
                                  (PLUS K PATLEN))))
                 (NOT (EQUAL I K))),

  which again simplifies, using linear arithmetic and appealing to the lemma
  DELTA1-LESSEQP-PATLEN, to:

        (IMPLIES (AND (EQUAL (DELTA1 PAT (ELT1 STR K) PATLEN)
                             PATLEN)
                      (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NUMBERP K)
                      (NOT (LESSP STRLEN K))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (LESSP K (PLUS K PATLEN)))
                 (LESSP (PLUS K PATLEN)
                        (PLUS K PATLEN))).

  But this again simplifies, using linear arithmetic, rewriting with the
  lemmas SUB1-ADD1 and MATCH-IMPLIES-EQ-CHARS, and expanding PLUS, NUMBERP,
  SUB1, EQUAL, and DIFFERENCE, to:

        (IMPLIES (AND (EQUAL (DELTA1 PAT
                                     (ELT1 PAT (DIFFERENCE K (SUB1 K)))
                                     PATLEN)
                             PATLEN)
                      (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NUMBERP STRLEN)
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (LESSP K (PLUS K PATLEN)))
                 (LESSP (PLUS K PATLEN)
                        (PLUS K PATLEN))).

  However this again simplifies, using linear arithmetic and rewriting with
  DELTA1-PLUS-J-LESSEQP-PATLEN, to:

        (IMPLIES (AND (LESSP K (SUB1 K))
                      (EQUAL (DELTA1 PAT
                                     (ELT1 PAT (DIFFERENCE K (SUB1 K)))
                                     PATLEN)
                             PATLEN)
                      (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (LESSP STRLEN K))
                      (NUMBERP STRLEN)
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (LESSP K (PLUS K PATLEN)))
                 (LESSP (PLUS K PATLEN)
                        (PLUS K PATLEN))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (LESSP I (PLUS K PATLEN))
                      (NOT (LESSP (PLUS I
                                        (DELTA1 PAT (ELT1 STR I) PATLEN))
                                  (PLUS K PATLEN))))
                 (NOT (LESSP I K))),

  which again simplifies, using linear arithmetic and applying the lemma
  DELTA1-LESSEQP-PATLEN, to:

        T.

Case 1. (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (LESSP I (PLUS K PATLEN))
                      (LESSP (PLUS I
                                   (DELTA1 PAT (ELT1 STR I) PATLEN))
                             (PLUS K PATLEN))
                      (NOT (LESSP I K))
                      (NOT (EQUAL I K)))
                 (LESSP K I)),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

DELTA1-DOESNT-GO-BEYOND-END-OF-MATCH


(DISABLE MATCH-IMPLIES-EQ-CHARS)

[ 0.0 0.0 0.0 ]

MATCH-IMPLIES-EQ-CHARS-OFF


(PROVE-LEMMA DELTA1-DOESNT-GO-BEYOND-SEARCH
             (REWRITE)
             (IMPLIES (AND (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                           (NUMBERP I)
                           (NOT (LESSP STRLEN I))
                           (NUMBERP J)
                           (NOT (LESSP PATLEN J))
                           (NUMBERP PATLEN)
                           (NUMBERP STRLEN)
                           (LESSP (DIFFERENCE I J)
                                  (SEARCH PAT STR PATLEN STRLEN K))
                           (NOT (LESSP STRLEN K))
                           (NOT (LESSP I J))
                           (NUMBERP K)
                           (NOT (EQUAL K 0)))
                      (LESSP (PLUS I
                                   (DELTA1 PAT (ELT1 STR I) PATLEN))
                             (PLUS PATLEN
                                   (SEARCH PAT STR PATLEN STRLEN K)))))

WARNING:  When the linear lemma DELTA1-DOESNT-GO-BEYOND-SEARCH is stored under:
      (SEARCH PAT STR PATLEN STRLEN K)
it contains the free variables J and I which will be chosen by instantiating
the hypothesis (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J))).


WARNING:  When the linear lemma DELTA1-DOESNT-GO-BEYOND-SEARCH is stored under:
      (DELTA1 PAT (ELT1 STR I) PATLEN)
it contains the free variables K, STRLEN, and J which will be chosen by
instantiating the hypotheses (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J))),
(NOT (LESSP STRLEN I)), and:
      (LESSP (DIFFERENCE I J)
             (SEARCH PAT STR PATLEN STRLEN K)).



WARNING:  Note that the proposed lemma DELTA1-DOESNT-GO-BEYOND-SEARCH is to be
stored as zero type prescription rules, zero compound recognizer rules, two
linear rules, and zero replacement rules.



     Call the conjecture *1.


     We will try to prove it by induction.  There are six plausible inductions.
They merge into three likely candidate inductions.  However, only one is
unflawed.  We will induct according to the following scheme:
      (AND (IMPLIES (LESSP STRLEN K)
                    (p I PAT STR PATLEN STRLEN K J))
           (IMPLIES (AND (NOT (LESSP STRLEN K))
                         (MATCH PAT 1 PATLEN STR K STRLEN))
                    (p I PAT STR PATLEN STRLEN K J))
           (IMPLIES (AND (NOT (LESSP STRLEN K))
                         (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                         (p I PAT STR PATLEN STRLEN
                            (ADD1 K)
                            J))
                    (p I PAT STR PATLEN STRLEN K J))).
Linear arithmetic can be used to establish that the measure:
      (DIFFERENCE (ADD1 STRLEN) K)
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 (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (LESSP (DIFFERENCE I J)
                             (SEARCH PAT STR PATLEN STRLEN K))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0)))
                 (LESSP (PLUS I
                              (DELTA1 PAT (ELT1 STR I) PATLEN))
                        (PLUS PATLEN
                              (SEARCH PAT STR PATLEN STRLEN K)))).

  This simplifies, rewriting with the lemma COMMUTATIVITY-OF-PLUS, and opening
  up SEARCH, to the new goal:

        (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (LESSP (DIFFERENCE I J) K)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0)))
                 (LESSP (PLUS I
                              (DELTA1 PAT (ELT1 STR I) PATLEN))
                        (PLUS K PATLEN))),

  which again simplifies, using linear arithmetic and rewriting with the lemma
  DELTA1-DOESNT-GO-BEYOND-END-OF-MATCH, to the formula:

        (IMPLIES (AND (MATCH PAT 1 PATLEN STR K STRLEN)
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (LESSP (DIFFERENCE I J) K)
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0))
                      (NOT (LESSP I K))
                      (NOT (EQUAL I K)))
                 (LESSP K I)).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 4. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (NOT (LESSP (DIFFERENCE I J)
                                  (SEARCH PAT STR PATLEN STRLEN
                                          (ADD1 K))))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (LESSP (DIFFERENCE I J)
                             (SEARCH PAT STR PATLEN STRLEN K))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0)))
                 (LESSP (PLUS I
                              (DELTA1 PAT (ELT1 STR I) PATLEN))
                        (PLUS PATLEN
                              (SEARCH PAT STR PATLEN STRLEN K)))),

  which simplifies, unfolding the definition of SEARCH, to:

        T.

Case 3. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (LESSP STRLEN (ADD1 K))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (LESSP (DIFFERENCE I J)
                             (SEARCH PAT STR PATLEN STRLEN K))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0)))
                 (LESSP (PLUS I
                              (DELTA1 PAT (ELT1 STR I) PATLEN))
                        (PLUS PATLEN
                              (SEARCH PAT STR PATLEN STRLEN K)))),

  which simplifies, using linear arithmetic, to:

        (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K K))
                      (LESSP K (ADD1 K))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP K I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP K)
                      (LESSP (DIFFERENCE I J)
                             (SEARCH PAT STR PATLEN K K))
                      (NOT (LESSP K K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0)))
                 (LESSP (PLUS I
                              (DELTA1 PAT (ELT1 STR I) PATLEN))
                        (PLUS PATLEN
                              (SEARCH PAT STR PATLEN K K)))).

  However this again simplifies, using linear arithmetic, applying
  MATCH-AT-STRLEN, SUB1-ADD1, COMMUTATIVITY-OF-PLUS, and PLUS-ADD1, and
  opening up the definitions of ADD1, MATCH, LESSP, and SEARCH, to the
  following four new formulas:

  Case 3.4.
          (IMPLIES (AND (NOT (LESSP PATLEN 1))
                        (NOT (LESSP PATLEN 2))
                        (LESSP (SUB1 K) K)
                        (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                        (NUMBERP I)
                        (NOT (LESSP K I))
                        (NUMBERP J)
                        (NOT (LESSP PATLEN J))
                        (NUMBERP PATLEN)
                        (EQUAL (DIFFERENCE I J) 0)
                        (NOT (LESSP K K))
                        (NOT (LESSP I J))
                        (NUMBERP K)
                        (NOT (EQUAL K 0))
                        (NOT (EQUAL (PLUS I
                                          (DELTA1 PAT (ELT1 STR I) PATLEN))
                                    0)))
                   (LESSP (SUB1 (PLUS I
                                      (DELTA1 PAT (ELT1 STR I) PATLEN)))
                          (PLUS K PATLEN))).

    But this again simplifies, using linear arithmetic and rewriting with
    DELTA1-LESSEQP-PATLEN, to:

          T.

  Case 3.3.
          (IMPLIES (AND (NOT (LESSP PATLEN 1))
                        (NOT (LESSP PATLEN 2))
                        (LESSP (SUB1 K) K)
                        (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                        (NUMBERP I)
                        (NOT (LESSP K I))
                        (NUMBERP J)
                        (NOT (LESSP PATLEN J))
                        (NUMBERP PATLEN)
                        (LESSP (SUB1 (DIFFERENCE I J)) K)
                        (NOT (LESSP K K))
                        (NOT (LESSP I J))
                        (NUMBERP K)
                        (NOT (EQUAL K 0))
                        (NOT (EQUAL (PLUS I
                                          (DELTA1 PAT (ELT1 STR I) PATLEN))
                                    0)))
                   (LESSP (SUB1 (PLUS I
                                      (DELTA1 PAT (ELT1 STR I) PATLEN)))
                          (PLUS K PATLEN))).

    But this again simplifies, using linear arithmetic and rewriting with the
    lemma DELTA1-LESSEQP-PATLEN, to:

          T.

  Case 3.2.
          (IMPLIES (AND (NOT (LESSP PATLEN 1))
                        (NOT (EQUAL (ELT1 PAT 1) (ELT1 STR K)))
                        (LESSP (SUB1 K) K)
                        (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                        (NUMBERP I)
                        (NOT (LESSP K I))
                        (NUMBERP J)
                        (NOT (LESSP PATLEN J))
                        (NUMBERP PATLEN)
                        (EQUAL (DIFFERENCE I J) 0)
                        (NOT (LESSP K K))
                        (NOT (LESSP I J))
                        (NUMBERP K)
                        (NOT (EQUAL K 0))
                        (NOT (EQUAL (PLUS I
                                          (DELTA1 PAT (ELT1 STR I) PATLEN))
                                    0)))
                   (LESSP (SUB1 (PLUS I
                                      (DELTA1 PAT (ELT1 STR I) PATLEN)))
                          (PLUS K PATLEN))),

    which again simplifies, using linear arithmetic and applying
    DELTA1-LESSEQP-PATLEN, to:

          T.

  Case 3.1.
          (IMPLIES (AND (NOT (LESSP PATLEN 1))
                        (NOT (EQUAL (ELT1 PAT 1) (ELT1 STR K)))
                        (LESSP (SUB1 K) K)
                        (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                        (NUMBERP I)
                        (NOT (LESSP K I))
                        (NUMBERP J)
                        (NOT (LESSP PATLEN J))
                        (NUMBERP PATLEN)
                        (LESSP (SUB1 (DIFFERENCE I J)) K)
                        (NOT (LESSP K K))
                        (NOT (LESSP I J))
                        (NUMBERP K)
                        (NOT (EQUAL K 0))
                        (NOT (EQUAL (PLUS I
                                          (DELTA1 PAT (ELT1 STR I) PATLEN))
                                    0)))
                   (LESSP (SUB1 (PLUS I
                                      (DELTA1 PAT (ELT1 STR I) PATLEN)))
                          (PLUS K PATLEN))).

    This again simplifies, using linear arithmetic and applying
    DELTA1-LESSEQP-PATLEN, to:

          T.

Case 2. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (EQUAL (ADD1 K) 0)
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (LESSP (DIFFERENCE I J)
                             (SEARCH PAT STR PATLEN STRLEN K))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0)))
                 (LESSP (PLUS I
                              (DELTA1 PAT (ELT1 STR I) PATLEN))
                        (PLUS PATLEN
                              (SEARCH PAT STR PATLEN STRLEN K)))).

  This simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (LESSP (PLUS I
                                   (DELTA1 PAT (ELT1 STR I) PATLEN))
                             (PLUS PATLEN
                                   (SEARCH PAT STR PATLEN STRLEN
                                           (ADD1 K))))
                      (NOT (EQUAL (ELT1 STR I) (ELT1 PAT J)))
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP J)
                      (NOT (LESSP PATLEN J))
                      (NUMBERP PATLEN)
                      (NUMBERP STRLEN)
                      (LESSP (DIFFERENCE I J)
                             (SEARCH PAT STR PATLEN STRLEN K))
                      (NOT (LESSP STRLEN K))
                      (NOT (LESSP I J))
                      (NUMBERP K)
                      (NOT (EQUAL K 0)))
                 (LESSP (PLUS I
                              (DELTA1 PAT (ELT1 STR I) PATLEN))
                        (PLUS PATLEN
                              (SEARCH PAT STR PATLEN STRLEN K)))).

  This simplifies, expanding the definition of SEARCH, to:

        T.


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


[ 0.0 1.0 0.0 ]

DELTA1-DOESNT-GO-BEYOND-SEARCH


(PROVE-LEMMA OUTER-INVRT1 NIL
 (IMPLIES
         (AND (ZNEQP (C$2) (ELT1 (PAT$0) (J$2)))
              (PATH-HYPS))
         (AND (AND (NUMBERP (I$3))
                   (AND (NOT (LESSP (I$3) (PATLEN$0)))
                        (AND (LESSP (I$3)
                                    (PLUS (PATLEN$0)
                                          (SEARCH (PAT$0)
                                                  (STR$0)
                                                  (PATLEN$0)
                                                  (STRLEN$0)
                                                  '1)))
                             (IMPLIES (AND (NUMBERP C)
                                           (AND (NOT (EQUAL C '0))
                                                (NOT (LESSP (ASIZE&) C))))
                                      (EQUAL (ELT1 (BLK-DELTA1$3) C)
                                             (DELTA1 (PAT$0) C (PATLEN$0)))))))
              (LEX (CONS (DIFFERENCE (PLUS '1
                                           (PLUS (STRLEN$0) (PATLEN$0)))
                                     (I$3))
                         (CONS (ADD1 (PATLEN$0)) 'NIL))
                   (CONS (DIFFERENCE (PLUS '1
                                           (PLUS (STRLEN$0) (PATLEN$0)))
                                     (SUB1 (NEXTI$1)))
                         (CONS (J$1) 'NIL))))))

This conjecture can be simplified, using the abbreviations GLOBAL-HYPS,
PATH-HYPS, ZEQP, ZNEQP, AND, IMPLIES, PATHS-FROM-INNER-INVRT, ASSIGNMENT2, and
ASSIGNMENT1, to:

      (IMPLIES
          (AND (NOT (EQUAL (ZNORMALIZE (ELT1 (STR$0) (I$1)))
                           (ZNORMALIZE (ELT1 (PAT$0) (J$1)))))
               (NOT (EQUAL (ASIZE&) 0))
               (LESSP (ADD1 (ASIZE&))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (LESSP 0 (PATLEN$0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (LESSP 0 (STRLEN$0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PATLEN$0))))
               (LESSP (PLUS (ADD1 (PATLEN$0))
                            (DIFFERENCE (I$1) (J$1)))
                      (ADD1 (PLUS (PATLEN$0)
                                  (SEARCH (PAT$0)
                                          (STR$0)
                                          (PATLEN$0)
                                          (STRLEN$0)
                                          1))))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NUMBERP (PLUS (ADD1 (PATLEN$0))
                              (DIFFERENCE (I$1) (J$1))))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (ADD1 (STRLEN$0))
                           (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (NUMBERP (ELT1 (BLK-DELTA1$1)
                              (ELT1 (STR$0) (I$1))))
               (NUMBERP (ELT1 (STR$0) (I$1)))
               (NUMBERP (ELT1 (PAT$0) (J$1))))
          (AND (AND (NUMBERP (MAX0 (ZPLUS (I$1)
                                          (ELT1 (BLK-DELTA1$1)
                                                (ELT1 (STR$0) (I$1))))
                                   (PLUS (ADD1 (PATLEN$0))
                                         (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (MAX0 (ZPLUS (I$1)
                                             (ELT1 (BLK-DELTA1$1)
                                                   (ELT1 (STR$0) (I$1))))
                                      (PLUS (ADD1 (PATLEN$0))
                                            (DIFFERENCE (I$1) (J$1))))
                                (PATLEN$0)))
                    (LESSP (MAX0 (ZPLUS (I$1)
                                        (ELT1 (BLK-DELTA1$1)
                                              (ELT1 (STR$0) (I$1))))
                                 (PLUS (ADD1 (PATLEN$0))
                                       (DIFFERENCE (I$1) (J$1))))
                           (PLUS (PATLEN$0)
                                 (SEARCH (PAT$0)
                                         (STR$0)
                                         (PATLEN$0)
                                         (STRLEN$0)
                                         1)))
                    (IMPLIES (AND (NUMBERP C)
                                  (NOT (EQUAL C 0))
                                  (NOT (LESSP (ASIZE&) C)))
                             (EQUAL (ELT1 (BLK-DELTA1$1) C)
                                    (DELTA1 (PAT$0) C (PATLEN$0)))))
               (LEX (LIST (DIFFERENCE (PLUS 1 (STRLEN$0) (PATLEN$0))
                                      (MAX0 (ZPLUS (I$1)
                                                   (ELT1 (BLK-DELTA1$1)
                                                         (ELT1 (STR$0) (I$1))))
                                            (PLUS (ADD1 (PATLEN$0))
                                                  (DIFFERENCE (I$1) (J$1)))))
                          (ADD1 (PATLEN$0)))
                    (LIST (DIFFERENCE (PLUS 1 (STRLEN$0) (PATLEN$0))
                                      (SUB1 (PLUS (ADD1 (PATLEN$0))
                                                  (DIFFERENCE (I$1) (J$1)))))
                          (J$1))))).

This simplifies, using linear arithmetic, rewriting with SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, PATHS-FROM-INNER-INVRT, COMMUTATIVITY-OF-PLUS,
CDR-CONS, and CAR-CONS, and unfolding the definitions of ZNORMALIZE, LESSP,
EQUAL, PLUS, ZPLUS, ZLESSP, MAX0, NOT, AND, IMPLIES, SUB1, NUMBERP, DIFFERENCE,
and LEX, to 25 new conjectures:

Case 25.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (LESSP (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0))))
                             (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))))
                 (NOT (LESSP (ADD1 (PLUS (PATLEN$0)
                                         (DIFFERENCE (I$1) (J$1))))
                             (PATLEN$0)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 24.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (I$1)
                                   (DELTA1 (PAT$0)
                                           (ELT1 (STR$0) (I$1))
                                           (PATLEN$0)))
                             0))
                 (NOT (LESSP (ADD1 (PLUS (PATLEN$0)
                                         (DIFFERENCE (I$1) (J$1))))
                             (PATLEN$0)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 23.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (NOT (EQUAL (PLUS (I$1)
                                        (DELTA1 (PAT$0)
                                                (ELT1 (STR$0) (I$1))
                                                (PATLEN$0)))
                                  0))
                      (NOT (LESSP (SUB1 (PLUS (I$1)
                                              (DELTA1 (PAT$0)
                                                      (ELT1 (STR$0) (I$1))
                                                      (PATLEN$0))))
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))
                 (NOT (LESSP (PLUS (I$1)
                                   (DELTA1 (PAT$0)
                                           (ELT1 (STR$0) (I$1))
                                           (PATLEN$0)))
                             (PATLEN$0)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 22.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (LESSP (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0))))
                             (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))))
                 (LESSP (ADD1 (PLUS (PATLEN$0)
                                    (DIFFERENCE (I$1) (J$1))))
                        (PLUS (PATLEN$0)
                              (SEARCH (PAT$0)
                                      (STR$0)
                                      (PATLEN$0)
                                      (STRLEN$0)
                                      1)))),

  which again simplifies, using linear arithmetic, applying
  NEQ-CHARS-IN-REGION-MEANS-SEARCH-SKIPS, and unfolding EQUAL, to:

        (IMPLIES (AND (EQUAL (SEARCH (PAT$0)
                                     (STR$0)
                                     (PATLEN$0)
                                     (STRLEN$0)
                                     1)
                             0)
                      (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (LESSP (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0))))
                             (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))))
                 (LESSP (ADD1 (PLUS (PATLEN$0)
                                    (DIFFERENCE (I$1) (J$1))))
                        (PLUS (PATLEN$0)
                              (SEARCH (PAT$0)
                                      (STR$0)
                                      (PATLEN$0)
                                      (STRLEN$0)
                                      1)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 21.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (I$1)
                                   (DELTA1 (PAT$0)
                                           (ELT1 (STR$0) (I$1))
                                           (PATLEN$0)))
                             0))
                 (LESSP (ADD1 (PLUS (PATLEN$0)
                                    (DIFFERENCE (I$1) (J$1))))
                        (PLUS (PATLEN$0)
                              (SEARCH (PAT$0)
                                      (STR$0)
                                      (PATLEN$0)
                                      (STRLEN$0)
                                      1)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 20.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (NOT (EQUAL (PLUS (I$1)
                                        (DELTA1 (PAT$0)
                                                (ELT1 (STR$0) (I$1))
                                                (PATLEN$0)))
                                  0))
                      (NOT (LESSP (SUB1 (PLUS (I$1)
                                              (DELTA1 (PAT$0)
                                                      (ELT1 (STR$0) (I$1))
                                                      (PATLEN$0))))
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))
                 (LESSP (PLUS (I$1)
                              (DELTA1 (PAT$0)
                                      (ELT1 (STR$0) (I$1))
                                      (PATLEN$0)))
                        (PLUS (PATLEN$0)
                              (SEARCH (PAT$0)
                                      (STR$0)
                                      (PATLEN$0)
                                      (STRLEN$0)
                                      1)))),

  which again simplifies, using linear arithmetic, applying
  DELTA1-DOESNT-GO-BEYOND-SEARCH, and opening up the definition of EQUAL, to:

        T.

Case 19.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$1) C)
                        (DELTA1 (PAT$0) C (PATLEN$0)))).

  This again simplifies, applying PATHS-FROM-INNER-INVRT, to:

        T.

Case 18.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             0)
                      (LESSP (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0))))
                             (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1))))
                      (EQUAL (ADD1 (PLUS (PATLEN$0)
                                         (DIFFERENCE (I$1) (J$1))))
                             0)
                      (NOT (LESSP (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                                  (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
                 (LESSP (PATLEN$0) (SUB1 (J$1)))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 17.(IMPLIES (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             0)
                      (EQUAL (PLUS (I$1)
                                   (DELTA1 (PAT$0)
                                           (ELT1 (STR$0) (I$1))
                                           (PATLEN$0)))
                             0)
                      (EQUAL (ADD1 (PLUS (PATLEN$0)
                                         (DIFFERENCE (I$1) (J$1))))
                             0)
                      (NOT (LESSP (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                                  (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
                 (LESSP (PATLEN$0) (SUB1 (J$1)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 16.(IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (EQUAL (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 0)
          (LESSP (SUB1 (PLUS (I$1)
                             (DELTA1 (PAT$0)
                                     (ELT1 (STR$0) (I$1))
                                     (PATLEN$0))))
                 (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1))))
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (SUB1 1))
                      (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP 0 (PATLEN$0)))
                      (LESSP 0
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0) 0))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             0)
                      (LESSP (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0))))
                             0)
                      (NOT (EQUAL 1 0))
                      (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                              (SUB1 1))
                                  (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
                 (LESSP (PATLEN$0) (SUB1 (J$1)))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 15.(IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (EQUAL (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 0)
          (EQUAL (PLUS (I$1)
                       (DELTA1 (PAT$0)
                               (ELT1 (STR$0) (I$1))
                               (PATLEN$0)))
                 0)
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))),

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

        (IMPLIES (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (SUB1 1))
                      (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP 0 (PATLEN$0)))
                      (LESSP 0
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0) 0))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             0)
                      (EQUAL (PLUS (I$1)
                                   (DELTA1 (PAT$0)
                                           (ELT1 (STR$0) (I$1))
                                           (PATLEN$0)))
                             0)
                      (NOT (EQUAL 1 0))
                      (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                              (SUB1 1))
                                  (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
                 (LESSP (PATLEN$0) (SUB1 (J$1)))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 14.(IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (EQUAL (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 0)
          (LESSP (SUB1 (PLUS (I$1)
                             (DELTA1 (PAT$0)
                                     (ELT1 (STR$0) (I$1))
                                     (PATLEN$0))))
                 (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1))))
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (ADD1 (PLUS (PATLEN$0)
                                              (DIFFERENCE (I$1) (J$1))))))
                (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))),

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

        (IMPLIES (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (SUB1 1))
                      (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP 0 (PATLEN$0)))
                      (LESSP 0
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0) 0))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             0)
                      (LESSP (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0))))
                             0)
                      (NOT (EQUAL 1 0))
                      (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                              (SUB1 1))
                                  (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
                 (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                    (SUB1 1))
                        (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 13.(IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (EQUAL (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 0)
          (EQUAL (PLUS (I$1)
                       (DELTA1 (PAT$0)
                               (ELT1 (STR$0) (I$1))
                               (PATLEN$0)))
                 0)
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (ADD1 (PLUS (PATLEN$0)
                                              (DIFFERENCE (I$1) (J$1))))))
                (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))),

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

        (IMPLIES (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (SUB1 1))
                      (NOT (EQUAL (ELT1 (STR$0) (I$1))
                                  (ELT1 (PAT$0) (J$1))))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP 0 (PATLEN$0)))
                      (LESSP 0
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0) 0))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             0)
                      (EQUAL (PLUS (I$1)
                                   (DELTA1 (PAT$0)
                                           (ELT1 (STR$0) (I$1))
                                           (PATLEN$0)))
                             0)
                      (NOT (EQUAL 1 0))
                      (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                              (SUB1 1))
                                  (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
                 (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                    (SUB1 1))
                        (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 12.(IMPLIES
          (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                           (ELT1 (PAT$0) (J$1))))
               (NOT (EQUAL (ASIZE&) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (NOT (EQUAL (PATLEN$0) 0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (NOT (EQUAL (STRLEN$0) 0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))
                           (PATLEN$0)))
               (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PLUS (PATLEN$0)
                            (SEARCH (PAT$0)
                                    (STR$0)
                                    (PATLEN$0)
                                    (STRLEN$0)
                                    1)))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (STRLEN$0)
                           (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0)
               (NOT (EQUAL (PLUS (I$1)
                                 (DELTA1 (PAT$0)
                                         (ELT1 (STR$0) (I$1))
                                         (PATLEN$0)))
                           0))
               (NOT (LESSP (SUB1 (PLUS (I$1)
                                       (DELTA1 (PAT$0)
                                               (ELT1 (STR$0) (I$1))
                                               (PATLEN$0))))
                           (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                       (SUB1 (PLUS (I$1)
                                                   (DELTA1 (PAT$0)
                                                           (ELT1 (STR$0) (I$1))
                                                           (PATLEN$0)))))
                           (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
          (LESSP (PATLEN$0) (SUB1 (J$1)))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES
          (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (SUB1 (PLUS (I$1)
                                  (DELTA1 (PAT$0)
                                          (ELT1 (STR$0) (I$1))
                                          (PATLEN$0)))))
               (NOT (EQUAL (ELT1 (STR$0) (I$1))
                           (ELT1 (PAT$0) (J$1))))
               (NOT (EQUAL (ASIZE&) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (NOT (EQUAL (PATLEN$0) 0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (NOT (EQUAL (STRLEN$0) 0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP 0 (PATLEN$0)))
               (LESSP 0
                      (PLUS (PATLEN$0)
                            (SEARCH (PAT$0)
                                    (STR$0)
                                    (PATLEN$0)
                                    (STRLEN$0)
                                    1)))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (STRLEN$0) 0))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0)
               (NOT (EQUAL (PLUS (I$1)
                                 (DELTA1 (PAT$0)
                                         (ELT1 (STR$0) (I$1))
                                         (PATLEN$0)))
                           0))
               (NOT (LESSP (SUB1 (PLUS (I$1)
                                       (DELTA1 (PAT$0)
                                               (ELT1 (STR$0) (I$1))
                                               (PATLEN$0))))
                           0))
               (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                       (SUB1 (PLUS (I$1)
                                                   (DELTA1 (PAT$0)
                                                           (ELT1 (STR$0) (I$1))
                                                           (PATLEN$0)))))
                           (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
          (LESSP (PATLEN$0) (SUB1 (J$1)))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 11.(IMPLIES
          (AND (NOT (EQUAL (ELT1 (STR$0) (I$1))
                           (ELT1 (PAT$0) (J$1))))
               (NOT (EQUAL (ASIZE&) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (NOT (EQUAL (PATLEN$0) 0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (NOT (EQUAL (STRLEN$0) 0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))
                           (PATLEN$0)))
               (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PLUS (PATLEN$0)
                            (SEARCH (PAT$0)
                                    (STR$0)
                                    (PATLEN$0)
                                    (STRLEN$0)
                                    1)))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (STRLEN$0)
                           (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0)
               (NOT (EQUAL (PLUS (I$1)
                                 (DELTA1 (PAT$0)
                                         (ELT1 (STR$0) (I$1))
                                         (PATLEN$0)))
                           0))
               (NOT (LESSP (SUB1 (PLUS (I$1)
                                       (DELTA1 (PAT$0)
                                               (ELT1 (STR$0) (I$1))
                                               (PATLEN$0))))
                           (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                       (SUB1 (PLUS (I$1)
                                                   (DELTA1 (PAT$0)
                                                           (ELT1 (STR$0) (I$1))
                                                           (PATLEN$0)))))
                           (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
          (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                             (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0)))))
                 (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES
          (AND (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (SUB1 (PLUS (I$1)
                                  (DELTA1 (PAT$0)
                                          (ELT1 (STR$0) (I$1))
                                          (PATLEN$0)))))
               (NOT (EQUAL (ELT1 (STR$0) (I$1))
                           (ELT1 (PAT$0) (J$1))))
               (NOT (EQUAL (ASIZE&) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (NOT (EQUAL (PATLEN$0) 0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (NOT (EQUAL (STRLEN$0) 0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP 0 (PATLEN$0)))
               (LESSP 0
                      (PLUS (PATLEN$0)
                            (SEARCH (PAT$0)
                                    (STR$0)
                                    (PATLEN$0)
                                    (STRLEN$0)
                                    1)))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (STRLEN$0) 0))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0)
               (NOT (EQUAL (PLUS (I$1)
                                 (DELTA1 (PAT$0)
                                         (ELT1 (STR$0) (I$1))
                                         (PATLEN$0)))
                           0))
               (NOT (LESSP (SUB1 (PLUS (I$1)
                                       (DELTA1 (PAT$0)
                                               (ELT1 (STR$0) (I$1))
                                               (PATLEN$0))))
                           0))
               (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                       (SUB1 (PLUS (I$1)
                                                   (DELTA1 (PAT$0)
                                                           (ELT1 (STR$0) (I$1))
                                                           (PATLEN$0)))))
                           (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
          (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                             (SUB1 (PLUS (I$1)
                                         (DELTA1 (PAT$0)
                                                 (ELT1 (STR$0) (I$1))
                                                 (PATLEN$0)))))
                 (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 10.(IMPLIES
         (AND
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (LESSP (SUB1 (PLUS (I$1)
                                (DELTA1 (PAT$0)
                                        (ELT1 (STR$0) (I$1))
                                        (PATLEN$0))))
                    (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1))))
             (EQUAL (ADD1 (PLUS (PATLEN$0)
                                (DIFFERENCE (I$1) (J$1))))
                    0)
             (NOT (LESSP (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 9. (IMPLIES
         (AND
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (EQUAL (PLUS (I$1)
                          (DELTA1 (PAT$0)
                                  (ELT1 (STR$0) (I$1))
                                  (PATLEN$0)))
                    0)
             (EQUAL (ADD1 (PLUS (PATLEN$0)
                                (DIFFERENCE (I$1) (J$1))))
                    0)
             (NOT (LESSP (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 8. (IMPLIES
         (AND
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (LESSP (SUB1 (PLUS (I$1)
                                (DELTA1 (PAT$0)
                                        (ELT1 (STR$0) (I$1))
                                        (PATLEN$0))))
                    (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1))))
             (EQUAL (ADD1 (PLUS (PATLEN$0)
                                (DIFFERENCE (I$1) (J$1))))
                    0)
             (NOT (LESSP (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 7. (IMPLIES
         (AND
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (EQUAL (PLUS (I$1)
                          (DELTA1 (PAT$0)
                                  (ELT1 (STR$0) (I$1))
                                  (PATLEN$0)))
                    0)
             (EQUAL (ADD1 (PLUS (PATLEN$0)
                                (DIFFERENCE (I$1) (J$1))))
                    0)
             (NOT (LESSP (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 6. (IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (LESSP (SUB1 (PLUS (I$1)
                             (DELTA1 (PAT$0)
                                     (ELT1 (STR$0) (I$1))
                                     (PATLEN$0))))
                 (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1))))
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES
         (AND
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1))))))
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (LESSP (SUB1 (PLUS (I$1)
                             (DELTA1 (PAT$0)
                                     (ELT1 (STR$0) (I$1))
                                     (PATLEN$0))))
                 (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1))))
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 5. (IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (EQUAL (PLUS (I$1)
                       (DELTA1 (PAT$0)
                               (ELT1 (STR$0) (I$1))
                               (PATLEN$0)))
                 0)
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES
         (AND
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1))))))
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (EQUAL (PLUS (I$1)
                       (DELTA1 (PAT$0)
                               (ELT1 (STR$0) (I$1))
                               (PATLEN$0)))
                 0)
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 4. (IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (LESSP (SUB1 (PLUS (I$1)
                             (DELTA1 (PAT$0)
                                     (ELT1 (STR$0) (I$1))
                                     (PATLEN$0))))
                 (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1))))
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (ADD1 (PLUS (PATLEN$0)
                                              (DIFFERENCE (I$1) (J$1))))))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES
         (AND
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1))))))
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (LESSP (SUB1 (PLUS (I$1)
                             (DELTA1 (PAT$0)
                                     (ELT1 (STR$0) (I$1))
                                     (PATLEN$0))))
                 (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1))))
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (ADD1 (PLUS (PATLEN$0)
                                              (DIFFERENCE (I$1) (J$1))))))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES
         (AND
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (EQUAL (PLUS (I$1)
                       (DELTA1 (PAT$0)
                               (ELT1 (STR$0) (I$1))
                               (PATLEN$0)))
                 0)
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (ADD1 (PLUS (PATLEN$0)
                                              (DIFFERENCE (I$1) (J$1))))))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES
         (AND
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1))))))
          (NOT (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1))))
          (NOT (EQUAL (ASIZE&) 0))
          (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                      0))
          (LESSP (ASIZE&)
                 (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
          (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
          (NOT (EQUAL (PATLEN$0) 0))
          (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
          (NOT (EQUAL (STRLEN$0) 0))
          (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
          (NUMBERP (PATLEN$0))
          (NUMBERP (STRLEN$0))
          (NOT (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PATLEN$0)))
          (LESSP (PLUS (PATLEN$0)
                       (DIFFERENCE (I$1) (J$1)))
                 (PLUS (PATLEN$0)
                       (SEARCH (PAT$0)
                               (STR$0)
                               (PATLEN$0)
                               (STRLEN$0)
                               1)))
          (NUMBERP (I$1))
          (NOT (EQUAL (I$1) 0))
          (NUMBERP (J$1))
          (NOT (EQUAL (J$1) 0))
          (NOT (LESSP (PATLEN$0) (J$1)))
          (NOT (LESSP (STRLEN$0) (I$1)))
          (NOT (LESSP (STRLEN$0)
                      (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))))
          (NOT (LESSP (I$1) (J$1)))
          (MATCH (PAT$0)
                 (ADD1 (J$1))
                 (PATLEN$0)
                 (STR$0)
                 (ADD1 (I$1))
                 (STRLEN$0))
          (NOT (EQUAL (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      0))
          (EQUAL (PLUS (I$1)
                       (DELTA1 (PAT$0)
                               (ELT1 (STR$0) (I$1))
                               (PATLEN$0)))
                 0)
          (NOT (EQUAL (ADD1 (PLUS (PATLEN$0)
                                  (DIFFERENCE (I$1) (J$1))))
                      0))
          (NOT
              (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (ADD1 (PLUS (PATLEN$0)
                                                   (DIFFERENCE (I$1) (J$1))))))
                     (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                 (SUB1 (PLUS (PATLEN$0)
                                             (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (ADD1 (PLUS (PATLEN$0)
                                              (DIFFERENCE (I$1) (J$1))))))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES
         (AND
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (NOT (EQUAL (PLUS (I$1)
                               (DELTA1 (PAT$0)
                                       (ELT1 (STR$0) (I$1))
                                       (PATLEN$0)))
                         0))
             (NOT (LESSP (SUB1 (PLUS (I$1)
                                     (DELTA1 (PAT$0)
                                             (ELT1 (STR$0) (I$1))
                                             (PATLEN$0))))
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (I$1)
                                                 (DELTA1 (PAT$0)
                                                         (ELT1 (STR$0) (I$1))
                                                         (PATLEN$0)))))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))),

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

        (IMPLIES
         (AND
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (SUB1 (PLUS (I$1)
                                (DELTA1 (PAT$0)
                                        (ELT1 (STR$0) (I$1))
                                        (PATLEN$0)))))
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (NOT (EQUAL (PLUS (I$1)
                               (DELTA1 (PAT$0)
                                       (ELT1 (STR$0) (I$1))
                                       (PATLEN$0)))
                         0))
             (NOT (LESSP (SUB1 (PLUS (I$1)
                                     (DELTA1 (PAT$0)
                                             (ELT1 (STR$0) (I$1))
                                             (PATLEN$0))))
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (I$1)
                                                 (DELTA1 (PAT$0)
                                                         (ELT1 (STR$0) (I$1))
                                                         (PATLEN$0)))))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (PATLEN$0) (SUB1 (J$1)))).

  But this again simplifies, using linear arithmetic and rewriting with
  DELTA1-LESSEQP-PATLEN, to:

        T.

Case 1. (IMPLIES
         (AND
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (NOT (EQUAL (PLUS (I$1)
                               (DELTA1 (PAT$0)
                                       (ELT1 (STR$0) (I$1))
                                       (PATLEN$0)))
                         0))
             (NOT (LESSP (SUB1 (PLUS (I$1)
                                     (DELTA1 (PAT$0)
                                             (ELT1 (STR$0) (I$1))
                                             (PATLEN$0))))
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (I$1)
                                                 (DELTA1 (PAT$0)
                                                         (ELT1 (STR$0) (I$1))
                                                         (PATLEN$0)))))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (I$1)
                                        (DELTA1 (PAT$0)
                                                (ELT1 (STR$0) (I$1))
                                                (PATLEN$0)))))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))).

  This again simplifies, using linear arithmetic, to:

        (IMPLIES
         (AND
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (SUB1 (PLUS (I$1)
                                (DELTA1 (PAT$0)
                                        (ELT1 (STR$0) (I$1))
                                        (PATLEN$0)))))
             (NOT (EQUAL (ELT1 (STR$0) (I$1))
                         (ELT1 (PAT$0) (J$1))))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (NOT (EQUAL (PLUS (I$1)
                               (DELTA1 (PAT$0)
                                       (ELT1 (STR$0) (I$1))
                                       (PATLEN$0)))
                         0))
             (NOT (LESSP (SUB1 (PLUS (I$1)
                                     (DELTA1 (PAT$0)
                                             (ELT1 (STR$0) (I$1))
                                             (PATLEN$0))))
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (I$1)
                                                 (DELTA1 (PAT$0)
                                                         (ELT1 (STR$0) (I$1))
                                                         (PATLEN$0)))))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (EQUAL (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (I$1)
                                        (DELTA1 (PAT$0)
                                                (ELT1 (STR$0) (I$1))
                                                (PATLEN$0)))))
                (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                            (SUB1 (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1))))))).

  However this again simplifies, using linear arithmetic and rewriting with
  DELTA1-LESSEQP-PATLEN, to:

        T.

Q.E.D.


[ 0.0 0.8 0.1 ]

OUTER-INVRT1


(UBT LOGICAL-IF-T)

LOGICAL-IF-T


(ADD-AXIOM LOGICAL-IF-F NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-F


(ADD-AXIOM LOGICAL-IF-T NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-T


(PROVE-LEMMA FIRST-MATCH-IS-SEARCH
             (REWRITE)
             (IMPLIES (AND (MATCH PAT 1 PATLEN STR I STRLEN)
                           (NUMBERP STRLEN)
                           (NUMBERP I)
                           (NOT (LESSP STRLEN I))
                           (NUMBERP K)
                           (NOT (LESSP I K))
                           (NOT (EQUAL K 0))
                           (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN K)
                                       I)))
                      (EQUAL (EQUAL I
                                    (SEARCH PAT STR PATLEN STRLEN K))
                             T)))


     Give the conjecture the name *1.


     We will appeal to induction.  There are eight plausible inductions.  They
merge into three likely candidate inductions, two of which are unflawed.  So
we will choose the one suggested by the largest number of nonprimitive
recursive functions.  We will induct according to the following scheme:
      (AND (IMPLIES (LESSP STRLEN K)
                    (p I PAT STR PATLEN STRLEN K))
           (IMPLIES (AND (NOT (LESSP STRLEN K))
                         (MATCH PAT 1 PATLEN STR K STRLEN))
                    (p I PAT STR PATLEN STRLEN K))
           (IMPLIES (AND (NOT (LESSP STRLEN K))
                         (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                         (p I PAT STR PATLEN STRLEN (ADD1 K)))
                    (p I PAT STR PATLEN STRLEN K))).
Linear arithmetic establishes that the measure (DIFFERENCE (ADD1 STRLEN) K)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme produces the following six new
goals:

Case 6. (IMPLIES (AND (LESSP STRLEN K)
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP K)
                      (NOT (LESSP I K))
                      (NOT (EQUAL K 0))
                      (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN K)
                                  I)))
                 (EQUAL I
                        (SEARCH PAT STR PATLEN STRLEN K))).

  This simplifies, using linear arithmetic, to:

        T.

Case 5. (IMPLIES (AND (NOT (LESSP STRLEN K))
                      (MATCH PAT 1 PATLEN STR K STRLEN)
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP K)
                      (NOT (LESSP I K))
                      (NOT (EQUAL K 0))
                      (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN K)
                                  I)))
                 (EQUAL I
                        (SEARCH PAT STR PATLEN STRLEN K))).

  This simplifies, unfolding SEARCH, to:

        (IMPLIES (AND (NOT (LESSP STRLEN K))
                      (MATCH PAT 1 PATLEN STR K STRLEN)
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP K)
                      (NOT (LESSP I K))
                      (NOT (EQUAL K 0))
                      (NOT (LESSP K I)))
                 (EQUAL I K)),

  which again simplifies, using linear arithmetic, to:

        T.

Case 4. (IMPLIES (AND (NOT (LESSP STRLEN K))
                      (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (LESSP I (ADD1 K))
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP K)
                      (NOT (LESSP I K))
                      (NOT (EQUAL K 0))
                      (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN K)
                                  I)))
                 (EQUAL I
                        (SEARCH PAT STR PATLEN STRLEN K))),

  which simplifies, using linear arithmetic, to:

        (IMPLIES (AND (NOT (LESSP STRLEN I))
                      (NOT (MATCH PAT 1 PATLEN STR I STRLEN))
                      (LESSP I (ADD1 I))
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP I)
                      (NOT (LESSP I I))
                      (NOT (EQUAL I 0))
                      (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN I)
                                  I)))
                 (EQUAL I
                        (SEARCH PAT STR PATLEN STRLEN I))).

  This again simplifies, obviously, to:

        T.

Case 3. (IMPLIES (AND (NOT (LESSP STRLEN K))
                      (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (EQUAL (ADD1 K) 0)
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP K)
                      (NOT (LESSP I K))
                      (NOT (EQUAL K 0))
                      (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN K)
                                  I)))
                 (EQUAL I
                        (SEARCH PAT STR PATLEN STRLEN K))).

  This simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (NOT (LESSP STRLEN K))
                      (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (LESSP (SEARCH PAT STR PATLEN STRLEN
                                     (ADD1 K))
                             I)
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP K)
                      (NOT (LESSP I K))
                      (NOT (EQUAL K 0))
                      (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN K)
                                  I)))
                 (EQUAL I
                        (SEARCH PAT STR PATLEN STRLEN K))).

  This simplifies, opening up SEARCH, to:

        T.

Case 1. (IMPLIES (AND (NOT (LESSP STRLEN K))
                      (NOT (MATCH PAT 1 PATLEN STR K STRLEN))
                      (EQUAL I
                             (SEARCH PAT STR PATLEN STRLEN
                                     (ADD1 K)))
                      (MATCH PAT 1 PATLEN STR I STRLEN)
                      (NUMBERP STRLEN)
                      (NUMBERP I)
                      (NOT (LESSP STRLEN I))
                      (NUMBERP K)
                      (NOT (LESSP I K))
                      (NOT (EQUAL K 0))
                      (NOT (LESSP (SEARCH PAT STR PATLEN STRLEN K)
                                  I)))
                 (EQUAL I
                        (SEARCH PAT STR PATLEN STRLEN K))).

  This simplifies, expanding the function SEARCH, to:

        T.


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


[ 0.0 0.1 0.0 ]

FIRST-MATCH-IS-SEARCH


(ADD-AXIOM ASSIGNMENT2
           (REWRITE)
           (AND (EQUAL (I$3) (I$2))
                (AND (EQUAL (J$3) (J$2))
                     (AND (EQUAL (C$3) (C$2))
                          (AND (EQUAL (NEXTI$3) (NEXTI$2))
                               (AND (EQUAL (X$3) (I$2))
                                    (EQUAL (BLK-DELTA1$3)
                                           (BLK-DELTA1$2))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT2 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT2


(PROVE-LEMMA OUTPUT NIL
             (IMPLIES (AND (ZEQP (J$2) '1)
                           (AND (NOT (ZNEQP (C$2) (ELT1 (PAT$0) (J$2))))
                                (PATH-HYPS)))
                      (EQUAL (X$3)
                             (SEARCH (PAT$0)
                                     (STR$0)
                                     (PATLEN$0)
                                     (STRLEN$0)
                                     '1))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, ZNEQP, NOT, AND, IMPLIES, ASSIGNMENT2,
ASSIGNMENT1, and ZEQP, to the new conjecture:

      (IMPLIES (AND (EQUAL (ZNORMALIZE (J$1))
                           (ZNORMALIZE 1))
                    (EQUAL (ZNORMALIZE (ELT1 (STR$0) (I$1)))
                           (ZNORMALIZE (ELT1 (PAT$0) (J$1))))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))
                                (ADD1 (PATLEN$0))))
                    (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PLUS (PATLEN$0)
                                       (SEARCH (PAT$0)
                                               (STR$0)
                                               (PATLEN$0)
                                               (STRLEN$0)
                                               1))))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1))))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (ADD1 (STRLEN$0))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0))
                    (NUMBERP (ELT1 (BLK-DELTA1$1)
                                   (ELT1 (STR$0) (I$1))))
                    (NUMBERP (ELT1 (STR$0) (I$1)))
                    (NUMBERP (ELT1 (PAT$0) (J$1))))
               (EQUAL (I$1)
                      (SEARCH (PAT$0)
                              (STR$0)
                              (PATLEN$0)
                              (STRLEN$0)
                              1))),

which simplifies, using linear arithmetic, applying
STRINGP-IS-A-UNIV-QUANTIFIER, SUB1-ADD1, and PATHS-FROM-INNER-INVRT, and
unfolding the definitions of ZNORMALIZE, EQUAL, LESSP, PLUS, NUMBERP, and ADD1,
to the following two new formulas:

Case 2. (IMPLIES (AND (EQUAL (J$1) 1)
                      (NOT (EQUAL (NEGATIVE-GUTS (ELT1 (PAT$0) 1))
                                  0))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) 1))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0) (DIFFERENCE (I$1) 1))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0) (DIFFERENCE (I$1) 1))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (PATLEN$0) 1))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) 1))))
                      (NOT (LESSP (I$1) 1))
                      (MATCH (PAT$0)
                             2
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (EQUAL (I$1)
                        (SEARCH (PAT$0)
                                (STR$0)
                                (PATLEN$0)
                                (STRLEN$0)
                                1))).

  This again simplifies, using linear arithmetic, applying the lemma
  FIRST-MATCH-IS-SEARCH, and expanding the definitions of EQUAL, MATCH, and
  ADD1, to:

        T.

Case 1. (IMPLIES (AND (EQUAL (J$1) 1)
                      (NOT (NEGATIVEP (ELT1 (PAT$0) 1)))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) 1))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0) (DIFFERENCE (I$1) 1))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0) (DIFFERENCE (I$1) 1))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NOT (LESSP (PATLEN$0) 1))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) 1))))
                      (NOT (LESSP (I$1) 1))
                      (MATCH (PAT$0)
                             2
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (EQUAL (I$1)
                        (SEARCH (PAT$0)
                                (STR$0)
                                (PATLEN$0)
                                (STRLEN$0)
                                1))),

  which again simplifies, using linear arithmetic, rewriting with
  FIRST-MATCH-IS-SEARCH, and expanding EQUAL, MATCH, and ADD1, to:

        T.

Q.E.D.


[ 0.0 0.8 0.0 ]

OUTPUT


(UBT LOGICAL-IF-T)

LOGICAL-IF-T


(ADD-AXIOM LOGICAL-IF-F1 NIL T)

[ 0.0 0.0 0.0 ]

LOGICAL-IF-F1


(PROVE-LEMMA INPUT-COND-OF-ZDIFFERENCE NIL
             (IMPLIES (AND (NOT (ZEQP (J$2) '1))
                           (AND (NOT (ZNEQP (C$2) (ELT1 (PAT$0) (J$2))))
                                (PATH-HYPS)))
                      (EXPRESSIBLE-ZNUMBERP (ZDIFFERENCE (J$2) '1))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, ZNEQP, NOT, AND, IMPLIES, ASSIGNMENT1, and
ZEQP, to the new conjecture:

      (IMPLIES (AND (NOT (EQUAL (ZNORMALIZE (J$1))
                                (ZNORMALIZE 1)))
                    (EQUAL (ZNORMALIZE (ELT1 (STR$0) (I$1)))
                           (ZNORMALIZE (ELT1 (PAT$0) (J$1))))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))
                                (ADD1 (PATLEN$0))))
                    (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PLUS (PATLEN$0)
                                       (SEARCH (PAT$0)
                                               (STR$0)
                                               (PATLEN$0)
                                               (STRLEN$0)
                                               1))))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1))))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (ADD1 (STRLEN$0))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0))
                    (NUMBERP (ELT1 (BLK-DELTA1$1)
                                   (ELT1 (STR$0) (I$1))))
                    (NUMBERP (ELT1 (STR$0) (I$1)))
                    (NUMBERP (ELT1 (PAT$0) (J$1))))
               (EXPRESSIBLE-ZNUMBERP (ZDIFFERENCE (J$1) 1))),

which simplifies, using linear arithmetic, rewriting with SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, and PATHS-FROM-INNER-INVRT, and opening up the
functions ZNORMALIZE, LESSP, EQUAL, PLUS, NEGATIVEP, and ZDIFFERENCE, to the
following two new formulas:

Case 2. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (NOT (LESSP (J$1) 1)))
                 (EXPRESSIBLE-ZNUMBERP (DIFFERENCE (J$1) 1))).

  This again simplifies, expanding ZLESSP and EXPRESSIBLE-ZNUMBERP, to two new
  goals:

  Case 2.2.
          (IMPLIES
           (AND
               (NOT (EQUAL (J$1) 1))
               (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1)))
               (NOT (EQUAL (ASIZE&) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (NOT (EQUAL (PATLEN$0) 0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (NOT (EQUAL (STRLEN$0) 0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))
                           (PATLEN$0)))
               (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PLUS (PATLEN$0)
                            (SEARCH (PAT$0)
                                    (STR$0)
                                    (PATLEN$0)
                                    (STRLEN$0)
                                    1)))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (STRLEN$0)
                           (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (NOT (LESSP (J$1) 1))
               (EQUAL (NEGATIVE-GUTS (GREATEST-INEXPRESSIBLE-NEGATIVE-INTEGER))
                      0))
           (NOT (EQUAL (DIFFERENCE (J$1) 1) 0))),

    which again simplifies, using linear arithmetic and applying INTEGER-SIZE,
    to:

          T.

  Case 2.1.
          (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                        (EQUAL (ELT1 (STR$0) (I$1))
                               (ELT1 (PAT$0) (J$1)))
                        (NOT (EQUAL (ASIZE&) 0))
                        (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                    0))
                        (LESSP (ASIZE&)
                               (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                        (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                        (NOT (EQUAL (PATLEN$0) 0))
                        (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                        (NOT (EQUAL (STRLEN$0) 0))
                        (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                               (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                        (NUMBERP (PATLEN$0))
                        (NUMBERP (STRLEN$0))
                        (NOT (LESSP (PLUS (PATLEN$0)
                                          (DIFFERENCE (I$1) (J$1)))
                                    (PATLEN$0)))
                        (LESSP (PLUS (PATLEN$0)
                                     (DIFFERENCE (I$1) (J$1)))
                               (PLUS (PATLEN$0)
                                     (SEARCH (PAT$0)
                                             (STR$0)
                                             (PATLEN$0)
                                             (STRLEN$0)
                                             1)))
                        (NUMBERP (I$1))
                        (NOT (EQUAL (I$1) 0))
                        (NUMBERP (J$1))
                        (NOT (EQUAL (J$1) 0))
                        (NOT (LESSP (PATLEN$0) (J$1)))
                        (NOT (LESSP (STRLEN$0) (I$1)))
                        (NOT (LESSP (STRLEN$0)
                                    (PLUS (PATLEN$0)
                                          (DIFFERENCE (I$1) (J$1)))))
                        (NOT (LESSP (I$1) (J$1)))
                        (MATCH (PAT$0)
                               (ADD1 (J$1))
                               (PATLEN$0)
                               (STR$0)
                               (ADD1 (I$1))
                               (STRLEN$0))
                        (NOT (LESSP (J$1) 1)))
                   (LESSP (DIFFERENCE (J$1) 1)
                          (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))).

    However this again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (LESSP (J$1) 1))
                 (EXPRESSIBLE-ZNUMBERP (MINUS (DIFFERENCE 1 (J$1))))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.3 0.0 ]

INPUT-COND-OF-ZDIFFERENCE


(ADD-AXIOM ASSIGNMENT2
           (REWRITE)
           (AND (EQUAL (I$3) (I$2))
                (AND (EQUAL (J$3) (ZDIFFERENCE (J$2) '1))
                     (AND (EQUAL (C$3) (C$2))
                          (AND (EQUAL (NEXTI$3) (NEXTI$2))
                               (AND (EQUAL (X$3) (X$2))
                                    (EQUAL (BLK-DELTA1$3)
                                           (BLK-DELTA1$2))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT2 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT2


(PROVE-LEMMA INPUT-COND-OF-ZDIFFERENCE1 NIL
             (IMPLIES (AND (NOT (ZEQP (J$2) '1))
                           (AND (NOT (ZNEQP (C$2) (ELT1 (PAT$0) (J$2))))
                                (PATH-HYPS)))
                      (EXPRESSIBLE-ZNUMBERP (ZDIFFERENCE (I$3) '1))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS,
PATHS-FROM-INNER-INVRT, PATH-HYPS, ZNEQP, NOT, AND, IMPLIES, ASSIGNMENT2,
ASSIGNMENT1, and ZEQP, to the new conjecture:

      (IMPLIES (AND (NOT (EQUAL (ZNORMALIZE (J$1))
                                (ZNORMALIZE 1)))
                    (EQUAL (ZNORMALIZE (ELT1 (STR$0) (I$1)))
                           (ZNORMALIZE (ELT1 (PAT$0) (J$1))))
                    (NOT (EQUAL (ASIZE&) 0))
                    (LESSP (ADD1 (ASIZE&))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                    (LESSP 0 (PATLEN$0))
                    (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                    (LESSP 0 (STRLEN$0))
                    (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                           (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                    (NUMBERP (PATLEN$0))
                    (NUMBERP (STRLEN$0))
                    (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))
                                (ADD1 (PATLEN$0))))
                    (LESSP (PLUS (ADD1 (PATLEN$0))
                                 (DIFFERENCE (I$1) (J$1)))
                           (ADD1 (PLUS (PATLEN$0)
                                       (SEARCH (PAT$0)
                                               (STR$0)
                                               (PATLEN$0)
                                               (STRLEN$0)
                                               1))))
                    (NUMBERP (I$1))
                    (NOT (EQUAL (I$1) 0))
                    (NUMBERP (J$1))
                    (NOT (EQUAL (J$1) 0))
                    (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1))))
                    (NOT (LESSP (PATLEN$0) (J$1)))
                    (NOT (LESSP (STRLEN$0) (I$1)))
                    (NOT (LESSP (ADD1 (STRLEN$0))
                                (PLUS (ADD1 (PATLEN$0))
                                      (DIFFERENCE (I$1) (J$1)))))
                    (NOT (LESSP (I$1) (J$1)))
                    (MATCH (PAT$0)
                           (ADD1 (J$1))
                           (PATLEN$0)
                           (STR$0)
                           (ADD1 (I$1))
                           (STRLEN$0))
                    (NUMBERP (ELT1 (BLK-DELTA1$1)
                                   (ELT1 (STR$0) (I$1))))
                    (NUMBERP (ELT1 (STR$0) (I$1)))
                    (NUMBERP (ELT1 (PAT$0) (J$1))))
               (EXPRESSIBLE-ZNUMBERP (ZDIFFERENCE (I$1) 1))),

which simplifies, using linear arithmetic, rewriting with SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, and PATHS-FROM-INNER-INVRT, and opening up the
functions ZNORMALIZE, LESSP, EQUAL, PLUS, NEGATIVEP, and ZDIFFERENCE, to the
following two new formulas:

Case 2. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (NOT (LESSP (I$1) 1)))
                 (EXPRESSIBLE-ZNUMBERP (DIFFERENCE (I$1) 1))).

  This again simplifies, expanding ZLESSP and EXPRESSIBLE-ZNUMBERP, to two new
  goals:

  Case 2.2.
          (IMPLIES
           (AND
               (NOT (EQUAL (J$1) 1))
               (EQUAL (ELT1 (STR$0) (I$1))
                      (ELT1 (PAT$0) (J$1)))
               (NOT (EQUAL (ASIZE&) 0))
               (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                           0))
               (LESSP (ASIZE&)
                      (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
               (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
               (NOT (EQUAL (PATLEN$0) 0))
               (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
               (NOT (EQUAL (STRLEN$0) 0))
               (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                      (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
               (NUMBERP (PATLEN$0))
               (NUMBERP (STRLEN$0))
               (NOT (LESSP (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))
                           (PATLEN$0)))
               (LESSP (PLUS (PATLEN$0)
                            (DIFFERENCE (I$1) (J$1)))
                      (PLUS (PATLEN$0)
                            (SEARCH (PAT$0)
                                    (STR$0)
                                    (PATLEN$0)
                                    (STRLEN$0)
                                    1)))
               (NUMBERP (I$1))
               (NOT (EQUAL (I$1) 0))
               (NUMBERP (J$1))
               (NOT (EQUAL (J$1) 0))
               (NOT (LESSP (PATLEN$0) (J$1)))
               (NOT (LESSP (STRLEN$0) (I$1)))
               (NOT (LESSP (STRLEN$0)
                           (PLUS (PATLEN$0)
                                 (DIFFERENCE (I$1) (J$1)))))
               (NOT (LESSP (I$1) (J$1)))
               (MATCH (PAT$0)
                      (ADD1 (J$1))
                      (PATLEN$0)
                      (STR$0)
                      (ADD1 (I$1))
                      (STRLEN$0))
               (NOT (LESSP (I$1) 1))
               (EQUAL (NEGATIVE-GUTS (GREATEST-INEXPRESSIBLE-NEGATIVE-INTEGER))
                      0))
           (NOT (EQUAL (DIFFERENCE (I$1) 1) 0))),

    which again simplifies, using linear arithmetic and applying INTEGER-SIZE,
    to:

          T.

  Case 2.1.
          (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                        (EQUAL (ELT1 (STR$0) (I$1))
                               (ELT1 (PAT$0) (J$1)))
                        (NOT (EQUAL (ASIZE&) 0))
                        (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                    0))
                        (LESSP (ASIZE&)
                               (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                        (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                        (NOT (EQUAL (PATLEN$0) 0))
                        (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                        (NOT (EQUAL (STRLEN$0) 0))
                        (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                               (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                        (NUMBERP (PATLEN$0))
                        (NUMBERP (STRLEN$0))
                        (NOT (LESSP (PLUS (PATLEN$0)
                                          (DIFFERENCE (I$1) (J$1)))
                                    (PATLEN$0)))
                        (LESSP (PLUS (PATLEN$0)
                                     (DIFFERENCE (I$1) (J$1)))
                               (PLUS (PATLEN$0)
                                     (SEARCH (PAT$0)
                                             (STR$0)
                                             (PATLEN$0)
                                             (STRLEN$0)
                                             1)))
                        (NUMBERP (I$1))
                        (NOT (EQUAL (I$1) 0))
                        (NUMBERP (J$1))
                        (NOT (EQUAL (J$1) 0))
                        (NOT (LESSP (PATLEN$0) (J$1)))
                        (NOT (LESSP (STRLEN$0) (I$1)))
                        (NOT (LESSP (STRLEN$0)
                                    (PLUS (PATLEN$0)
                                          (DIFFERENCE (I$1) (J$1)))))
                        (NOT (LESSP (I$1) (J$1)))
                        (MATCH (PAT$0)
                               (ADD1 (J$1))
                               (PATLEN$0)
                               (STR$0)
                               (ADD1 (I$1))
                               (STRLEN$0))
                        (NOT (LESSP (I$1) 1)))
                   (LESSP (DIFFERENCE (I$1) 1)
                          (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))).

    However this again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (LESSP (I$1) 1))
                 (EXPRESSIBLE-ZNUMBERP (MINUS (DIFFERENCE 1 (I$1))))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.3 0.0 ]

INPUT-COND-OF-ZDIFFERENCE1


(ADD-AXIOM ASSIGNMENT3
           (REWRITE)
           (AND (EQUAL (I$4) (ZDIFFERENCE (I$3) '1))
                (AND (EQUAL (J$4) (J$3))
                     (AND (EQUAL (C$4) (C$3))
                          (AND (EQUAL (NEXTI$4) (NEXTI$3))
                               (AND (EQUAL (X$4) (X$3))
                                    (EQUAL (BLK-DELTA1$4)
                                           (BLK-DELTA1$3))))))))

WARNING:  Note that the proposed lemma ASSIGNMENT3 is to be stored as zero
type prescription rules, zero compound recognizer rules, zero linear rules,
and six replacement rules.


[ 0.0 0.0 0.0 ]

ASSIGNMENT3


(PROVE-LEMMA OPEN-UP-DIFFERENCE
             (REWRITE)
             (EQUAL (DIFFERENCE X 1) (SUB1 X)))

This simplifies, using linear arithmetic, to:

      (IMPLIES (LESSP X 1)
               (EQUAL (DIFFERENCE X 1) (SUB1 X))).

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

Case 3. (IMPLIES (AND (EQUAL X 0) (LESSP X 1))
                 (EQUAL (DIFFERENCE X 1) (SUB1 X))),

  which further simplifies, expanding the functions LESSP, DIFFERENCE, SUB1,
  and EQUAL, to:

        T.

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

  which further simplifies, appealing to the lemma SUB1-NNUMBERP, and
  unfolding the functions NUMBERP, EQUAL, LESSP, and DIFFERENCE, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP Z)
                      (NOT (EQUAL (ADD1 Z) 0))
                      (LESSP (ADD1 Z) 1))
                 (EQUAL (DIFFERENCE (ADD1 Z) 1) Z)),

  which further simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

OPEN-UP-DIFFERENCE


(PROVE-LEMMA INNER-INVRT1 NIL
 (IMPLIES
  (AND (NOT (ZEQP (J$2) '1))
       (AND (NOT (ZNEQP (C$2) (ELT1 (PAT$0) (J$2))))
            (PATH-HYPS)))
  (AND
   (AND
    (NOT (LESSP (NEXTI$4) (ADD1 (PATLEN$0))))
    (AND
     (LESSP (NEXTI$4)
            (ADD1 (PLUS (PATLEN$0)
                        (SEARCH (PAT$0)
                                (STR$0)
                                (PATLEN$0)
                                (STRLEN$0)
                                '1))))
     (AND
      (IMPLIES (AND (NUMBERP C)
                    (AND (NOT (EQUAL C '0))
                         (NOT (LESSP (ASIZE&) C))))
               (EQUAL (ELT1 (BLK-DELTA1$4) C)
                      (DELTA1 (PAT$0) C (PATLEN$0))))
      (AND
       (NUMBERP (I$4))
       (AND
        (NOT (EQUAL (I$4) '0))
        (AND
         (NUMBERP (J$4))
         (AND
          (NOT (EQUAL (J$4) '0))
          (AND
           (NUMBERP (NEXTI$4))
           (AND
            (NOT (LESSP (PATLEN$0) (J$4)))
            (AND
             (NOT (LESSP (STRLEN$0) (I$4)))
             (AND
              (EQUAL (NEXTI$4)
                     (PLUS (ADD1 (PATLEN$0))
                           (DIFFERENCE (I$4) (J$4))))
              (AND
               (NOT (LESSP (ADD1 (STRLEN$0)) (NEXTI$4)))
               (AND
                  (NOT (LESSP (I$4) (J$4)))
                  (AND (MATCH (PAT$0)
                              (ADD1 (J$4))
                              (PATLEN$0)
                              (STR$0)
                              (ADD1 (I$4))
                              (STRLEN$0))
                       (AND (NUMBERP (ELT1 (BLK-DELTA1$4)
                                           (ELT1 (STR$0) (I$4))))
                            (AND (NUMBERP (ELT1 (STR$0) (I$4)))
                                 (NUMBERP (ELT1 (PAT$0) (J$4)))))))))))))))))))
   (LEX (CONS (DIFFERENCE (PLUS '1
                                (PLUS (STRLEN$0) (PATLEN$0)))
                          (SUB1 (NEXTI$4)))
              (CONS (J$4) 'NIL))
        (CONS (DIFFERENCE (PLUS '1
                                (PLUS (STRLEN$0) (PATLEN$0)))
                          (SUB1 (NEXTI$1)))
              (CONS (J$1) 'NIL))))))

This formula can be simplified, using the abbreviations GLOBAL-HYPS, PATH-HYPS,
ZNEQP, NOT, AND, IMPLIES, PATHS-FROM-INNER-INVRT, ASSIGNMENT2, ASSIGNMENT3,
ASSIGNMENT1, and ZEQP, to the new goal:

      (IMPLIES
            (AND (NOT (EQUAL (ZNORMALIZE (J$1))
                             (ZNORMALIZE 1)))
                 (EQUAL (ZNORMALIZE (ELT1 (STR$0) (I$1)))
                        (ZNORMALIZE (ELT1 (PAT$0) (J$1))))
                 (NOT (EQUAL (ASIZE&) 0))
                 (LESSP (ADD1 (ASIZE&))
                        (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                 (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                 (LESSP 0 (PATLEN$0))
                 (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                 (LESSP 0 (STRLEN$0))
                 (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                        (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                 (NUMBERP (PATLEN$0))
                 (NUMBERP (STRLEN$0))
                 (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1)))
                             (ADD1 (PATLEN$0))))
                 (LESSP (PLUS (ADD1 (PATLEN$0))
                              (DIFFERENCE (I$1) (J$1)))
                        (ADD1 (PLUS (PATLEN$0)
                                    (SEARCH (PAT$0)
                                            (STR$0)
                                            (PATLEN$0)
                                            (STRLEN$0)
                                            1))))
                 (NUMBERP (I$1))
                 (NOT (EQUAL (I$1) 0))
                 (NUMBERP (J$1))
                 (NOT (EQUAL (J$1) 0))
                 (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                (DIFFERENCE (I$1) (J$1))))
                 (NOT (LESSP (PATLEN$0) (J$1)))
                 (NOT (LESSP (STRLEN$0) (I$1)))
                 (NOT (LESSP (ADD1 (STRLEN$0))
                             (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1)))))
                 (NOT (LESSP (I$1) (J$1)))
                 (MATCH (PAT$0)
                        (ADD1 (J$1))
                        (PATLEN$0)
                        (STR$0)
                        (ADD1 (I$1))
                        (STRLEN$0))
                 (NUMBERP (ELT1 (BLK-DELTA1$1)
                                (ELT1 (STR$0) (I$1))))
                 (NUMBERP (ELT1 (STR$0) (I$1)))
                 (NUMBERP (ELT1 (PAT$0) (J$1))))
            (AND (AND (NOT (LESSP (PLUS (ADD1 (PATLEN$0))
                                        (DIFFERENCE (I$1) (J$1)))
                                  (ADD1 (PATLEN$0))))
                      (LESSP (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1)))
                             (ADD1 (PLUS (PATLEN$0)
                                         (SEARCH (PAT$0)
                                                 (STR$0)
                                                 (PATLEN$0)
                                                 (STRLEN$0)
                                                 1))))
                      (IMPLIES (AND (NUMBERP C)
                                    (NOT (EQUAL C 0))
                                    (NOT (LESSP (ASIZE&) C)))
                               (EQUAL (ELT1 (BLK-DELTA1$1) C)
                                      (DELTA1 (PAT$0) C (PATLEN$0))))
                      (NUMBERP (ZDIFFERENCE (I$1) 1))
                      (NOT (EQUAL (ZDIFFERENCE (I$1) 1) 0))
                      (NUMBERP (ZDIFFERENCE (J$1) 1))
                      (NOT (EQUAL (ZDIFFERENCE (J$1) 1) 0))
                      (NUMBERP (PLUS (ADD1 (PATLEN$0))
                                     (DIFFERENCE (I$1) (J$1))))
                      (NOT (LESSP (PATLEN$0)
                                  (ZDIFFERENCE (J$1) 1)))
                      (NOT (LESSP (STRLEN$0)
                                  (ZDIFFERENCE (I$1) 1)))
                      (EQUAL (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (ADD1 (PATLEN$0))
                                   (DIFFERENCE (ZDIFFERENCE (I$1) 1)
                                               (ZDIFFERENCE (J$1) 1))))
                      (NOT (LESSP (ADD1 (STRLEN$0))
                                  (PLUS (ADD1 (PATLEN$0))
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (ZDIFFERENCE (I$1) 1)
                                  (ZDIFFERENCE (J$1) 1)))
                      (MATCH (PAT$0)
                             (ADD1 (ZDIFFERENCE (J$1) 1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (ZDIFFERENCE (I$1) 1))
                             (STRLEN$0))
                      (NUMBERP (ELT1 (BLK-DELTA1$1)
                                     (ELT1 (STR$0) (ZDIFFERENCE (I$1) 1))))
                      (NUMBERP (ELT1 (STR$0) (ZDIFFERENCE (I$1) 1)))
                      (NUMBERP (ELT1 (PAT$0) (ZDIFFERENCE (J$1) 1))))
                 (LEX (LIST (DIFFERENCE (PLUS 1 (STRLEN$0) (PATLEN$0))
                                        (SUB1 (PLUS (ADD1 (PATLEN$0))
                                                    (DIFFERENCE (I$1) (J$1)))))
                            (ZDIFFERENCE (J$1) 1))
                      (LIST (DIFFERENCE (PLUS 1 (STRLEN$0) (PATLEN$0))
                                        (SUB1 (PLUS (ADD1 (PATLEN$0))
                                                    (DIFFERENCE (I$1) (J$1)))))
                            (J$1))))),

which simplifies, using linear arithmetic, rewriting with SUB1-ADD1,
STRINGP-IS-A-UNIV-QUANTIFIER, PATHS-FROM-INNER-INVRT, OPEN-UP-DIFFERENCE,
ADD1-EQUAL, COMMUTATIVITY-OF-PLUS, CDR-CONS, and CAR-CONS, and opening up the
definitions of ZNORMALIZE, LESSP, EQUAL, PLUS, NOT, AND, IMPLIES, NEGATIVEP,
ZDIFFERENCE, SUB1, NUMBERP, DIFFERENCE, and LEX, to the following 15 new goals:

Case 15.(IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NOT (LESSP (J$1) 1))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 14.(IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NOT (LESSP (I$1) 1))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 13.(IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (NUMBERP C)
                      (NOT (EQUAL C 0))
                      (NOT (LESSP (ASIZE&) C)))
                 (EQUAL (ELT1 (BLK-DELTA1$1) C)
                        (DELTA1 (PAT$0) C (PATLEN$0)))),

  which again simplifies, applying the lemma PATHS-FROM-INNER-INVRT, to:

        T.

Case 12.(IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NOT (EQUAL (SUB1 (I$1)) 0))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 11.(IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NOT (EQUAL (SUB1 (J$1)) 0))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 10.(IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NOT (LESSP (PATLEN$0) (SUB1 (J$1))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 9. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NOT (LESSP (STRLEN$0) (SUB1 (I$1))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 8. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (EQUAL (PLUS (PATLEN$0)
                              (DIFFERENCE (I$1) (J$1)))
                        (PLUS (PATLEN$0)
                              (DIFFERENCE (SUB1 (I$1))
                                          (SUB1 (J$1)))))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES (AND (LESSP (SUB1 (I$1)) (SUB1 (J$1)))
                      (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (EQUAL (PLUS (PATLEN$0)
                              (DIFFERENCE (I$1) (J$1)))
                        (PLUS (PATLEN$0)
                              (DIFFERENCE (SUB1 (I$1))
                                          (SUB1 (J$1)))))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 7. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NOT (LESSP (SUB1 (I$1)) (SUB1 (J$1))))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 6. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (MATCH (PAT$0)
                        (ADD1 (SUB1 (J$1)))
                        (PATLEN$0)
                        (STR$0)
                        (ADD1 (SUB1 (I$1)))
                        (STRLEN$0))),

  which again simplifies, applying ADD1-SUB1, and unfolding the function MATCH,
  to:

        T.

Case 5. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NUMBERP (ELT1 (BLK-DELTA1$1)
                                (ELT1 (STR$0) (SUB1 (I$1)))))).

  However this again simplifies, using linear arithmetic and applying
  STRINGP-IS-A-UNIV-QUANTIFIER and PATHS-FROM-INNER-INVRT, to:

        T.

Case 4. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NUMBERP (ELT1 (STR$0) (SUB1 (I$1))))).

  However this again simplifies, using linear arithmetic and applying the
  lemma STRINGP-IS-A-UNIV-QUANTIFIER, to:

        T.

Case 3. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0)))
                 (NUMBERP (ELT1 (PAT$0) (SUB1 (J$1))))),

  which again simplifies, using linear arithmetic and rewriting with
  STRINGP-IS-A-UNIV-QUANTIFIER, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL (J$1) 1))
                      (EQUAL (ELT1 (STR$0) (I$1))
                             (ELT1 (PAT$0) (J$1)))
                      (NOT (EQUAL (ASIZE&) 0))
                      (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                                  0))
                      (LESSP (ASIZE&)
                             (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
                      (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
                      (NOT (EQUAL (PATLEN$0) 0))
                      (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
                      (NOT (EQUAL (STRLEN$0) 0))
                      (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                             (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
                      (NUMBERP (PATLEN$0))
                      (NUMBERP (STRLEN$0))
                      (NOT (LESSP (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))
                                  (PATLEN$0)))
                      (LESSP (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             (PLUS (PATLEN$0)
                                   (SEARCH (PAT$0)
                                           (STR$0)
                                           (PATLEN$0)
                                           (STRLEN$0)
                                           1)))
                      (NUMBERP (I$1))
                      (NOT (EQUAL (I$1) 0))
                      (NUMBERP (J$1))
                      (NOT (EQUAL (J$1) 0))
                      (NOT (LESSP (PATLEN$0) (J$1)))
                      (NOT (LESSP (STRLEN$0) (I$1)))
                      (NOT (LESSP (STRLEN$0)
                                  (PLUS (PATLEN$0)
                                        (DIFFERENCE (I$1) (J$1)))))
                      (NOT (LESSP (I$1) (J$1)))
                      (MATCH (PAT$0)
                             (ADD1 (J$1))
                             (PATLEN$0)
                             (STR$0)
                             (ADD1 (I$1))
                             (STRLEN$0))
                      (EQUAL (PLUS (PATLEN$0)
                                   (DIFFERENCE (I$1) (J$1)))
                             0)
                      (NOT (LESSP (ADD1 (PLUS (PATLEN$0) (STRLEN$0)))
                                  (ADD1 (PLUS (PATLEN$0) (STRLEN$0))))))
                 (LESSP (SUB1 (J$1)) (J$1))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES
         (AND
             (NOT (EQUAL (J$1) 1))
             (EQUAL (ELT1 (STR$0) (I$1))
                    (ELT1 (PAT$0) (J$1)))
             (NOT (EQUAL (ASIZE&) 0))
             (NOT (EQUAL (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)
                         0))
             (LESSP (ASIZE&)
                    (SUB1 (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER)))
             (STRINGP (PAT$0) (PATLEN$0) (ASIZE&))
             (NOT (EQUAL (PATLEN$0) 0))
             (STRINGP (STR$0) (STRLEN$0) (ASIZE&))
             (NOT (EQUAL (STRLEN$0) 0))
             (LESSP (PLUS (PATLEN$0) (STRLEN$0))
                    (LEAST-INEXPRESSIBLE-POSITIVE-INTEGER))
             (NUMBERP (PATLEN$0))
             (NUMBERP (STRLEN$0))
             (NOT (LESSP (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         (PATLEN$0)))
             (LESSP (PLUS (PATLEN$0)
                          (DIFFERENCE (I$1) (J$1)))
                    (PLUS (PATLEN$0)
                          (SEARCH (PAT$0)
                                  (STR$0)
                                  (PATLEN$0)
                                  (STRLEN$0)
                                  1)))
             (NUMBERP (I$1))
             (NOT (EQUAL (I$1) 0))
             (NUMBERP (J$1))
             (NOT (EQUAL (J$1) 0))
             (NOT (LESSP (PATLEN$0) (J$1)))
             (NOT (LESSP (STRLEN$0) (I$1)))
             (NOT (LESSP (STRLEN$0)
                         (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))))
             (NOT (LESSP (I$1) (J$1)))
             (MATCH (PAT$0)
                    (ADD1 (J$1))
                    (PATLEN$0)
                    (STR$0)
                    (ADD1 (I$1))
                    (STRLEN$0))
             (NOT (EQUAL (PLUS (PATLEN$0)
                               (DIFFERENCE (I$1) (J$1)))
                         0))
             (NOT (LESSP (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1)))))
                         (DIFFERENCE (PLUS (PATLEN$0) (STRLEN$0))
                                     (SUB1 (PLUS (PATLEN$0)
                                                 (DIFFERENCE (I$1) (J$1))))))))
         (LESSP (SUB1 (J$1)) (J$1))),

  which again simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 1.5 0.0 ]

INNER-INVRT1


(UBT PATHS-FROM-INNER-INVRT)

PATHS-FROM-INNER-INVRT


(UBT FORTRAN)

FORTRAN