(NOTE-LIB "mc20-2" T)
Loading ./yu/mc20-2.lib
Finished loading ./yu/mc20-2.lib
Loading ./yu/mc20-2.o
Loading ./yu/0mc20-2.o
Finished loading ./yu/0mc20-2.o
Loading ./yu/1mc20-2.o
Finished loading ./yu/1mc20-2.o
Finished loading ./yu/mc20-2.o

(#./yu/mc20-2.lib #./yu/mc20-2)


(DEFN ISQRT-CODE NIL
      '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0 78 118
           178 128 111 28 208 129 78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
           76 65 8 0 78 118 178 128 110 228 32 1 78 94 78 117))

     Observe that (LISTP (ISQRT-CODE)) is a theorem.




[ 0.0 0.0 0.0 ]

ISQRT-CODE


(DEFN SQ (X) (TIMES X X))

     Note that (NUMBERP (SQ X)) is a theorem.




[ 0.0 0.0 0.0 ]

SQ


(DEFN ISQRT1
      (I J)
      (IF (ZEROP J)
          (FIX I)
          (IF (LESSP (QUOTIENT I J) J)
              (ISQRT1 I
                      (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
              (FIX J))))

     The lemmas MEAN-LESSP, COUNT-NUMBERP, and QUOTIENT-TIMES-LESSP and the
definition of ZEROP establish that the measure (COUNT J) decreases according
to the well-founded relation LESSP in each recursive call.  Hence, ISQRT1 is
accepted under the definitional principle.  Note that (NUMBERP (ISQRT1 I J))
is a theorem.




[ 0.0 0.1 0.0 ]

ISQRT1


(DEFN ISQRT
      (I)
      (LET ((J1 (QUOTIENT (PLUS (QUOTIENT I 2)
                                (QUOTIENT I (QUOTIENT I 2)))
                          2)))
           (IF (LESSP I (SQ (QUOTIENT I 2)))
               (ISQRT1 I J1)
               (QUOTIENT I 2))))

     From the definition we can conclude that (NUMBERP (ISQRT I)) is a theorem.




[ 0.0 0.0 0.0 ]

ISQRT


(DEFN ISQRT1-T
      (I J)
      (IF (ZEROP J)
          0
          (IF (LESSP (QUOTIENT I J) J)
              (SPLUS 10
                     (ISQRT1-T I
                               (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
              8)))

     The lemmas MEAN-LESSP, COUNT-NUMBERP, and QUOTIENT-TIMES-LESSP and the
definition of ZEROP can be used to show that the measure (COUNT J) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
ISQRT1-T is accepted under the definitional principle.  From the definition we
can conclude that (NUMBERP (ISQRT1-T I J)) is a theorem.




[ 0.0 0.1 0.0 ]

ISQRT1-T


(DEFN ISQRT-T
      (I)
      (LET ((J1 (QUOTIENT (PLUS (QUOTIENT I 2)
                                (QUOTIENT I (QUOTIENT I 2)))
                          2)))
           (IF (LESSP I (SQ (QUOTIENT I 2)))
               (SPLUS 14 (ISQRT1-T I J1))
               12)))

     From the definition we can conclude that (NUMBERP (ISQRT-T I)) is a
theorem.




[ 0.0 0.0 0.0 ]

ISQRT-T


(ENABLE IPLUS)

[ 0.0 0.0 0.0 ]

IPLUS-ON


(ENABLE INTEGERP)

[ 0.0 0.0 0.0 ]

INTEGERP-ON


(ENABLE IQUOTIENT)

[ 0.0 0.0 0.0 ]

IQUOTIENT-ON


(ENABLE ILESSP)

[ 0.0 0.0 0.0 ]

ILESSP-ON


(DISABLE REMAINDER)

[ 0.0 0.0 0.0 ]

REMAINDER-OFF


(DISABLE QUOTIENT)

[ 0.0 0.0 0.0 ]

QUOTIENT-OFF


(PROVE-LEMMA ISQRT-NO-OVERFLOW
             (REWRITE)
             (IMPLIES (AND (INT-RANGEP (TIMES 2 J) N)
                           (LESSP (QUOTIENT I J) J))
                      (INT-RANGEP (PLUS J (QUOTIENT I J))
                                  N)))

This simplifies, using linear arithmetic, rewriting with QUOTIENT-TIMES-LESSP
and ABS-LESSP-INT-RANGEP, and expanding the functions EQUAL, ABS, and NEGP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ISQRT-NO-OVERFLOW


(PROVE-LEMMA J-NONZEROP
             (REWRITE)
             (IMPLIES (AND (LESSP 1 I) (LESSP 0 J))
                      (NOT (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                  0))))

This formula simplifies, rewriting with PLUS-EQUAL-0, LESSP-OF-1, SUB1-OF-1,
and QUOTIENT-EQUAL-0, and opening up the functions EQUAL, LESSP, NUMBERP, and
SUB1, to the new formula:

      (IMPLIES (AND (LESSP 1 I)
                    (NOT (EQUAL J 0))
                    (NUMBERP J))
               (NOT (EQUAL (PLUS J (QUOTIENT I J)) 1))).

Applying the lemma REMAINDER-QUOTIENT-ELIM, replace I by (PLUS Z (TIMES J X))
to eliminate (QUOTIENT I J) and (REMAINDER I J).  We employ REMAINDER-LESSP,
the type restriction lemma noted when QUOTIENT was introduced, and the type
restriction lemma noted when REMAINDER was introduced to restrict the new
variables.  This produces the following two new goals:

Case 2. (IMPLIES (AND (NOT (NUMBERP I))
                      (LESSP 1 I)
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (NOT (EQUAL (PLUS J (QUOTIENT I J)) 1))).

  This further simplifies, opening up the function LESSP, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X)
                      (NUMBERP Z)
                      (EQUAL (LESSP Z J) (NOT (ZEROP J)))
                      (LESSP 1 (PLUS Z (TIMES J X)))
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (NOT (EQUAL (PLUS J X) 1))),

  which further simplifies, opening up the functions ZEROP and NOT, to:

        (IMPLIES (AND (NUMBERP X)
                      (NUMBERP Z)
                      (LESSP Z J)
                      (LESSP 1 (PLUS Z (TIMES J X)))
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (NOT (EQUAL (PLUS J X) 1))),

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


     So now let us consider:

(IMPLIES (AND (LESSP 1 I) (LESSP 0 J))
         (NOT (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                     0))).

We gave this the name *1 above.  Perhaps we can prove it by induction.  There
are three plausible inductions.  They merge into two likely candidate
inductions, both of which are unflawed.  However, one of these is more likely
than the other.  We will induct according to the following scheme:
      (AND (IMPLIES (OR (EQUAL J 0) (NOT (NUMBERP J)))
                    (p J I))
           (IMPLIES (AND (NOT (OR (EQUAL J 0) (NOT (NUMBERP J))))
                         (OR (EQUAL 0 0) (NOT (NUMBERP 0))))
                    (p J I))
           (IMPLIES (AND (NOT (OR (EQUAL J 0) (NOT (NUMBERP J))))
                         (NOT (OR (EQUAL 0 0) (NOT (NUMBERP 0))))
                         (p (SUB1 J) I))
                    (p J I))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT inform us that the measure (COUNT J) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme leads to the following four new formulas:

Case 4. (IMPLIES (AND (OR (EQUAL J 0) (NOT (NUMBERP J)))
                      (LESSP 1 I)
                      (LESSP 0 J))
                 (NOT (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                             0))).

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

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL J 0) (NOT (NUMBERP J))))
                      (OR (EQUAL 0 0) (NOT (NUMBERP 0)))
                      (LESSP 1 I)
                      (LESSP 0 J))
                 (NOT (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                             0))).

  This simplifies, applying QUOTIENT-ADD1, and opening up the definitions of
  NOT, OR, EQUAL, NUMBERP, LESSP, PLUS, and SUB1, to two new conjectures:

  Case 3.2.
          (IMPLIES (AND (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (LESSP 1 I)
                        (NOT (EQUAL (REMAINDER (PLUS (SUB1 J) (QUOTIENT I J))
                                               2)
                                    1)))
                   (NOT (EQUAL (QUOTIENT (PLUS (SUB1 J) (QUOTIENT I J))
                                         2)
                               0))),

    which again simplifies, applying SUB1-OF-1, LESSP-OF-1, QUOTIENT-EQUAL-0,
    and PLUS-EQUAL-0, and unfolding the definitions of EQUAL, NUMBERP, SUB1,
    and LESSP, to the following three new goals:

    Case 3.2.3.
            (IMPLIES (AND (NOT (EQUAL J 0))
                          (NUMBERP J)
                          (LESSP 1 I)
                          (NOT (EQUAL (REMAINDER (PLUS (SUB1 J) (QUOTIENT I J))
                                                 2)
                                      1))
                          (EQUAL J 1))
                     (NUMBERP I)).

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

            T.

    Case 3.2.2.
            (IMPLIES (AND (NOT (EQUAL J 0))
                          (NUMBERP J)
                          (LESSP 1 I)
                          (NOT (EQUAL (REMAINDER (PLUS (SUB1 J) (QUOTIENT I J))
                                                 2)
                                      1))
                          (EQUAL J 1))
                     (NOT (EQUAL I 0))),

      which again simplifies, using linear arithmetic, to:

            T.

    Case 3.2.1.
            (IMPLIES (AND (NOT (EQUAL J 0))
                          (NUMBERP J)
                          (LESSP 1 I)
                          (NOT (EQUAL (REMAINDER (PLUS (SUB1 J) (QUOTIENT I J))
                                                 2)
                                      1)))
                     (NOT (EQUAL (PLUS (SUB1 J) (QUOTIENT I J))
                                 1))),

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

            T.

  Case 3.1.
          (IMPLIES (AND (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (LESSP 1 I)
                        (EQUAL (REMAINDER (PLUS (SUB1 J) (QUOTIENT I J))
                                          2)
                               1))
                   (NOT (EQUAL (ADD1 (QUOTIENT (PLUS (SUB1 J) (QUOTIENT I J))
                                               2))
                               0))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL J 0) (NOT (NUMBERP J))))
                      (NOT (OR (EQUAL 0 0) (NOT (NUMBERP 0))))
                      (NOT (LESSP 0 (SUB1 J)))
                      (LESSP 1 I)
                      (LESSP 0 J))
                 (NOT (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                             0))),

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

  Case 2.2.
          (IMPLIES (AND (NOT (NUMBERP J))
                        (NOT (OR (EQUAL J 0) (NOT (NUMBERP J))))
                        (NOT (OR (EQUAL 0 0) (NOT (NUMBERP 0))))
                        (NOT (LESSP 0 (SUB1 J)))
                        (LESSP 1 I)
                        (LESSP 0 J))
                   (NOT (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                               0))),

    which again simplifies, unfolding NOT and OR, to:

          T.

  Case 2.1.
          (IMPLIES (AND (NUMBERP J)
                        (NOT (OR (EQUAL 1 0) (NOT (NUMBERP 1))))
                        (NOT (OR (EQUAL 0 0) (NOT (NUMBERP 0))))
                        (NOT (LESSP 0 (SUB1 1)))
                        (LESSP 1 I)
                        (LESSP 0 1))
                   (NOT (EQUAL (QUOTIENT (PLUS 1 (QUOTIENT I 1)) 2)
                               0))),

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

          T.

Case 1. (IMPLIES
               (AND (NOT (OR (EQUAL J 0) (NOT (NUMBERP J))))
                    (NOT (OR (EQUAL 0 0) (NOT (NUMBERP 0))))
                    (NOT (EQUAL (QUOTIENT (PLUS (SUB1 J) (QUOTIENT I (SUB1 J)))
                                          2)
                                0))
                    (LESSP 1 I)
                    (LESSP 0 J))
               (NOT (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                           0))),

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

        T.


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


[ 0.0 0.1 0.1 ]

J-NONZEROP


(PROVE-LEMMA J-INT-RANGEP
             (REWRITE)
             (IMPLIES (AND (INT-RANGEP (TIMES 2 J) N)
                           (LESSP (QUOTIENT I J) J))
                      (INT-RANGEP (TIMES 2
                                         (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                                  N)))

This formula simplifies, applying QUOTIENT-TIMES-LESSP, MEAN-LESSP,
CORRECTNESS-OF-CANCEL-LESSP-TIMES, and ABS-LESSP-INT-RANGEP, and expanding the
functions EQUAL, AND, FIX, NOT, ZEROP, ABS, and NEGP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

J-INT-RANGEP


(DEFN ISQRT-INDUCT
      (S I J)
      (IF (ZEROP J)
          T
          (IF (LESSP (QUOTIENT I J) J)
              (ISQRT-INDUCT (STEPN S 10)
                            I
                            (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
              T)))

     The lemmas MEAN-LESSP, COUNT-NUMBERP, and QUOTIENT-TIMES-LESSP and the
definition of ZEROP inform us that the measure (COUNT J) decreases according
to the well-founded relation LESSP in each recursive call.  Hence,
ISQRT-INDUCT is accepted under the principle of definition.  Note that:
      (TRUEP (ISQRT-INDUCT S I J))
is a theorem.




[ 0.0 0.0 0.0 ]

ISQRT-INDUCT


(DEFN ISQRT-STATEP
      (S I)
      (AND (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        (ISQRT-CODE))
           (RAM-ADDRP (SUB 32 8 (READ-SP S))
                      (MC-MEM S)
                      12)
           (EQUAL I (IREAD-DN 32 2 S))
           (ILESSP 1 I)))

     Observe that (OR (FALSEP (ISQRT-STATEP S I)) (TRUEP (ISQRT-STATEP S I)))
is a theorem.




[ 0.0 0.0 0.0 ]

ISQRT-STATEP


(DEFN ISQRT-S0P
      (S I J)
      (AND (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (SUB 32 44 (MC-PC S))
                      (MC-MEM S)
                      70)
           (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                        (MC-MEM S)
                        (ISQRT-CODE))
           (RAM-ADDRP (SUB 32 4 (READ-AN 32 6 S))
                      (MC-MEM S)
                      12)
           (EQUAL I (IREAD-DN 32 2 S))
           (EQUAL J (IREAD-DN 32 1 S))
           (INT-RANGEP (TIMES 2 J) 32)
           (ILESSP 1 I)
           (ILESSP 0 J)))

     Observe that (OR (FALSEP (ISQRT-S0P S I J)) (TRUEP (ISQRT-S0P S I J))) is
a theorem.




[ 0.0 0.0 0.0 ]

ISQRT-S0P


(PROVE-LEMMA INITIAL-J-INT-RANGEP
             (REWRITE)
             (IMPLIES (INT-RANGEP I N)
                      (INT-RANGEP (TIMES 2 (QUOTIENT I 2))
                                  N))
             ((ENABLE INT-RANGEP)))

This conjecture simplifies, applying QUOTIENT-EQUAL-0, TIMES-ZERO, and
INT-RANGEP-OF-0, and expanding the functions FIX-INT, NEGP, NEGATIVE-GUTS,
INTEGERP, INT-RANGEP, OR, ZEROP, QUOTIENT, and TIMES, to:

      (IMPLIES (AND (NOT (EQUAL N 0))
                    (NUMBERP N)
                    (NOT (NEGATIVEP I))
                    (LESSP I (EXP 2 (SUB1 N))))
               (LESSP (TIMES 2 (QUOTIENT I 2))
                      (EXP 2 (SUB1 N)))).

Appealing to the lemma REMAINDER-QUOTIENT-ELIM, we now replace I by
(PLUS Z (TIMES 2 X)) to eliminate (QUOTIENT I 2) and (REMAINDER I 2).  We rely
upon REMAINDER-LESSP, the type restriction lemma noted when QUOTIENT was
introduced, and the type restriction lemma noted when REMAINDER was introduced
to constrain the new variables.  This generates four new goals:

Case 4. (IMPLIES (AND (NOT (NUMBERP I))
                      (NOT (EQUAL N 0))
                      (NUMBERP N)
                      (NOT (NEGATIVEP I))
                      (LESSP I (EXP 2 (SUB1 N))))
                 (LESSP (TIMES 2 (QUOTIENT I 2))
                        (EXP 2 (SUB1 N)))),

  which further simplifies, using linear arithmetic, applying QUOTIENT-LEQ and
  EXP-OF-2-0, and opening up the function EQUAL, to:

        T.

Case 3. (IMPLIES (AND (EQUAL 2 0)
                      (NOT (EQUAL N 0))
                      (NUMBERP N)
                      (NOT (NEGATIVEP I))
                      (LESSP I (EXP 2 (SUB1 N))))
                 (LESSP (TIMES 2 (QUOTIENT I 2))
                        (EXP 2 (SUB1 N)))).

  However this further simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (AND (NOT (NUMBERP 2))
                      (NOT (EQUAL N 0))
                      (NUMBERP N)
                      (NOT (NEGATIVEP I))
                      (LESSP I (EXP 2 (SUB1 N))))
                 (LESSP (TIMES 2 (QUOTIENT I 2))
                        (EXP 2 (SUB1 N)))),

  which further simplifies, trivially, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X)
                      (NUMBERP Z)
                      (EQUAL (LESSP Z 2) (NOT (ZEROP 2)))
                      (NOT (EQUAL 2 0))
                      (NOT (EQUAL N 0))
                      (NUMBERP N)
                      (LESSP (PLUS Z (TIMES 2 X))
                             (EXP 2 (SUB1 N))))
                 (LESSP (TIMES 2 X) (EXP 2 (SUB1 N)))).

  This further simplifies, using linear arithmetic, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

INITIAL-J-INT-RANGEP


(PROVE-LEMMA ISQRT-S-EXIT
             (REWRITE)
             (IMPLIES (AND (ISQRT-STATEP S I)
                           (NOT (LESSP I
                                       (TIMES (QUOTIENT I 2)
                                              (QUOTIENT I 2)))))
                      (AND (EQUAL (MC-STATUS (STEPN S 12))
                                  'RUNNING)
                           (EQUAL (MC-PC (STEPN S 12))
                                  (RTS-ADDR S))
                           (EQUAL (IREAD-DN 32 0 (STEPN S 12))
                                  (QUOTIENT I 2))
                           (EQUAL (READ-RN 32 14
                                           (MC-RFILE (STEPN S 12)))
                                  (READ-RN 32 14 (MC-RFILE S)))
                           (EQUAL (READ-RN 32 15
                                           (MC-RFILE (STEPN S 12)))
                                  (ADD 32 (READ-SP S) 4)))))

WARNING:  Note that ISQRT-S-EXIT contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


WARNING:  Note that ISQRT-S-EXIT contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


WARNING:  Note that the rewrite rule ISQRT-S-EXIT will be stored so as to
apply only to terms with the nonrecursive function symbol IREAD-DN.


WARNING:  Note that ISQRT-S-EXIT contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


WARNING:  Note that ISQRT-S-EXIT contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


WARNING:  Note that ISQRT-S-EXIT contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


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


This conjecture can be simplified, using the abbreviations NOT, ISQRT-CODE,
ISQRT-STATEP, AND, IMPLIES, SP, L, READ-AN, and READ-SP, to the conjecture:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
                    (MCODE-ADDRP (MC-PC S)
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 8
                                    (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (ILESSP 1 I)
                    (NOT (LESSP I
                                (TIMES (QUOTIENT I 2)
                                       (QUOTIENT I 2)))))
               (AND (EQUAL (MC-STATUS (STEPN S 12))
                           'RUNNING)
                    (EQUAL (MC-PC (STEPN S 12))
                           (RTS-ADDR S))
                    (EQUAL (IREAD-DN 32 0 (STEPN S 12))
                           (QUOTIENT I 2))
                    (EQUAL (READ-RN 32 14
                                    (MC-RFILE (STEPN S 12)))
                           (READ-RN 32 14 (MC-RFILE S)))
                    (EQUAL (READ-RN 32 15
                                    (MC-RFILE (STEPN S 12)))
                           (ADD 32
                                (READ-RN 32 (PLUS 8 7) (MC-RFILE S))
                                4)))).

This simplifies, applying the lemmas SUB-NEG, NAT-TO-INT-INTEGERP,
READ-RN-NAT-RANGEP, NEGATIVEP-GUTS0, WRITE-MEMP-RAM3, MC-STATUS-REWRITE,
MC-RFILE-REWRITE, MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY,
PC-READ-MEM-MCODE1, PC-READ-MEMP-ROM1, MC-MEM-REWRITE, MC-PC-REWRITE,
ADD-NAT-RANGEP, PC-READ-MEM-MCODE0, PC-READ-MEMP-ROM0, CDR-CONS, CAR-CONS,
READ-WRITE-RN, PC-READ-MEM-WRITE-MEM, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
ADD-EVENP, BGE-V0, MOVE-BMI, SET-CVZNX-N, BITP-FIX-BIT, MOVE-N-BITP,
SET-CVZNX-V, SET-CVZNX-NAT-RANGEP, WRITE-WRITE-RN, SET-SET-CVZNX1,
HEAD-READ-RN, SET-CVZNX-X, ASR-C-BITP, ASR-INT, LESSP-OF-1, SUB1-OF-1,
QUOTIENT-EQUAL-0, DIVS_3232-OVERFLOW, HEAD-LEMMA, ASR-NAT-RANGEP, and
STEPN-REWRITER, and expanding the functions PLUS, NEG, READ-DN, IREAD-DN,
NEGATIVE-GUTS, NEGP, ILESSP, EXECUTE-INS, OPCODE-FIELD, EQUAL, UNLK-SUBGROUP,
S_RN, LINK-MAPPING, LSZ, READ-AN, SP, READ-SP, INDEX-N, UPDATE-RFILE, WRITE-AN,
WRITE-SP, UPDATE-MEM, ADD, EXT, W, LINK_W-INS, B0P, BITN, MISC-GROUP,
UPDATE-PC, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP, PC-WORD-READ,
PC-WORD-READP, WSZ, LESSP, STEPI, MOVE-INS, MOVE-ADDR-MODEP, CAR, EFFEC-ADDR,
CONS, DN-DIRECT, S_MODE, MC-INSTATE, MC-HALTP, NUMBERP, CDR, OPERAND, MAPPING,
D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, D_RN, MOVE-MAPPING, D_MODE, MOVE-GROUP,
EVENP, B, HEAD, BCC-RA-SR, B-NOT, FIX-BIT, BRANCH-CC, COND-FIELD, BCC-GROUP,
REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA,
REGISTER-ASR-INS, Q, OP-LEN, S&R-GROUP, MOVEM-EA-RN-SUBGROUP, DIV_L-INS, EXP,
IQUOTIENT, SUB1, HALT, DQ, DR, UPDATE-CCR, WRITE-DN, DIVS-CVZNX, DIVSL_L,
MUL&DIV-ADDR-MODEP, BITS, MUL-DIV_L-INS, RTS-ADDR, and AND, to the following
15 new formulas:

Case 15.(IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  1))
         (EQUAL
          (MC-STATUS
           (STEPN
            (MC-STATE 'TRAP-EXCEPTION
             (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (MOVE-Z 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (MOVE-N 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            6))
          'RUNNING)).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 14.(IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  0))
         (EQUAL
          (MC-STATUS
           (STEPN
            (MC-STATE 'TRAP-EXCEPTION
             (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (MOVE-Z 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (MOVE-N 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            6))
          'RUNNING)),

  which again simplifies, using linear arithmetic, to:

        T.

Case 13.(IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       0))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       1)))
         (EQUAL
          (MC-STATUS
           (STEPN
            (MC-STATE 'RUNNING
             (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (DIVS-Z 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (DIVS-N 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            6))
          'RUNNING)),

  which again simplifies, appealing to the lemmas MC-STATUS-REWRITE,
  SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP,
  MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
  QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP,
  QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
  SUB-V-BITP, WRITE-WRITE-RN, ADD-0, HEAD-READ-RN, READ-WRITE-MEM2,
  WRITE-MEM-MAINTAIN-WRITE-MEMP, WRITE-MEMP->READ-MEMP, WRITE-MEMP-RAM2,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, STEPN-REWRITER0, and STEPN-REWRITER,
  and expanding EQUAL, EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS,
  FIX-BIT, TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS,
  READ-LST, LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP,
  PLUS, EVENP, STEPI, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS,
  DN-DIRECT, S_RN, S_MODE, MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR,
  OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
  B-NOT, ILESSP, SUB1, EXP, NEGP, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD,
  BCC-GROUP, MOVE-INS, MOVE-ADDR-MODEP, MAPPING, D-MAPPING, MOVE-EFFECT, B0,
  MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP, UNLK-SUBGROUP, WRITE-SP, SP,
  UPDATE-RFILE, WRITE-AN, LONG-READ, UINT-RANGEP, TIMES, LONG-READP, LSZ,
  READ-AN, UNLK-INS, RTD-MAPPING, DISJOINT, W, READ-SP, and RTS-INS, to:

        T.

Case 12.(IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  1))
         (EQUAL
          (MC-PC
           (STEPN
            (MC-STATE 'TRAP-EXCEPTION
             (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (MOVE-Z 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (MOVE-N 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            6))
          (READ-MEM (READ-RN 32 15 (MC-RFILE S))
                    (MC-MEM S)
                    4))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 11.(IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  0))
         (EQUAL
          (MC-PC
           (STEPN
            (MC-STATE 'TRAP-EXCEPTION
             (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (MOVE-Z 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (MOVE-N 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            6))
          (READ-MEM (READ-RN 32 15 (MC-RFILE S))
                    (MC-MEM S)
                    4))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 10.(IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       0))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       1)))
         (EQUAL
          (MC-PC
           (STEPN
            (MC-STATE 'RUNNING
             (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (DIVS-Z 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (DIVS-N 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            6))
          (READ-MEM (READ-RN 32 15 (MC-RFILE S))
                    (MC-MEM S)
                    4))),

  which again simplifies, rewriting with MC-STATUS-REWRITE, SET-CVZNX-V,
  MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP, MC-CCR-REWRITE,
  ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
  QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP,
  QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
  SUB-V-BITP, WRITE-WRITE-RN, ADD-0, HEAD-READ-RN, READ-WRITE-MEM2,
  WRITE-MEM-MAINTAIN-WRITE-MEMP, WRITE-MEMP->READ-MEMP, WRITE-MEMP-RAM2,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, STEPN-REWRITER0, STEPN-REWRITER, and
  READ-MEM-NAT-RANGEP, and opening up the definitions of EQUAL, EXECUTE-INS,
  OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS, B0P, BITN,
  MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP,
  INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, PLUS, EVENP, STEPI, OP-LEN,
  CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE,
  MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR, OPERAND, D_RN, CMP-CVZNX,
  UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR, B-NOT, ILESSP, SUB1, EXP, NEGP,
  IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, MOVE-INS, MOVE-ADDR-MODEP,
  MAPPING, D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, MOVE-MAPPING, D_MODE,
  MOVE-GROUP, UNLK-SUBGROUP, WRITE-SP, SP, UPDATE-RFILE, WRITE-AN, LONG-READ,
  UINT-RANGEP, TIMES, LONG-READP, LSZ, READ-AN, UNLK-INS, RTD-MAPPING,
  DISJOINT, W, READ-SP, and RTS-INS, to:

        T.

Case 9. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  1))
         (EQUAL
          (NAT-TO-INT
           (READ-RN 32 0
            (MC-RFILE
             (STEPN
              (MC-STATE 'TRAP-EXCEPTION
               (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
               (ADD 32 (MC-PC S) 22)
               (SET-CVZNX (CVZNX 0 0
                                 (MOVE-Z 32
                                         (READ-RN 32 2 (MC-RFILE S)))
                                 (MOVE-N 32
                                         (READ-RN 32 2 (MC-RFILE S)))
                                 (ASR-C 32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        1))
                          (MC-CCR S))
               (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                          (ADD 32
                               (READ-RN 32 15 (MC-RFILE S))
                               4294967292)
                          (MC-MEM S)
                          4))
              6)))
           32)
          (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                32)
                    2))).

  But this again simplifies, using linear arithmetic, to:

        T.

Case 8. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  0))
         (EQUAL
          (NAT-TO-INT
           (READ-RN 32 0
            (MC-RFILE
             (STEPN
              (MC-STATE 'TRAP-EXCEPTION
               (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
               (ADD 32 (MC-PC S) 22)
               (SET-CVZNX (CVZNX 0 0
                                 (MOVE-Z 32
                                         (READ-RN 32 2 (MC-RFILE S)))
                                 (MOVE-N 32
                                         (READ-RN 32 2 (MC-RFILE S)))
                                 (ASR-C 32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        1))
                          (MC-CCR S))
               (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                          (ADD 32
                               (READ-RN 32 15 (MC-RFILE S))
                               4294967292)
                          (MC-MEM S)
                          4))
              6)))
           32)
          (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                32)
                    2))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 7. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       0))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       1)))
         (EQUAL
          (NAT-TO-INT
           (READ-RN 32 0
            (MC-RFILE
             (STEPN
              (MC-STATE 'RUNNING
               (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
               (ADD 32 (MC-PC S) 22)
               (SET-CVZNX (CVZNX 0 0
                                 (DIVS-Z 32
                                         (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                         32
                                         (READ-RN 32 2 (MC-RFILE S))
                                         32)
                                 (DIVS-N 32
                                         (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                         32
                                         (READ-RN 32 2 (MC-RFILE S))
                                         32)
                                 (ASR-C 32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        1))
                          (MC-CCR S))
               (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                          (ADD 32
                               (READ-RN 32 15 (MC-RFILE S))
                               4294967292)
                          (MC-MEM S)
                          4))
              6)))
           32)
          (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                32)
                    2))),

  which again simplifies, rewriting with the lemmas MC-STATUS-REWRITE,
  SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP,
  MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
  QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP,
  QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
  SUB-V-BITP, WRITE-WRITE-RN, ADD-0, HEAD-READ-RN, READ-WRITE-MEM2,
  WRITE-MEM-MAINTAIN-WRITE-MEMP, WRITE-MEMP->READ-MEMP, WRITE-MEMP-RAM2,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, STEPN-REWRITER0, and STEPN-REWRITER,
  and expanding EQUAL, EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS,
  FIX-BIT, TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS,
  READ-LST, LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP,
  PLUS, EVENP, STEPI, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS,
  DN-DIRECT, S_RN, S_MODE, MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR,
  OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
  B-NOT, ILESSP, SUB1, EXP, NEGP, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD,
  BCC-GROUP, MOVE-INS, MOVE-ADDR-MODEP, MAPPING, D-MAPPING, MOVE-EFFECT, B0,
  MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP, UNLK-SUBGROUP, WRITE-SP, SP,
  UPDATE-RFILE, WRITE-AN, LONG-READ, UINT-RANGEP, TIMES, LONG-READP, LSZ,
  READ-AN, UNLK-INS, RTD-MAPPING, DISJOINT, W, READ-SP, and RTS-INS, to:

        T.

Case 6. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  1))
         (EQUAL
          (READ-RN 32 14
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (READ-RN 32 14 (MC-RFILE S)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 5. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  0))
         (EQUAL
          (READ-RN 32 14
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (READ-RN 32 14 (MC-RFILE S)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 4. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       0))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       1)))
         (EQUAL
          (READ-RN 32 14
           (MC-RFILE
            (STEPN
             (MC-STATE 'RUNNING
              (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (DIVS-Z 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (DIVS-N 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (READ-RN 32 14 (MC-RFILE S)))),

  which again simplifies, applying MC-STATUS-REWRITE, SET-CVZNX-V,
  MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP, MC-CCR-REWRITE,
  ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
  QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP,
  QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
  SUB-V-BITP, WRITE-WRITE-RN, ADD-0, HEAD-READ-RN, READ-WRITE-MEM2,
  WRITE-MEM-MAINTAIN-WRITE-MEMP, WRITE-MEMP->READ-MEMP, WRITE-MEMP-RAM2,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, STEPN-REWRITER0, and STEPN-REWRITER,
  and opening up the definitions of EQUAL, EXECUTE-INS, OPCODE-FIELD,
  NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC,
  ADD, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ,
  PC-WORD-READP, WSZ, LESSP, PLUS, EVENP, STEPI, OP-LEN, CMP-INS,
  CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE, MC-INSTATE,
  MC-HALTP, READ-DN, NUMBERP, CDR, OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q,
  CMP-GROUP, B, HEAD, BCC-RA-SR, B-NOT, ILESSP, SUB1, EXP, NEGP, IQUOTIENT,
  BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, MOVE-INS, MOVE-ADDR-MODEP, MAPPING,
  D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP,
  UNLK-SUBGROUP, WRITE-SP, SP, UPDATE-RFILE, WRITE-AN, LONG-READ, UINT-RANGEP,
  TIMES, LONG-READP, LSZ, READ-AN, UNLK-INS, RTD-MAPPING, DISJOINT, W, READ-SP,
  and RTS-INS, to:

        T.

Case 3. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  1))
         (EQUAL
          (READ-RN 32 15
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (ADD 32
               (READ-RN 32 15 (MC-RFILE S))
               4))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  0))
         (EQUAL
          (READ-RN 32 15
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (ADD 32
               (READ-RN 32 15 (MC-RFILE S))
               4))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       0))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       1)))
         (EQUAL
          (READ-RN 32 15
           (MC-RFILE
            (STEPN
             (MC-STATE 'RUNNING
              (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (DIVS-Z 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (DIVS-N 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (ADD 32
               (READ-RN 32 15 (MC-RFILE S))
               4))),

  which again simplifies, applying the lemmas MC-STATUS-REWRITE, SET-CVZNX-V,
  MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP, MC-CCR-REWRITE,
  ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
  QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP,
  QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
  SUB-V-BITP, WRITE-WRITE-RN, ADD-0, HEAD-READ-RN, READ-WRITE-MEM2,
  WRITE-MEM-MAINTAIN-WRITE-MEMP, WRITE-MEMP->READ-MEMP, WRITE-MEMP-RAM2,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, STEPN-REWRITER0, and STEPN-REWRITER,
  and expanding the definitions of EQUAL, EXECUTE-INS, OPCODE-FIELD,
  NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC,
  ADD, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ,
  PC-WORD-READP, WSZ, LESSP, PLUS, EVENP, STEPI, OP-LEN, CMP-INS,
  CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE, MC-INSTATE,
  MC-HALTP, READ-DN, NUMBERP, CDR, OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q,
  CMP-GROUP, B, HEAD, BCC-RA-SR, B-NOT, ILESSP, SUB1, EXP, NEGP, IQUOTIENT,
  BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, MOVE-INS, MOVE-ADDR-MODEP, MAPPING,
  D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP,
  UNLK-SUBGROUP, WRITE-SP, SP, UPDATE-RFILE, WRITE-AN, LONG-READ, UINT-RANGEP,
  TIMES, LONG-READP, LSZ, READ-AN, UNLK-INS, RTD-MAPPING, DISJOINT, W, READ-SP,
  and RTS-INS, to:

        T.

Q.E.D.


[ 0.0 0.5 0.5 ]

ISQRT-S-EXIT


(PROVE-LEMMA ISQRT-S-EXIT-RFILE
             (REWRITE)
             (IMPLIES (AND (ISQRT-STATEP S I)
                           (NOT (LESSP I
                                       (TIMES (QUOTIENT I 2)
                                              (QUOTIENT I 2))))
                           (D2-7A2-5P RN))
                      (EQUAL (READ-RN OPLEN RN
                                      (MC-RFILE (STEPN S 12)))
                             (READ-RN OPLEN RN (MC-RFILE S)))))

WARNING:  Note that ISQRT-S-EXIT-RFILE contains the free variable I which will
be chosen by instantiating the hypothesis (ISQRT-STATEP S I).


This conjecture can be simplified, using the abbreviations D2-7A2-5P, NOT, SP,
L, READ-AN, READ-SP, ISQRT-CODE, ISQRT-STATEP, AND, and IMPLIES, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
                    (MCODE-ADDRP (MC-PC S)
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 8
                                    (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (ILESSP 1 I)
                    (NOT (LESSP I
                                (TIMES (QUOTIENT I 2)
                                       (QUOTIENT I 2))))
                    (NOT (EQUAL RN 0))
                    (NUMBERP RN)
                    (NOT (EQUAL RN 1))
                    (NOT (EQUAL RN 8))
                    (NOT (EQUAL RN 9))
                    (NOT (EQUAL RN 14))
                    (NOT (EQUAL RN 15)))
               (EQUAL (READ-RN OPLEN RN
                               (MC-RFILE (STEPN S 12)))
                      (READ-RN OPLEN RN (MC-RFILE S)))).

This simplifies, applying SUB-NEG, NAT-TO-INT-INTEGERP, READ-RN-NAT-RANGEP,
NEGATIVEP-GUTS0, WRITE-MEMP-RAM3, MC-STATUS-REWRITE, MC-RFILE-REWRITE,
MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-MCODE1,
PC-READ-MEMP-ROM1, MC-MEM-REWRITE, MC-PC-REWRITE, ADD-NAT-RANGEP,
PC-READ-MEM-MCODE0, PC-READ-MEMP-ROM0, CDR-CONS, CAR-CONS, READ-WRITE-RN,
PC-READ-MEM-WRITE-MEM, WRITE-MEM-MAINTAIN-PC-READ-MEMP, ADD-EVENP, BGE-V0,
MOVE-BMI, SET-CVZNX-N, BITP-FIX-BIT, MOVE-N-BITP, SET-CVZNX-V,
SET-CVZNX-NAT-RANGEP, WRITE-WRITE-RN, SET-SET-CVZNX1, HEAD-READ-RN,
SET-CVZNX-X, ASR-C-BITP, ASR-INT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
DIVS_3232-OVERFLOW, HEAD-LEMMA, ASR-NAT-RANGEP, and STEPN-REWRITER, and
expanding PLUS, NEG, READ-DN, IREAD-DN, NEGATIVE-GUTS, NEGP, ILESSP,
EXECUTE-INS, OPCODE-FIELD, EQUAL, UNLK-SUBGROUP, S_RN, LINK-MAPPING, LSZ,
READ-AN, SP, READ-SP, INDEX-N, UPDATE-RFILE, WRITE-AN, WRITE-SP, UPDATE-MEM,
ADD, EXT, W, LINK_W-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, L, CURRENT-INS,
READ-LST, LEN, LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, STEPI,
MOVE-INS, MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_MODE,
MC-INSTATE, MC-HALTP, NUMBERP, CDR, OPERAND, MAPPING, D-MAPPING, MOVE-EFFECT,
B0, MOVE-CVZNX, D_RN, MOVE-MAPPING, D_MODE, MOVE-GROUP, EVENP, B, HEAD,
BCC-RA-SR, B-NOT, FIX-BIT, BRANCH-CC, COND-FIELD, BCC-GROUP,
REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA,
REGISTER-ASR-INS, Q, OP-LEN, S&R-GROUP, MOVEM-EA-RN-SUBGROUP, DIV_L-INS, EXP,
IQUOTIENT, SUB1, HALT, DQ, DR, UPDATE-CCR, WRITE-DN, DIVS-CVZNX, DIVSL_L,
MUL&DIV-ADDR-MODEP, BITS, and MUL-DIV_L-INS, to three new goals:

Case 3. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL RN 0))
           (NUMBERP RN)
           (NOT (EQUAL RN 1))
           (NOT (EQUAL RN 8))
           (NOT (EQUAL RN 9))
           (NOT (EQUAL RN 14))
           (NOT (EQUAL RN 15))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  1))
         (EQUAL
          (READ-RN OPLEN RN
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (READ-RN OPLEN RN (MC-RFILE S)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL RN 0))
           (NUMBERP RN)
           (NOT (EQUAL RN 1))
           (NOT (EQUAL RN 8))
           (NOT (EQUAL RN 9))
           (NOT (EQUAL RN 14))
           (NOT (EQUAL RN 15))
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  0))
         (EQUAL
          (READ-RN OPLEN RN
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (READ-RN OPLEN RN (MC-RFILE S)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (NOT (EQUAL RN 0))
           (NUMBERP RN)
           (NOT (EQUAL RN 1))
           (NOT (EQUAL RN 8))
           (NOT (EQUAL RN 9))
           (NOT (EQUAL RN 14))
           (NOT (EQUAL RN 15))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       0))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       1)))
         (EQUAL
          (READ-RN OPLEN RN
           (MC-RFILE
            (STEPN
             (MC-STATE 'RUNNING
              (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (DIVS-Z 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (DIVS-N 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6)))
          (READ-RN OPLEN RN (MC-RFILE S)))),

  which again simplifies, applying MC-STATUS-REWRITE, SET-CVZNX-V,
  MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP, MC-CCR-REWRITE,
  ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
  QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP,
  QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
  SUB-V-BITP, WRITE-WRITE-RN, ADD-0, HEAD-READ-RN, READ-WRITE-MEM2,
  WRITE-MEM-MAINTAIN-WRITE-MEMP, WRITE-MEMP->READ-MEMP, WRITE-MEMP-RAM2,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, STEPN-REWRITER0, and STEPN-REWRITER,
  and expanding EQUAL, EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS,
  FIX-BIT, TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS,
  READ-LST, LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP,
  PLUS, EVENP, STEPI, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS,
  DN-DIRECT, S_RN, S_MODE, MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR,
  OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
  B-NOT, ILESSP, SUB1, EXP, NEGP, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD,
  BCC-GROUP, MOVE-INS, MOVE-ADDR-MODEP, MAPPING, D-MAPPING, MOVE-EFFECT, B0,
  MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP, UNLK-SUBGROUP, WRITE-SP, SP,
  UPDATE-RFILE, WRITE-AN, LONG-READ, UINT-RANGEP, TIMES, LONG-READP, LSZ,
  READ-AN, UNLK-INS, RTD-MAPPING, DISJOINT, W, READ-SP, and RTS-INS, to:

        T.

Q.E.D.


[ 0.0 0.1 0.1 ]

ISQRT-S-EXIT-RFILE


(PROVE-LEMMA ISQRT-S-EXIT-MEM
             (REWRITE)
             (IMPLIES (AND (ISQRT-STATEP S I)
                           (NOT (LESSP I
                                       (TIMES (QUOTIENT I 2)
                                              (QUOTIENT I 2))))
                           (DISJOINT X K
                                     (SUB 32 8 (READ-SP S))
                                     12))
                      (EQUAL (READ-MEM X (MC-MEM (STEPN S 12)) K)
                             (READ-MEM X (MC-MEM S) K))))

WARNING:  Note that ISQRT-S-EXIT-MEM contains the free variable I which will
be chosen by instantiating the hypothesis (ISQRT-STATEP S I).


This formula can be simplified, using the abbreviations NOT, ISQRT-CODE,
ISQRT-STATEP, AND, IMPLIES, SP, L, READ-AN, and READ-SP, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
                    (MCODE-ADDRP (MC-PC S)
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 8
                                    (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (ILESSP 1 I)
                    (NOT (LESSP I
                                (TIMES (QUOTIENT I 2)
                                       (QUOTIENT I 2))))
                    (DISJOINT X K
                              (SUB 32 8
                                   (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                              12))
               (EQUAL (READ-MEM X (MC-MEM (STEPN S 12)) K)
                      (READ-MEM X (MC-MEM S) K))),

which simplifies, applying SUB-NEG, NAT-TO-INT-INTEGERP, READ-RN-NAT-RANGEP,
NEGATIVEP-GUTS0, WRITE-MEMP-RAM3, MC-STATUS-REWRITE, MC-RFILE-REWRITE,
MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-MCODE1,
PC-READ-MEMP-ROM1, MC-MEM-REWRITE, MC-PC-REWRITE, ADD-NAT-RANGEP,
PC-READ-MEM-MCODE0, PC-READ-MEMP-ROM0, CDR-CONS, CAR-CONS, READ-WRITE-RN,
PC-READ-MEM-WRITE-MEM, WRITE-MEM-MAINTAIN-PC-READ-MEMP, ADD-EVENP, BGE-V0,
MOVE-BMI, SET-CVZNX-N, BITP-FIX-BIT, MOVE-N-BITP, SET-CVZNX-V,
SET-CVZNX-NAT-RANGEP, WRITE-WRITE-RN, SET-SET-CVZNX1, HEAD-READ-RN,
SET-CVZNX-X, ASR-C-BITP, ASR-INT, LESSP-OF-1, SUB1-OF-1, QUOTIENT-EQUAL-0,
DIVS_3232-OVERFLOW, HEAD-LEMMA, ASR-NAT-RANGEP, and STEPN-REWRITER, and
opening up the functions PLUS, NEG, READ-DN, IREAD-DN, NEGATIVE-GUTS, NEGP,
ILESSP, EXECUTE-INS, OPCODE-FIELD, EQUAL, UNLK-SUBGROUP, S_RN, LINK-MAPPING,
LSZ, READ-AN, SP, READ-SP, INDEX-N, UPDATE-RFILE, WRITE-AN, WRITE-SP,
UPDATE-MEM, ADD, EXT, W, LINK_W-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, L,
CURRENT-INS, READ-LST, LEN, LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ,
LESSP, STEPI, MOVE-INS, MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT,
S_MODE, MC-INSTATE, MC-HALTP, NUMBERP, CDR, OPERAND, MAPPING, D-MAPPING,
MOVE-EFFECT, B0, MOVE-CVZNX, D_RN, MOVE-MAPPING, D_MODE, MOVE-GROUP, EVENP, B,
HEAD, BCC-RA-SR, B-NOT, FIX-BIT, BRANCH-CC, COND-FIELD, BCC-GROUP,
REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA,
REGISTER-ASR-INS, Q, OP-LEN, S&R-GROUP, MOVEM-EA-RN-SUBGROUP, DIV_L-INS, EXP,
IQUOTIENT, SUB1, HALT, DQ, DR, UPDATE-CCR, WRITE-DN, DIVS-CVZNX, DIVSL_L,
MUL&DIV-ADDR-MODEP, BITS, and MUL-DIV_L-INS, to the following three new goals:

Case 3. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (DISJOINT X K
                     (ADD 32
                          (READ-RN 32 15 (MC-RFILE S))
                          4294967288)
                     12)
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  1))
         (EQUAL
          (READ-MEM X
           (MC-MEM
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6))
           K)
          (READ-MEM X (MC-MEM S) K))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (DISJOINT X K
                     (ADD 32
                          (READ-RN 32 15 (MC-RFILE S))
                          4294967288)
                     12)
           (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32)
                  0))
         (EQUAL
          (READ-MEM X
           (MC-MEM
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6))
           K)
          (READ-MEM X (MC-MEM S) K))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES
         (AND
           (EQUAL (MC-STATUS S) 'RUNNING)
           (EVENP (MC-PC S))
           (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
           (MCODE-ADDRP (MC-PC S)
                        (MC-MEM S)
                        '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32 2
                             76 65 8 0 78 118 178 128 111 28 208 129 78 118
                             34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65 8 0
                             78 118 178 128 110 228 32 1 78 94 78 117))
           (RAM-ADDRP (ADD 32
                           (READ-RN 32 15 (MC-RFILE S))
                           4294967288)
                      (MC-MEM S)
                      12)
           (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                       32)))
           (LESSP 1
                  (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                              32))
           (NOT (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2))))
           (DISJOINT X K
                     (ADD 32
                          (READ-RN 32 15 (MC-RFILE S))
                          4294967288)
                     12)
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       0))
           (NOT (EQUAL (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                   32)
                       1)))
         (EQUAL
          (READ-MEM X
           (MC-MEM
            (STEPN
             (MC-STATE 'RUNNING
              (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (DIVS-Z 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (DIVS-N 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             6))
           K)
          (READ-MEM X (MC-MEM S) K))),

  which again simplifies, using linear arithmetic, rewriting with
  MC-STATUS-REWRITE, SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP,
  MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM,
  PC-READ-MEM-MCODE1, WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1,
  WRITE-MEM-MAINTAIN-PC-READ-MEMP, MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE,
  ADD-NAT-RANGEP, CDR-CONS, CAR-CONS, IQUOT-NAT-RANGEP, HEAD-LEMMA,
  READ-WRITE-RN, READ-RN-NAT-RANGEP, ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT,
  ASR-C-BITP, SET-SET-CVZNX1, BLE-BGT, SUB-BGT, LESSP-OF-1, SUB1-OF-1,
  QUOTIENT-EQUAL-0, QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT,
  NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z,
  SUB-Z-BITP, SUB-V-BITP, WRITE-WRITE-RN, ADD-0, HEAD-READ-RN, READ-WRITE-MEM2,
  WRITE-MEM-MAINTAIN-WRITE-MEMP, WRITE-MEMP->READ-MEMP, WRITE-MEMP-RAM2,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, STEPN-REWRITER0, STEPN-REWRITER, and
  DISJOINT-10, and expanding EQUAL, EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP,
  B1P, BVS, FIX-BIT, TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, ADD, L,
  CURRENT-INS, READ-LST, LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ,
  PC-WORD-READP, WSZ, LESSP, PLUS, EVENP, STEPI, OP-LEN, CMP-INS,
  CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE, MC-INSTATE,
  MC-HALTP, READ-DN, NUMBERP, CDR, OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q,
  CMP-GROUP, B, HEAD, BCC-RA-SR, B-NOT, ILESSP, SUB1, EXP, NEGP, IQUOTIENT,
  BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, MOVE-INS, MOVE-ADDR-MODEP, MAPPING,
  D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP,
  UNLK-SUBGROUP, WRITE-SP, SP, UPDATE-RFILE, WRITE-AN, LONG-READ, UINT-RANGEP,
  TIMES, LONG-READP, LSZ, READ-AN, UNLK-INS, RTD-MAPPING, DISJOINT, W, READ-SP,
  and RTS-INS, to:

        T.

Q.E.D.


[ 0.0 0.1 0.3 ]

ISQRT-S-EXIT-MEM


(PROVE-LEMMA ISQRT-S-S0
             (REWRITE)
             (LET ((J1 (QUOTIENT (PLUS (QUOTIENT I 2)
                                       (QUOTIENT I (QUOTIENT I 2)))
                                 2)))
                  (IMPLIES (AND (ISQRT-STATEP S I)
                                (LESSP I
                                       (TIMES (QUOTIENT I 2)
                                              (QUOTIENT I 2))))
                           (AND (ISQRT-S0P (STEPN S 14) I J1)
                                (EQUAL (LINKED-RTS-ADDR (STEPN S 14))
                                       (RTS-ADDR S))
                                (EQUAL (LINKED-A6 (STEPN S 14))
                                       (READ-AN 32 6 S))
                                (EQUAL (READ-RN 32 14
                                                (MC-RFILE (STEPN S 14)))
                                       (SUB 32 4 (READ-SP S))))))
             ((DISABLE QUOTIENT-EQUAL-0)))

WARNING:  Note that the rewrite rule ISQRT-S-S0 will be stored so as to apply
only to terms with the nonrecursive function symbol ISQRT-S0P.


WARNING:  Note that the rewrite rule ISQRT-S-S0 will be stored so as to apply
only to terms with the nonrecursive function symbol LINKED-RTS-ADDR.


WARNING:  Note that ISQRT-S-S0 contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


WARNING:  Note that the rewrite rule ISQRT-S-S0 will be stored so as to apply
only to terms with the nonrecursive function symbol LINKED-A6.


WARNING:  Note that ISQRT-S-S0 contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


WARNING:  Note that ISQRT-S-S0 contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


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


This conjecture can be simplified, using the abbreviations ISQRT-CODE,
ISQRT-STATEP, AND, IMPLIES, SP, L, READ-SP, and READ-AN, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
                    (MCODE-ADDRP (MC-PC S)
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 8
                                    (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (ILESSP 1 I)
                    (LESSP I
                           (TIMES (QUOTIENT I 2)
                                  (QUOTIENT I 2))))
               (AND (ISQRT-S0P (STEPN S 14)
                               I
                               (QUOTIENT (PLUS (QUOTIENT I 2)
                                               (QUOTIENT I (QUOTIENT I 2)))
                                         2))
                    (EQUAL (LINKED-RTS-ADDR (STEPN S 14))
                           (RTS-ADDR S))
                    (EQUAL (LINKED-A6 (STEPN S 14))
                           (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                    (EQUAL (READ-RN 32 14
                                    (MC-RFILE (STEPN S 14)))
                           (SUB 32 4
                                (READ-RN 32
                                         (PLUS 8 7)
                                         (MC-RFILE S)))))).

This simplifies, rewriting with SUB-NEG, NAT-TO-INT-INTEGERP,
READ-RN-NAT-RANGEP, NEGATIVEP-GUTS0, WRITE-MEMP-RAM3, MC-STATUS-REWRITE,
MC-RFILE-REWRITE, MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY,
PC-READ-MEM-MCODE1, PC-READ-MEMP-ROM1, MC-MEM-REWRITE, MC-PC-REWRITE,
ADD-NAT-RANGEP, PC-READ-MEM-MCODE0, PC-READ-MEMP-ROM0, CDR-CONS, CAR-CONS,
READ-WRITE-RN, PC-READ-MEM-WRITE-MEM, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
ADD-EVENP, BGE-V0, MOVE-BMI, SET-CVZNX-N, BITP-FIX-BIT, MOVE-N-BITP,
SET-CVZNX-V, SET-CVZNX-NAT-RANGEP, WRITE-WRITE-RN, SET-SET-CVZNX1,
HEAD-READ-RN, SET-CVZNX-X, ASR-C-BITP, ASR-INT, DIVS_3232-OVERFLOW, HEAD-LEMMA,
ASR-NAT-RANGEP, and STEPN-REWRITER, and opening up the functions PLUS, NEG,
READ-DN, IREAD-DN, NEGATIVE-GUTS, NEGP, ILESSP, EXECUTE-INS, OPCODE-FIELD,
EQUAL, UNLK-SUBGROUP, S_RN, LINK-MAPPING, LSZ, READ-AN, SP, READ-SP, INDEX-N,
UPDATE-RFILE, WRITE-AN, WRITE-SP, UPDATE-MEM, ADD, EXT, W, LINK_W-INS, B0P,
BITN, MISC-GROUP, UPDATE-PC, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP,
PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, STEPI, MOVE-INS, MOVE-ADDR-MODEP, CAR,
EFFEC-ADDR, CONS, DN-DIRECT, S_MODE, MC-INSTATE, MC-HALTP, NUMBERP, CDR,
OPERAND, MAPPING, D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, D_RN, MOVE-MAPPING,
D_MODE, MOVE-GROUP, EVENP, B, HEAD, BCC-RA-SR, B-NOT, FIX-BIT, BRANCH-CC,
COND-FIELD, BCC-GROUP, REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX,
SR-CNT, I-DATA, REGISTER-ASR-INS, Q, OP-LEN, S&R-GROUP, MOVEM-EA-RN-SUBGROUP,
DIV_L-INS, EXP, IQUOTIENT, HALT, DQ, DR, UPDATE-CCR, WRITE-DN, DIVS-CVZNX,
DIVSL_L, MUL&DIV-ADDR-MODEP, BITS, MUL-DIV_L-INS, RTS-ADDR, and AND, to eight
new formulas:

Case 8. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (NOT (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                32)
                                    2)
                          0)))
         (ISQRT-S0P
          (STEPN
           (MC-STATE 'RUNNING
            (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
            (ADD 32 (MC-PC S) 22)
            (SET-CVZNX (CVZNX 0 0
                              (DIVS-Z 32
                                      (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                      32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      32)
                              (DIVS-N 32
                                      (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                      32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      32)
                              (ASR-C 32
                                     (READ-RN 32 2 (MC-RFILE S))
                                     1))
                       (MC-CCR S))
            (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                       (ADD 32
                            (READ-RN 32 15 (MC-RFILE S))
                            4294967292)
                       (MC-MEM S)
                       4))
           8)
          (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                      32)
          (QUOTIENT
              (PLUS (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)
                              2)
                    (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)))
              2))),

  which again simplifies, using linear arithmetic, applying MC-STATUS-REWRITE,
  SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP,
  MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT,
  NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z,
  SUB-Z-BITP, SUB-V-BITP, WRITE-WRITE-RN, ADD-BVS&VC, ISQRT-NO-OVERFLOW,
  INITIAL-J-INT-RANGEP, ADD-V-BITP, ADD-C-BITP, BGE-V0, MOVE-BMI, ADD-INT,
  IPLUS-COMMUTATIVITY, MOVE-N-BITP, STEPN-REWRITER0, STEPN-REWRITER,
  WRITE-MEM-MAINTAIN-RAM-ADDRP, RAM-ADDRP-3, WRITE-MEM-MCODE-ADDRP,
  PC-READ-MEMP-ROM0, WRITE-MEM-MAINTAIN-ROM-ADDRP, ROM-ADDRP-LA2, INDEX-N-X-X,
  SUB-NEG, ADD-0, and MC-PC-RANGEP, and expanding the functions EQUAL,
  EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS, B0P,
  BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP,
  INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, PLUS, EVENP, STEPI, OP-LEN,
  CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE,
  MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR, OPERAND, D_RN, CMP-CVZNX,
  UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR, B-NOT, ILESSP, EXP, NEGP,
  IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, OPMODE-FIELD, ADD-INS1,
  ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, D-MAPPING, ADD-GROUP, IPLUS,
  MOVE-INS, MOVE-ADDR-MODEP, MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX,
  MOVE-MAPPING, D_MODE, MOVE-GROUP, REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X,
  ASR-CVZNX, SR-CNT, I-DATA, REGISTER-ASR-INS, S&R-GROUP, IREAD-DN, READ-AN,
  ISQRT-CODE, NEG, and ISQRT-S0P, to:

        (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (NOT (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                32)
                                    2)
                          0)))
         (NOT
          (EQUAL
           (QUOTIENT
              (PLUS (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)
                              2)
                    (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)))
              2)
           0))),

  which again simplifies, using linear arithmetic and applying the lemma
  J-NONZEROP, to:

        T.

Case 7. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                           32)
                               2)
                     0))
         (ISQRT-S0P
          (STEPN
           (MC-STATE 'TRAP-EXCEPTION
            (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
            (ADD 32 (MC-PC S) 22)
            (SET-CVZNX (CVZNX 0 0
                              (MOVE-Z 32
                                      (READ-RN 32 2 (MC-RFILE S)))
                              (MOVE-N 32
                                      (READ-RN 32 2 (MC-RFILE S)))
                              (ASR-C 32
                                     (READ-RN 32 2 (MC-RFILE S))
                                     1))
                       (MC-CCR S))
            (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                       (ADD 32
                            (READ-RN 32 15 (MC-RFILE S))
                            4294967292)
                       (MC-MEM S)
                       4))
           8)
          (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                      32)
          (QUOTIENT
              (PLUS (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)
                              2)
                    (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        2)))
              2))),

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

        T.

Case 6. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (NOT (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                32)
                                    2)
                          0)))
         (EQUAL
          (LINKED-RTS-ADDR
           (STEPN
            (MC-STATE 'RUNNING
             (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (DIVS-Z 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (DIVS-N 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            8))
          (READ-MEM (READ-RN 32 15 (MC-RFILE S))
                    (MC-MEM S)
                    4))),

  which again simplifies, using linear arithmetic, applying MC-STATUS-REWRITE,
  SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP,
  MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT,
  NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z,
  SUB-Z-BITP, SUB-V-BITP, WRITE-WRITE-RN, ADD-BVS&VC, ISQRT-NO-OVERFLOW,
  INITIAL-J-INT-RANGEP, ADD-V-BITP, ADD-C-BITP, BGE-V0, MOVE-BMI, ADD-INT,
  IPLUS-COMMUTATIVITY, MOVE-N-BITP, STEPN-REWRITER0, STEPN-REWRITER,
  READ-WRITE-MEM1, DISJOINT-DEDUCTION1, ADD-0, and HEAD-READ-RN, and opening
  up the functions EQUAL, EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS,
  FIX-BIT, TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS,
  READ-LST, LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP,
  PLUS, EVENP, STEPI, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS,
  DN-DIRECT, S_RN, S_MODE, MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR,
  OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
  B-NOT, ILESSP, EXP, NEGP, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP,
  OPMODE-FIELD, ADD-INS1, ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, D-MAPPING,
  ADD-GROUP, IPLUS, MOVE-INS, MOVE-ADDR-MODEP, MAPPING, MOVE-EFFECT, B0,
  MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP, REGISTER-SHIFT-ROTATE,
  ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA, REGISTER-ASR-INS, S&R-GROUP,
  DISJOINT, READ-AN, and LINKED-RTS-ADDR, to:

        T.

Case 5. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                           32)
                               2)
                     0))
         (EQUAL
          (LINKED-RTS-ADDR
           (STEPN
            (MC-STATE 'TRAP-EXCEPTION
             (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (MOVE-Z 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (MOVE-N 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            8))
          (READ-MEM (READ-RN 32 15 (MC-RFILE S))
                    (MC-MEM S)
                    4))).

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

        T.

Case 4. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (NOT (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                32)
                                    2)
                          0)))
         (EQUAL
          (LINKED-A6
           (STEPN
            (MC-STATE 'RUNNING
             (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (DIVS-Z 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (DIVS-N 32
                                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                       32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       32)
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            8))
          (READ-RN 32 14 (MC-RFILE S)))),

  which again simplifies, using linear arithmetic, rewriting with the lemmas
  MC-STATUS-REWRITE, SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP,
  MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM,
  PC-READ-MEM-MCODE1, WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1,
  WRITE-MEM-MAINTAIN-PC-READ-MEMP, MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE,
  ADD-NAT-RANGEP, CDR-CONS, CAR-CONS, IQUOT-NAT-RANGEP, HEAD-LEMMA,
  READ-WRITE-RN, READ-RN-NAT-RANGEP, ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT,
  ASR-C-BITP, SET-SET-CVZNX1, BLE-BGT, SUB-BGT, QUOTIENT-TIMES-LESSP,
  IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N,
  SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP, SUB-V-BITP, WRITE-WRITE-RN, ADD-BVS&VC,
  ISQRT-NO-OVERFLOW, INITIAL-J-INT-RANGEP, ADD-V-BITP, ADD-C-BITP, BGE-V0,
  MOVE-BMI, ADD-INT, IPLUS-COMMUTATIVITY, MOVE-N-BITP, STEPN-REWRITER0,
  STEPN-REWRITER, READ-WRITE-MEM2, and HEAD-READ-RN, and opening up EQUAL,
  EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS, B0P,
  BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP,
  INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, PLUS, EVENP, STEPI, OP-LEN,
  CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE,
  MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR, OPERAND, D_RN, CMP-CVZNX,
  UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR, B-NOT, ILESSP, EXP, NEGP,
  IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, OPMODE-FIELD, ADD-INS1,
  ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, D-MAPPING, ADD-GROUP, IPLUS,
  MOVE-INS, MOVE-ADDR-MODEP, MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX,
  MOVE-MAPPING, D_MODE, MOVE-GROUP, REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X,
  ASR-CVZNX, SR-CNT, I-DATA, REGISTER-ASR-INS, S&R-GROUP, TIMES, UINT-RANGEP,
  READ-AN, and LINKED-A6, to:

        T.

Case 3. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                           32)
                               2)
                     0))
         (EQUAL
          (LINKED-A6
           (STEPN
            (MC-STATE 'TRAP-EXCEPTION
             (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
             (ADD 32 (MC-PC S) 22)
             (SET-CVZNX (CVZNX 0 0
                               (MOVE-Z 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (MOVE-N 32
                                       (READ-RN 32 2 (MC-RFILE S)))
                               (ASR-C 32
                                      (READ-RN 32 2 (MC-RFILE S))
                                      1))
                        (MC-CCR S))
             (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967292)
                        (MC-MEM S)
                        4))
            8))
          (READ-RN 32 14 (MC-RFILE S)))),

  which again simplifies, unfolding TIMES, EQUAL, and LESSP, to:

        T.

Case 2. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (NOT (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                32)
                                    2)
                          0)))
         (EQUAL
          (READ-RN 32 14
           (MC-RFILE
            (STEPN
             (MC-STATE 'RUNNING
              (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (DIVS-Z 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (DIVS-N 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             8)))
          (ADD 32
               (READ-RN 32 15 (MC-RFILE S))
               4294967292))),

  which again simplifies, using linear arithmetic, applying MC-STATUS-REWRITE,
  SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP, MC-CCR-RANGEP,
  MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM, PC-READ-MEM-MCODE1,
  WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
  MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE, ADD-NAT-RANGEP, CDR-CONS, CAR-CONS,
  IQUOT-NAT-RANGEP, HEAD-LEMMA, READ-WRITE-RN, READ-RN-NAT-RANGEP,
  ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT, ASR-C-BITP, SET-SET-CVZNX1,
  BLE-BGT, SUB-BGT, QUOTIENT-TIMES-LESSP, IQUOT-INT, ASR-INT,
  NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z,
  SUB-Z-BITP, SUB-V-BITP, WRITE-WRITE-RN, ADD-BVS&VC, ISQRT-NO-OVERFLOW,
  INITIAL-J-INT-RANGEP, ADD-V-BITP, ADD-C-BITP, BGE-V0, MOVE-BMI, ADD-INT,
  IPLUS-COMMUTATIVITY, MOVE-N-BITP, STEPN-REWRITER0, and STEPN-REWRITER, and
  unfolding EQUAL, EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS, FIX-BIT,
  TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS, READ-LST,
  LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, PLUS,
  EVENP, STEPI, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS,
  DN-DIRECT, S_RN, S_MODE, MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR,
  OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
  B-NOT, ILESSP, EXP, NEGP, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP,
  OPMODE-FIELD, ADD-INS1, ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, D-MAPPING,
  ADD-GROUP, IPLUS, MOVE-INS, MOVE-ADDR-MODEP, MAPPING, MOVE-EFFECT, B0,
  MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP, REGISTER-SHIFT-ROTATE,
  ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA, REGISTER-ASR-INS, and
  S&R-GROUP, to:

        T.

Case 1. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                           32)
                               2)
                     0))
         (EQUAL
          (READ-RN 32 14
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             8)))
          (ADD 32
               (READ-RN 32 15 (MC-RFILE S))
               4294967292))).

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

        T.

Q.E.D.


[ 0.0 0.8 0.1 ]

ISQRT-S-S0


(PROVE-LEMMA ISQRT-S-S0-RFILE
             (REWRITE)
             (IMPLIES (AND (ISQRT-STATEP S I)
                           (LESSP I
                                  (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                           (D2-7A2-5P RN))
                      (EQUAL (READ-RN OPLEN RN
                                      (MC-RFILE (STEPN S 14)))
                             (READ-RN OPLEN RN (MC-RFILE S))))
             ((DISABLE QUOTIENT-EQUAL-0)))

WARNING:  Note that ISQRT-S-S0-RFILE contains the free variable I which will
be chosen by instantiating the hypothesis (ISQRT-STATEP S I).


This conjecture can be simplified, using the abbreviations D2-7A2-5P, SP, L,
READ-AN, READ-SP, ISQRT-CODE, ISQRT-STATEP, AND, and IMPLIES, to the goal:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
                    (MCODE-ADDRP (MC-PC S)
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 8
                                    (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (ILESSP 1 I)
                    (LESSP I
                           (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                    (NOT (EQUAL RN 0))
                    (NUMBERP RN)
                    (NOT (EQUAL RN 1))
                    (NOT (EQUAL RN 8))
                    (NOT (EQUAL RN 9))
                    (NOT (EQUAL RN 14))
                    (NOT (EQUAL RN 15)))
               (EQUAL (READ-RN OPLEN RN
                               (MC-RFILE (STEPN S 14)))
                      (READ-RN OPLEN RN (MC-RFILE S)))).

This simplifies, applying SUB-NEG, NAT-TO-INT-INTEGERP, READ-RN-NAT-RANGEP,
NEGATIVEP-GUTS0, WRITE-MEMP-RAM3, MC-STATUS-REWRITE, MC-RFILE-REWRITE,
MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-MCODE1,
PC-READ-MEMP-ROM1, MC-MEM-REWRITE, MC-PC-REWRITE, ADD-NAT-RANGEP,
PC-READ-MEM-MCODE0, PC-READ-MEMP-ROM0, CDR-CONS, CAR-CONS, READ-WRITE-RN,
PC-READ-MEM-WRITE-MEM, WRITE-MEM-MAINTAIN-PC-READ-MEMP, ADD-EVENP, BGE-V0,
MOVE-BMI, SET-CVZNX-N, BITP-FIX-BIT, MOVE-N-BITP, SET-CVZNX-V,
SET-CVZNX-NAT-RANGEP, WRITE-WRITE-RN, SET-SET-CVZNX1, HEAD-READ-RN,
SET-CVZNX-X, ASR-C-BITP, ASR-INT, DIVS_3232-OVERFLOW, HEAD-LEMMA,
ASR-NAT-RANGEP, and STEPN-REWRITER, and expanding the definitions of PLUS, NEG,
READ-DN, IREAD-DN, NEGATIVE-GUTS, NEGP, ILESSP, EXECUTE-INS, OPCODE-FIELD,
EQUAL, UNLK-SUBGROUP, S_RN, LINK-MAPPING, LSZ, READ-AN, SP, READ-SP, INDEX-N,
UPDATE-RFILE, WRITE-AN, WRITE-SP, UPDATE-MEM, ADD, EXT, W, LINK_W-INS, B0P,
BITN, MISC-GROUP, UPDATE-PC, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP,
PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, STEPI, MOVE-INS, MOVE-ADDR-MODEP, CAR,
EFFEC-ADDR, CONS, DN-DIRECT, S_MODE, MC-INSTATE, MC-HALTP, NUMBERP, CDR,
OPERAND, MAPPING, D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, D_RN, MOVE-MAPPING,
D_MODE, MOVE-GROUP, EVENP, B, HEAD, BCC-RA-SR, B-NOT, FIX-BIT, BRANCH-CC,
COND-FIELD, BCC-GROUP, REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX,
SR-CNT, I-DATA, REGISTER-ASR-INS, Q, OP-LEN, S&R-GROUP, MOVEM-EA-RN-SUBGROUP,
DIV_L-INS, EXP, IQUOTIENT, HALT, DQ, DR, UPDATE-CCR, WRITE-DN, DIVS-CVZNX,
DIVSL_L, MUL&DIV-ADDR-MODEP, BITS, and MUL-DIV_L-INS, to two new goals:

Case 2. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (NOT (EQUAL RN 0))
              (NUMBERP RN)
              (NOT (EQUAL RN 1))
              (NOT (EQUAL RN 8))
              (NOT (EQUAL RN 9))
              (NOT (EQUAL RN 14))
              (NOT (EQUAL RN 15))
              (NOT (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                32)
                                    2)
                          0)))
         (EQUAL
          (READ-RN OPLEN RN
           (MC-RFILE
            (STEPN
             (MC-STATE 'RUNNING
              (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (DIVS-Z 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (DIVS-N 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             8)))
          (READ-RN OPLEN RN (MC-RFILE S)))),

  which again simplifies, using linear arithmetic, rewriting with
  MC-STATUS-REWRITE, SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP,
  MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM,
  PC-READ-MEM-MCODE1, WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1,
  WRITE-MEM-MAINTAIN-PC-READ-MEMP, MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE,
  ADD-NAT-RANGEP, CDR-CONS, CAR-CONS, IQUOT-NAT-RANGEP, HEAD-LEMMA,
  READ-WRITE-RN, READ-RN-NAT-RANGEP, ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT,
  ASR-C-BITP, SET-SET-CVZNX1, BLE-BGT, SUB-BGT, QUOTIENT-TIMES-LESSP,
  IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N,
  SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP, SUB-V-BITP, WRITE-WRITE-RN, ADD-BVS&VC,
  ISQRT-NO-OVERFLOW, INITIAL-J-INT-RANGEP, ADD-V-BITP, ADD-C-BITP, BGE-V0,
  MOVE-BMI, ADD-INT, IPLUS-COMMUTATIVITY, MOVE-N-BITP, STEPN-REWRITER0, and
  STEPN-REWRITER, and opening up the functions EQUAL, EXECUTE-INS,
  OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS, B0P, BITN,
  MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP,
  INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, PLUS, EVENP, STEPI, OP-LEN,
  CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE,
  MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR, OPERAND, D_RN, CMP-CVZNX,
  UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR, B-NOT, ILESSP, EXP, NEGP,
  IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, OPMODE-FIELD, ADD-INS1,
  ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, D-MAPPING, ADD-GROUP, IPLUS,
  MOVE-INS, MOVE-ADDR-MODEP, MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX,
  MOVE-MAPPING, D_MODE, MOVE-GROUP, REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X,
  ASR-CVZNX, SR-CNT, I-DATA, REGISTER-ASR-INS, and S&R-GROUP, to:

        T.

Case 1. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (NOT (EQUAL RN 0))
              (NUMBERP RN)
              (NOT (EQUAL RN 1))
              (NOT (EQUAL RN 8))
              (NOT (EQUAL RN 9))
              (NOT (EQUAL RN 14))
              (NOT (EQUAL RN 15))
              (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                           32)
                               2)
                     0))
         (EQUAL
          (READ-RN OPLEN RN
           (MC-RFILE
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             8)))
          (READ-RN OPLEN RN (MC-RFILE S)))).

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

        T.

Q.E.D.


[ 0.0 0.2 0.0 ]

ISQRT-S-S0-RFILE


(PROVE-LEMMA ISQRT-S-S0-MEM
             (REWRITE)
             (IMPLIES (AND (ISQRT-STATEP S I)
                           (LESSP I
                                  (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                           (DISJOINT X K
                                     (SUB 32 8 (READ-SP S))
                                     12))
                      (EQUAL (READ-MEM X (MC-MEM (STEPN S 14)) K)
                             (READ-MEM X (MC-MEM S) K)))
             ((DISABLE QUOTIENT-EQUAL-0)))

WARNING:  Note that ISQRT-S-S0-MEM contains the free variable I which will be
chosen by instantiating the hypothesis (ISQRT-STATEP S I).


This formula can be simplified, using the abbreviations ISQRT-CODE,
ISQRT-STATEP, AND, IMPLIES, SP, L, READ-AN, and READ-SP, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
                    (MCODE-ADDRP (MC-PC S)
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 8
                                    (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (ILESSP 1 I)
                    (LESSP I
                           (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                    (DISJOINT X K
                              (SUB 32 8
                                   (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                              12))
               (EQUAL (READ-MEM X (MC-MEM (STEPN S 14)) K)
                      (READ-MEM X (MC-MEM S) K))),

which simplifies, rewriting with SUB-NEG, NAT-TO-INT-INTEGERP,
READ-RN-NAT-RANGEP, NEGATIVEP-GUTS0, WRITE-MEMP-RAM3, MC-STATUS-REWRITE,
MC-RFILE-REWRITE, MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY,
PC-READ-MEM-MCODE1, PC-READ-MEMP-ROM1, MC-MEM-REWRITE, MC-PC-REWRITE,
ADD-NAT-RANGEP, PC-READ-MEM-MCODE0, PC-READ-MEMP-ROM0, CDR-CONS, CAR-CONS,
READ-WRITE-RN, PC-READ-MEM-WRITE-MEM, WRITE-MEM-MAINTAIN-PC-READ-MEMP,
ADD-EVENP, BGE-V0, MOVE-BMI, SET-CVZNX-N, BITP-FIX-BIT, MOVE-N-BITP,
SET-CVZNX-V, SET-CVZNX-NAT-RANGEP, WRITE-WRITE-RN, SET-SET-CVZNX1,
HEAD-READ-RN, SET-CVZNX-X, ASR-C-BITP, ASR-INT, DIVS_3232-OVERFLOW, HEAD-LEMMA,
ASR-NAT-RANGEP, and STEPN-REWRITER, and expanding PLUS, NEG, READ-DN, IREAD-DN,
NEGATIVE-GUTS, NEGP, ILESSP, EXECUTE-INS, OPCODE-FIELD, EQUAL, UNLK-SUBGROUP,
S_RN, LINK-MAPPING, LSZ, READ-AN, SP, READ-SP, INDEX-N, UPDATE-RFILE, WRITE-AN,
WRITE-SP, UPDATE-MEM, ADD, EXT, W, LINK_W-INS, B0P, BITN, MISC-GROUP,
UPDATE-PC, L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP, PC-WORD-READ,
PC-WORD-READP, WSZ, LESSP, STEPI, MOVE-INS, MOVE-ADDR-MODEP, CAR, EFFEC-ADDR,
CONS, DN-DIRECT, S_MODE, MC-INSTATE, MC-HALTP, NUMBERP, CDR, OPERAND, MAPPING,
D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, D_RN, MOVE-MAPPING, D_MODE, MOVE-GROUP,
EVENP, B, HEAD, BCC-RA-SR, B-NOT, FIX-BIT, BRANCH-CC, COND-FIELD, BCC-GROUP,
REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA,
REGISTER-ASR-INS, Q, OP-LEN, S&R-GROUP, MOVEM-EA-RN-SUBGROUP, DIV_L-INS, EXP,
IQUOTIENT, HALT, DQ, DR, UPDATE-CCR, WRITE-DN, DIVS-CVZNX, DIVSL_L,
MUL&DIV-ADDR-MODEP, BITS, and MUL-DIV_L-INS, to the following two new
conjectures:

Case 2. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (DISJOINT X K
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967288)
                        12)
              (NOT (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                32)
                                    2)
                          0)))
         (EQUAL
          (READ-MEM X
           (MC-MEM
            (STEPN
             (MC-STATE 'RUNNING
              (WRITE-RN 32
                (IQUOT 32
                       (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                       32
                       (READ-RN 32 2 (MC-RFILE S))
                       32)
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (DIVS-Z 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (DIVS-N 32
                                        (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                                        32
                                        (READ-RN 32 2 (MC-RFILE S))
                                        32)
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             8))
           K)
          (READ-MEM X (MC-MEM S) K))).

  But this again simplifies, using linear arithmetic, applying
  MC-STATUS-REWRITE, SET-CVZNX-V, MC-RFILE-REWRITE, SET-CVZNX-NAT-RANGEP,
  MC-CCR-RANGEP, MC-CCR-REWRITE, ADD-ASSOCIATIVITY, PC-READ-MEM-WRITE-MEM,
  PC-READ-MEM-MCODE1, WRITE-MEMP-RAM3, PC-READ-MEMP-ROM1,
  WRITE-MEM-MAINTAIN-PC-READ-MEMP, MC-MEM-REWRITE, ADD-EVENP, MC-PC-REWRITE,
  ADD-NAT-RANGEP, CDR-CONS, CAR-CONS, IQUOT-NAT-RANGEP, HEAD-LEMMA,
  READ-WRITE-RN, READ-RN-NAT-RANGEP, ASR-NAT-RANGEP, SET-CVZNX-X, BITP-FIX-BIT,
  ASR-C-BITP, SET-SET-CVZNX1, BLE-BGT, SUB-BGT, QUOTIENT-TIMES-LESSP,
  IQUOT-INT, ASR-INT, NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N,
  SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP, SUB-V-BITP, WRITE-WRITE-RN, ADD-BVS&VC,
  ISQRT-NO-OVERFLOW, INITIAL-J-INT-RANGEP, ADD-V-BITP, ADD-C-BITP, BGE-V0,
  MOVE-BMI, ADD-INT, IPLUS-COMMUTATIVITY, MOVE-N-BITP, STEPN-REWRITER0,
  STEPN-REWRITER, DISJOINT-10, and READ-WRITE-MEM1, and opening up the
  functions EQUAL, EXECUTE-INS, OPCODE-FIELD, NOP-SUBGROUP, B1P, BVS, FIX-BIT,
  TRAPV-INS, B0P, BITN, MISC-GROUP, UPDATE-PC, ADD, L, CURRENT-INS, READ-LST,
  LEN, LST-NUMBERP, INDEX-N, PC-WORD-READ, PC-WORD-READP, WSZ, LESSP, PLUS,
  EVENP, STEPI, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CAR, EFFEC-ADDR, CONS,
  DN-DIRECT, S_RN, S_MODE, MC-INSTATE, MC-HALTP, READ-DN, NUMBERP, CDR,
  OPERAND, D_RN, CMP-CVZNX, UPDATE-CCR, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
  B-NOT, ILESSP, EXP, NEGP, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP,
  OPMODE-FIELD, ADD-INS1, ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, D-MAPPING,
  ADD-GROUP, IPLUS, MOVE-INS, MOVE-ADDR-MODEP, MAPPING, MOVE-EFFECT, B0,
  MOVE-CVZNX, MOVE-MAPPING, D_MODE, MOVE-GROUP, REGISTER-SHIFT-ROTATE,
  ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA, REGISTER-ASR-INS, and
  S&R-GROUP, to:

        T.

Case 1. (IMPLIES
         (AND (EQUAL (MC-STATUS S) 'RUNNING)
              (EVENP (MC-PC S))
              (ROM-ADDRP (MC-PC S) (MC-MEM S) 70)
              (MCODE-ADDRP (MC-PC S)
                           (MC-MEM S)
                           '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129
                                32 2 76 65 8 0 78 118 178 128 111 28 208 129
                                78 118 34 0 108 6 6 129 0 0 0 1 226 129 32 2
                                76 65 8 0 78 118 178 128 110 228 32 1 78 94
                                78 117))
              (RAM-ADDRP (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967288)
                         (MC-MEM S)
                         12)
              (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                          32)))
              (LESSP 1
                     (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32))
              (LESSP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                 32)
                     (TIMES (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)
                            (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                  32)
                                      2)))
              (DISJOINT X K
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967288)
                        12)
              (EQUAL (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                           32)
                               2)
                     0))
         (EQUAL
          (READ-MEM X
           (MC-MEM
            (STEPN
             (MC-STATE 'TRAP-EXCEPTION
              (WRITE-RN 32
                (READ-RN 32 2 (MC-RFILE S))
                0
                (WRITE-RN 32
                          (ASR 32 (READ-RN 32 2 (MC-RFILE S)) 1)
                          1
                          (WRITE-RN 32
                                    (ADD 32
                                         (READ-RN 32 15 (MC-RFILE S))
                                         4294967288)
                                    15
                                    (WRITE-RN 32
                                              (ADD 32
                                                   (READ-RN 32 15 (MC-RFILE S))
                                                   4294967292)
                                              14
                                              (MC-RFILE S)))))
              (ADD 32 (MC-PC S) 22)
              (SET-CVZNX (CVZNX 0 0
                                (MOVE-Z 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (MOVE-N 32
                                        (READ-RN 32 2 (MC-RFILE S)))
                                (ASR-C 32
                                       (READ-RN 32 2 (MC-RFILE S))
                                       1))
                         (MC-CCR S))
              (WRITE-MEM (READ-RN 32 14 (MC-RFILE S))
                         (ADD 32
                              (READ-RN 32 15 (MC-RFILE S))
                              4294967292)
                         (MC-MEM S)
                         4))
             8))
           K)
          (READ-MEM X (MC-MEM S) K))).

  But this again simplifies, expanding TIMES, EQUAL, and LESSP, to:

        T.

Q.E.D.


[ 0.0 0.1 0.1 ]

ISQRT-S-S0-MEM


(PROVE-LEMMA ISQRT-S0-EXIT-BASE
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J)
                           (NOT (LESSP (QUOTIENT I J) J)))
                      (AND (EQUAL (MC-STATUS (STEPN S 8))
                                  'RUNNING)
                           (EQUAL (MC-PC (STEPN S 8))
                                  (LINKED-RTS-ADDR S))
                           (EQUAL (IREAD-DN 32 0 (STEPN S 8)) J)
                           (EQUAL (READ-RN 32 14 (MC-RFILE (STEPN S 8)))
                                  (LINKED-A6 S))
                           (EQUAL (READ-RN 32 15 (MC-RFILE (STEPN S 8)))
                                  (ADD 32 (READ-AN 32 6 S) 8)))))

WARNING:  Note that ISQRT-S0-EXIT-BASE contains the free variables J and I
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that ISQRT-S0-EXIT-BASE contains the free variables J and I
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that the rewrite rule ISQRT-S0-EXIT-BASE will be stored so as
to apply only to terms with the nonrecursive function symbol IREAD-DN.


WARNING:  Note that ISQRT-S0-EXIT-BASE contains the free variables J and I
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that ISQRT-S0-EXIT-BASE contains the free variables J and I
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that ISQRT-S0-EXIT-BASE contains the free variables J and I
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that the proposed lemma ISQRT-S0-EXIT-BASE is to be stored as
zero type prescription rules, zero compound recognizer rules, zero linear
rules, and five replacement rules.


This conjecture can be simplified, using the abbreviations NOT, ISQRT-CODE,
ISQRT-S0P, AND, IMPLIES, and READ-AN, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (SUB 32 44 (MC-PC S))
                               (MC-MEM S)
                               70)
                    (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 4
                                    (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (EQUAL J (IREAD-DN 32 1 S))
                    (INT-RANGEP (TIMES 2 J) 32)
                    (ILESSP 1 I)
                    (ILESSP 0 J)
                    (NOT (LESSP (QUOTIENT I J) J)))
               (AND (EQUAL (MC-STATUS (STEPN S 8))
                           'RUNNING)
                    (EQUAL (MC-PC (STEPN S 8))
                           (LINKED-RTS-ADDR S))
                    (EQUAL (IREAD-DN 32 0 (STEPN S 8)) J)
                    (EQUAL (READ-RN 32 14 (MC-RFILE (STEPN S 8)))
                           (LINKED-A6 S))
                    (EQUAL (READ-RN 32 15 (MC-RFILE (STEPN S 8)))
                           (ADD 32
                                (READ-RN 32 (PLUS 8 6) (MC-RFILE S))
                                8)))).

This simplifies, applying SUB-NEG, NAT-TO-INT-INTEGERP, READ-RN-NAT-RANGEP,
NEGATIVEP-GUTS0, QUOTIENT-TIMES-LESSP, CDR-CONS, CAR-CONS, MC-STATUS-REWRITE,
MC-RFILE-REWRITE, MC-MEM-REWRITE, MC-PC-REWRITE, ADD-NAT-RANGEP,
MC-CCR-REWRITE, MC-CCR-RANGEP, PC-READ-MEM-MCODE2, PC-READ-MEMP-ROM2,
HEAD-READ-RN, SET-SET-CVZNX1, WRITE-WRITE-RN, SET-CVZNX-X, DIVS_3232-OVERFLOW,
READ-WRITE-RN, SET-CVZNX-NAT-RANGEP, ADD-ASSOCIATIVITY, PC-READ-MEM-MCODE3,
PC-READ-MEMP-ROM3, ADD-EVENP, SET-CVZNX-V, IQUOT-NAT-RANGEP, HEAD-LEMMA,
BITP-FIX-BIT, FIX-BIT-BITP, SUB-BGT, IQUOT-INT, NAT-TO-INT-RANGEP,
QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
SUB-V-BITP, READ-MEMP-RAM2, READ-MEMP-RAM3, STEPN-REWRITER0, STEPN-REWRITER,
and READ-MEM-NAT-RANGEP, and opening up NEG, PLUS, READ-DN, IREAD-DN,
NEGATIVE-GUTS, NEGP, ILESSP, LESSP, EQUAL, EXECUTE-INS, OPCODE-FIELD, MOVE-INS,
MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE, MC-INSTATE,
MC-HALTP, CDR, OPERAND, MAPPING, D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, D_RN,
MOVE-MAPPING, D_MODE, MOVE-GROUP, UPDATE-PC, L, CURRENT-INS, READ-LST, LEN,
LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ, INDEX-N, STEPI,
MOVEM-EA-RN-SUBGROUP, DIV_L-INS, DQ, DR, UPDATE-CCR, WRITE-DN, UPDATE-RFILE,
DIVS-CVZNX, DIVSL_L, NUMBERP, MUL&DIV-ADDR-MODEP, BITS, MUL-DIV_L-INS, B0P,
BITN, MISC-GROUP, ADD, EVENP, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS,
OP-LEN, CMP-INS, CMP-ADDR-MODEP, CMP-CVZNX, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, UNLK-SUBGROUP, WRITE-SP, SP,
WRITE-AN, LONG-READ, LONG-READP, LSZ, READ-AN, UNLK-INS, RTD-MAPPING, W,
READ-SP, RTS-INS, TIMES, LINKED-RTS-ADDR, LINKED-A6, and AND, to:

      T.

Q.E.D.


[ 0.0 0.5 0.0 ]

ISQRT-S0-EXIT-BASE


(PROVE-LEMMA ISQRT1-S0-EXIT-RFILE-BASE
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J)
                           (NOT (LESSP (QUOTIENT I J) J))
                           (D2-7A2-5P RN))
                      (EQUAL (READ-RN OPLEN RN
                                      (MC-RFILE (STEPN S 8)))
                             (READ-RN OPLEN RN (MC-RFILE S)))))

WARNING:  Note that ISQRT1-S0-EXIT-RFILE-BASE contains the free variables J
and I which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


This formula can be simplified, using the abbreviations D2-7A2-5P, NOT,
READ-AN, ISQRT-CODE, ISQRT-S0P, AND, and IMPLIES, to the new conjecture:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (SUB 32 44 (MC-PC S))
                               (MC-MEM S)
                               70)
                    (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 4
                                    (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (EQUAL J (IREAD-DN 32 1 S))
                    (INT-RANGEP (TIMES 2 J) 32)
                    (ILESSP 1 I)
                    (ILESSP 0 J)
                    (NOT (LESSP (QUOTIENT I J) J))
                    (NOT (EQUAL RN 0))
                    (NUMBERP RN)
                    (NOT (EQUAL RN 1))
                    (NOT (EQUAL RN 8))
                    (NOT (EQUAL RN 9))
                    (NOT (EQUAL RN 14))
                    (NOT (EQUAL RN 15)))
               (EQUAL (READ-RN OPLEN RN
                               (MC-RFILE (STEPN S 8)))
                      (READ-RN OPLEN RN (MC-RFILE S)))),

which simplifies, applying SUB-NEG, NAT-TO-INT-INTEGERP, READ-RN-NAT-RANGEP,
NEGATIVEP-GUTS0, QUOTIENT-TIMES-LESSP, CDR-CONS, CAR-CONS, MC-STATUS-REWRITE,
MC-RFILE-REWRITE, MC-MEM-REWRITE, MC-PC-REWRITE, ADD-NAT-RANGEP,
MC-CCR-REWRITE, MC-CCR-RANGEP, PC-READ-MEM-MCODE2, PC-READ-MEMP-ROM2,
HEAD-READ-RN, SET-SET-CVZNX1, WRITE-WRITE-RN, SET-CVZNX-X, DIVS_3232-OVERFLOW,
READ-WRITE-RN, SET-CVZNX-NAT-RANGEP, ADD-ASSOCIATIVITY, PC-READ-MEM-MCODE3,
PC-READ-MEMP-ROM3, ADD-EVENP, SET-CVZNX-V, IQUOT-NAT-RANGEP, HEAD-LEMMA,
BITP-FIX-BIT, FIX-BIT-BITP, SUB-BGT, IQUOT-INT, NAT-TO-INT-RANGEP,
QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
SUB-V-BITP, READ-MEMP-RAM2, READ-MEMP-RAM3, STEPN-REWRITER0, and
STEPN-REWRITER, and unfolding the definitions of NEG, PLUS, READ-DN, IREAD-DN,
NEGATIVE-GUTS, NEGP, ILESSP, LESSP, EQUAL, EXECUTE-INS, OPCODE-FIELD, MOVE-INS,
MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE, MC-INSTATE,
MC-HALTP, CDR, OPERAND, MAPPING, D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, D_RN,
MOVE-MAPPING, D_MODE, MOVE-GROUP, UPDATE-PC, L, CURRENT-INS, READ-LST, LEN,
LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ, INDEX-N, STEPI,
MOVEM-EA-RN-SUBGROUP, DIV_L-INS, DQ, DR, UPDATE-CCR, WRITE-DN, UPDATE-RFILE,
DIVS-CVZNX, DIVSL_L, NUMBERP, MUL&DIV-ADDR-MODEP, BITS, MUL-DIV_L-INS, B0P,
BITN, MISC-GROUP, ADD, EVENP, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS,
OP-LEN, CMP-INS, CMP-ADDR-MODEP, CMP-CVZNX, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, UNLK-SUBGROUP, WRITE-SP, SP,
WRITE-AN, LONG-READ, LONG-READP, LSZ, READ-AN, UNLK-INS, RTD-MAPPING, W,
READ-SP, and RTS-INS, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT1-S0-EXIT-RFILE-BASE


(PROVE-LEMMA ISQRT1-S0-EXIT-MEM-BASE
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J)
                           (NOT (LESSP (QUOTIENT I J) J)))
                      (EQUAL (READ-MEM X (MC-MEM (STEPN S 8)) K)
                             (READ-MEM X (MC-MEM S) K))))

WARNING:  Note that ISQRT1-S0-EXIT-MEM-BASE contains the free variables J and
I which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


This conjecture can be simplified, using the abbreviations NOT, READ-AN,
ISQRT-CODE, ISQRT-S0P, AND, and IMPLIES, to the conjecture:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (SUB 32 44 (MC-PC S))
                               (MC-MEM S)
                               70)
                    (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 4
                                    (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (EQUAL J (IREAD-DN 32 1 S))
                    (INT-RANGEP (TIMES 2 J) 32)
                    (ILESSP 1 I)
                    (ILESSP 0 J)
                    (NOT (LESSP (QUOTIENT I J) J)))
               (EQUAL (READ-MEM X (MC-MEM (STEPN S 8)) K)
                      (READ-MEM X (MC-MEM S) K))).

This simplifies, rewriting with SUB-NEG, NAT-TO-INT-INTEGERP,
READ-RN-NAT-RANGEP, NEGATIVEP-GUTS0, QUOTIENT-TIMES-LESSP, CDR-CONS, CAR-CONS,
MC-STATUS-REWRITE, MC-RFILE-REWRITE, MC-MEM-REWRITE, MC-PC-REWRITE,
ADD-NAT-RANGEP, MC-CCR-REWRITE, MC-CCR-RANGEP, PC-READ-MEM-MCODE2,
PC-READ-MEMP-ROM2, HEAD-READ-RN, SET-SET-CVZNX1, WRITE-WRITE-RN, SET-CVZNX-X,
DIVS_3232-OVERFLOW, READ-WRITE-RN, SET-CVZNX-NAT-RANGEP, ADD-ASSOCIATIVITY,
PC-READ-MEM-MCODE3, PC-READ-MEMP-ROM3, ADD-EVENP, SET-CVZNX-V,
IQUOT-NAT-RANGEP, HEAD-LEMMA, BITP-FIX-BIT, FIX-BIT-BITP, SUB-BGT, IQUOT-INT,
NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z,
SUB-Z-BITP, SUB-V-BITP, READ-MEMP-RAM2, READ-MEMP-RAM3, STEPN-REWRITER0, and
STEPN-REWRITER, and opening up the functions NEG, PLUS, READ-DN, IREAD-DN,
NEGATIVE-GUTS, NEGP, ILESSP, LESSP, EQUAL, EXECUTE-INS, OPCODE-FIELD, MOVE-INS,
MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE, MC-INSTATE,
MC-HALTP, CDR, OPERAND, MAPPING, D-MAPPING, MOVE-EFFECT, B0, MOVE-CVZNX, D_RN,
MOVE-MAPPING, D_MODE, MOVE-GROUP, UPDATE-PC, L, CURRENT-INS, READ-LST, LEN,
LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ, INDEX-N, STEPI,
MOVEM-EA-RN-SUBGROUP, DIV_L-INS, DQ, DR, UPDATE-CCR, WRITE-DN, UPDATE-RFILE,
DIVS-CVZNX, DIVSL_L, NUMBERP, MUL&DIV-ADDR-MODEP, BITS, MUL-DIV_L-INS, B0P,
BITN, MISC-GROUP, ADD, EVENP, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS,
OP-LEN, CMP-INS, CMP-ADDR-MODEP, CMP-CVZNX, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, UNLK-SUBGROUP, WRITE-SP, SP,
WRITE-AN, LONG-READ, LONG-READP, LSZ, READ-AN, UNLK-INS, RTD-MAPPING, W,
READ-SP, and RTS-INS, to:

      T.

Q.E.D.


[ 0.0 0.3 0.0 ]

ISQRT1-S0-EXIT-MEM-BASE


(PROVE-LEMMA ISQRT-S0-S0
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J)
                           (LESSP (QUOTIENT I J) J))
                      (AND (ISQRT-S0P (STEPN S 10)
                                      I
                                      (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                           (EQUAL (READ-RN OPLEN 14
                                           (MC-RFILE (STEPN S 10)))
                                  (READ-RN OPLEN 14 (MC-RFILE S)))
                           (EQUAL (LINKED-A6 (STEPN S 10))
                                  (LINKED-A6 S))
                           (EQUAL (LINKED-RTS-ADDR (STEPN S 10))
                                  (LINKED-RTS-ADDR S))))
             ((DISABLE QUOTIENT-EQUAL-0 QUOTIENT-TIMES-LESSP)))

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


WARNING:  Note that ISQRT-S0-S0 contains the free variables J and I which will
be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that the rewrite rule ISQRT-S0-S0 will be stored so as to apply
only to terms with the nonrecursive function symbol LINKED-A6.


WARNING:  Note that ISQRT-S0-S0 contains the free variables J and I which will
be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that the rewrite rule ISQRT-S0-S0 will be stored so as to apply
only to terms with the nonrecursive function symbol LINKED-RTS-ADDR.


WARNING:  Note that ISQRT-S0-S0 contains the free variables J and I which will
be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


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


This formula can be simplified, using the abbreviations READ-AN, ISQRT-CODE,
ISQRT-S0P, AND, and IMPLIES, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (SUB 32 44 (MC-PC S))
                               (MC-MEM S)
                               70)
                    (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 4
                                    (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (EQUAL J (IREAD-DN 32 1 S))
                    (INT-RANGEP (TIMES 2 J) 32)
                    (ILESSP 1 I)
                    (ILESSP 0 J)
                    (LESSP (QUOTIENT I J) J))
               (AND (ISQRT-S0P (STEPN S 10)
                               I
                               (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                    (EQUAL (READ-RN OPLEN 14
                                    (MC-RFILE (STEPN S 10)))
                           (READ-RN OPLEN 14 (MC-RFILE S)))
                    (EQUAL (LINKED-A6 (STEPN S 10))
                           (LINKED-A6 S))
                    (EQUAL (LINKED-RTS-ADDR (STEPN S 10))
                           (LINKED-RTS-ADDR S)))),

which simplifies, rewriting with SUB-NEG, NAT-TO-INT-INTEGERP,
READ-RN-NAT-RANGEP, NEGATIVEP-GUTS0, CDR-CONS, CAR-CONS, MC-STATUS-REWRITE,
MC-RFILE-REWRITE, MC-MEM-REWRITE, MC-PC-REWRITE, ADD-NAT-RANGEP,
MC-CCR-REWRITE, MC-CCR-RANGEP, PC-READ-MEM-MCODE2, PC-READ-MEMP-ROM2,
HEAD-READ-RN, SET-SET-CVZNX1, WRITE-WRITE-RN, SET-CVZNX-X, DIVS_3232-OVERFLOW,
READ-WRITE-RN, SET-CVZNX-NAT-RANGEP, ADD-ASSOCIATIVITY, PC-READ-MEM-MCODE3,
PC-READ-MEMP-ROM3, ADD-EVENP, SET-CVZNX-V, IQUOT-NAT-RANGEP, HEAD-LEMMA,
BITP-FIX-BIT, FIX-BIT-BITP, SUB-BGT, IQUOT-INT, NAT-TO-INT-RANGEP,
QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
SUB-V-BITP, ADD-BVS&VC, ISQRT-NO-OVERFLOW, ADD-V-BITP, ADD-C-BITP, BGE-V0,
MOVE-BMI, ADD-INT, IPLUS-COMMUTATIVITY, MOVE-N-BITP, ADD-0, MC-PC-RANGEP,
STEPN-REWRITER0, STEPN-REWRITER, INITIAL-J-INT-RANGEP, ASR-NAT-RANGEP, ASR-INT,
RAM-ADDRP-3, ROM-ADDRP-LA2, and INDEX-N-DEDUCTION2, and unfolding NEG, PLUS,
READ-DN, IREAD-DN, NEGATIVE-GUTS, NEGP, ILESSP, LESSP, EQUAL, EXECUTE-INS,
OPCODE-FIELD, MOVE-INS, MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT,
S_RN, S_MODE, MC-INSTATE, MC-HALTP, CDR, OPERAND, MAPPING, D-MAPPING,
MOVE-EFFECT, B0, MOVE-CVZNX, D_RN, MOVE-MAPPING, D_MODE, MOVE-GROUP, UPDATE-PC,
L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ,
INDEX-N, STEPI, MOVEM-EA-RN-SUBGROUP, DIV_L-INS, DQ, DR, UPDATE-CCR, WRITE-DN,
UPDATE-RFILE, DIVS-CVZNX, DIVSL_L, NUMBERP, MUL&DIV-ADDR-MODEP, BITS,
MUL-DIV_L-INS, B0P, BITN, MISC-GROUP, ADD, EVENP, NOP-SUBGROUP, B1P, BVS,
FIX-BIT, TRAPV-INS, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CMP-CVZNX, Q, CMP-GROUP,
B, HEAD, BCC-RA-SR, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP,
OPMODE-FIELD, ADD-INS1, ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, ADD-GROUP,
IPLUS, B-NOT, REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT,
I-DATA, REGISTER-ASR-INS, S&R-GROUP, EXP, READ-AN, ISQRT-CODE, ISQRT-S0P,
LINKED-A6, LINKED-RTS-ADDR, and AND, to the new conjecture:

      (IMPLIES
       (AND (EQUAL (MC-STATUS S) 'RUNNING)
            (EVENP (MC-PC S))
            (ROM-ADDRP (ADD 32 (MC-PC S) 4294967252)
                       (MC-MEM S)
                       70)
            (MCODE-ADDRP (ADD 32 (MC-PC S) 4294967252)
                         (MC-MEM S)
                         '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32
                              2 76 65 8 0 78 118 178 128 111 28 208 129 78
                              118 34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65
                              8 0 78 118 178 128 110 228 32 1 78 94 78 117))
            (RAM-ADDRP (ADD 32
                            (READ-RN 32 14 (MC-RFILE S))
                            4294967292)
                       (MC-MEM S)
                       12)
            (INT-RANGEP (TIMES 2
                               (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                           32))
                        32)
            (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                        32)))
            (LESSP 1
                   (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                               32))
            (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                        32)))
            (NOT (EQUAL (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                    32)
                        0))
            (LESSP (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                         32)
                             (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                         32))
                   (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                               32)))
       (NOT
        (EQUAL
              (QUOTIENT (PLUS (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                          32)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                                    32)))
                        2)
              0))),

which again simplifies, using linear arithmetic, applying
QUOTIENT-LESSP-LINEAR and J-NONZEROP, and opening up LESSP, to:

      (IMPLIES
       (AND (EQUAL (MC-STATUS S) 'RUNNING)
            (EVENP (MC-PC S))
            (ROM-ADDRP (ADD 32 (MC-PC S) 4294967252)
                       (MC-MEM S)
                       70)
            (MCODE-ADDRP (ADD 32 (MC-PC S) 4294967252)
                         (MC-MEM S)
                         '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226 129 32
                              2 76 65 8 0 78 118 178 128 111 28 208 129 78
                              118 34 0 108 6 6 129 0 0 0 1 226 129 32 2 76 65
                              8 0 78 118 178 128 110 228 32 1 78 94 78 117))
            (RAM-ADDRP (ADD 32
                            (READ-RN 32 14 (MC-RFILE S))
                            4294967292)
                       (MC-MEM S)
                       12)
            (INT-RANGEP (TIMES 2
                               (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                           32))
                        32)
            (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                        32)))
            (LESSP 1
                   (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                               32))
            (NOT (NEGATIVEP (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                        32)))
            (NOT (EQUAL (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                    32)
                        0))
            (LESSP (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                         32)
                             (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                         32))
                   (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                               32))
            (NOT (NUMBERP (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                      32))))
       (NOT
        (EQUAL
              (QUOTIENT (PLUS (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                          32)
                              (QUOTIENT (NAT-TO-INT (READ-RN 32 2 (MC-RFILE S))
                                                    32)
                                        (NAT-TO-INT (READ-RN 32 1 (MC-RFILE S))
                                                    32)))
                        2)
              0))),

which again simplifies, trivially, to:

      T.

Q.E.D.


[ 0.0 0.6 0.0 ]

ISQRT-S0-S0


(PROVE-LEMMA ISQRT-S0-S0-RFILE
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J)
                           (LESSP (QUOTIENT I J) J)
                           (D2-7A2-5P RN))
                      (EQUAL (READ-RN OPLEN RN
                                      (MC-RFILE (STEPN S 10)))
                             (READ-RN OPLEN RN (MC-RFILE S)))))

WARNING:  Note that ISQRT-S0-S0-RFILE contains the free variables J and I
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


This formula can be simplified, using the abbreviations D2-7A2-5P, READ-AN,
ISQRT-CODE, ISQRT-S0P, AND, and IMPLIES, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (SUB 32 44 (MC-PC S))
                               (MC-MEM S)
                               70)
                    (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 4
                                    (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (EQUAL J (IREAD-DN 32 1 S))
                    (INT-RANGEP (TIMES 2 J) 32)
                    (ILESSP 1 I)
                    (ILESSP 0 J)
                    (LESSP (QUOTIENT I J) J)
                    (NOT (EQUAL RN 0))
                    (NUMBERP RN)
                    (NOT (EQUAL RN 1))
                    (NOT (EQUAL RN 8))
                    (NOT (EQUAL RN 9))
                    (NOT (EQUAL RN 14))
                    (NOT (EQUAL RN 15)))
               (EQUAL (READ-RN OPLEN RN
                               (MC-RFILE (STEPN S 10)))
                      (READ-RN OPLEN RN (MC-RFILE S)))),

which simplifies, applying SUB-NEG, NAT-TO-INT-INTEGERP, READ-RN-NAT-RANGEP,
NEGATIVEP-GUTS0, QUOTIENT-TIMES-LESSP, CDR-CONS, CAR-CONS, MC-STATUS-REWRITE,
MC-RFILE-REWRITE, MC-MEM-REWRITE, MC-PC-REWRITE, ADD-NAT-RANGEP,
MC-CCR-REWRITE, MC-CCR-RANGEP, PC-READ-MEM-MCODE2, PC-READ-MEMP-ROM2,
HEAD-READ-RN, SET-SET-CVZNX1, WRITE-WRITE-RN, SET-CVZNX-X, DIVS_3232-OVERFLOW,
READ-WRITE-RN, SET-CVZNX-NAT-RANGEP, ADD-ASSOCIATIVITY, PC-READ-MEM-MCODE3,
PC-READ-MEMP-ROM3, ADD-EVENP, SET-CVZNX-V, IQUOT-NAT-RANGEP, HEAD-LEMMA,
BITP-FIX-BIT, FIX-BIT-BITP, SUB-BGT, IQUOT-INT, NAT-TO-INT-RANGEP,
QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z, SUB-Z-BITP,
SUB-V-BITP, ADD-BVS&VC, ISQRT-NO-OVERFLOW, ADD-V-BITP, ADD-C-BITP, BGE-V0,
MOVE-BMI, ADD-INT, IPLUS-COMMUTATIVITY, MOVE-N-BITP, ADD-0, MC-PC-RANGEP,
STEPN-REWRITER0, and STEPN-REWRITER, and expanding NEG, PLUS, READ-DN,
IREAD-DN, NEGATIVE-GUTS, NEGP, ILESSP, LESSP, EQUAL, EXECUTE-INS, OPCODE-FIELD,
MOVE-INS, MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT, S_RN, S_MODE,
MC-INSTATE, MC-HALTP, CDR, OPERAND, MAPPING, D-MAPPING, MOVE-EFFECT, B0,
MOVE-CVZNX, D_RN, MOVE-MAPPING, D_MODE, MOVE-GROUP, UPDATE-PC, L, CURRENT-INS,
READ-LST, LEN, LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ, INDEX-N, STEPI,
MOVEM-EA-RN-SUBGROUP, DIV_L-INS, DQ, DR, UPDATE-CCR, WRITE-DN, UPDATE-RFILE,
DIVS-CVZNX, DIVSL_L, NUMBERP, MUL&DIV-ADDR-MODEP, BITS, MUL-DIV_L-INS, B0P,
BITN, MISC-GROUP, ADD, EVENP, NOP-SUBGROUP, B1P, BVS, FIX-BIT, TRAPV-INS,
OP-LEN, CMP-INS, CMP-ADDR-MODEP, CMP-CVZNX, Q, CMP-GROUP, B, HEAD, BCC-RA-SR,
IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP, OPMODE-FIELD, ADD-INS1,
ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, ADD-GROUP, IPLUS, B-NOT,
REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT, I-DATA,
REGISTER-ASR-INS, and S&R-GROUP, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT-S0-S0-RFILE


(PROVE-LEMMA ISQRT-S0-S0-MEM
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J)
                           (LESSP (QUOTIENT I J) J)
                           (DISJOINT X K
                                     (SUB 32 8 (READ-AN 32 6 S))
                                     20))
                      (EQUAL (READ-MEM X (MC-MEM (STEPN S 10)) K)
                             (READ-MEM X (MC-MEM S) K))))

WARNING:  Note that ISQRT-S0-S0-MEM contains the free variables J and I which
will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


This conjecture can be simplified, using the abbreviations ISQRT-CODE,
ISQRT-S0P, AND, IMPLIES, and READ-AN, to the formula:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (SUB 32 44 (MC-PC S))
                               (MC-MEM S)
                               70)
                    (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 4
                                    (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (EQUAL J (IREAD-DN 32 1 S))
                    (INT-RANGEP (TIMES 2 J) 32)
                    (ILESSP 1 I)
                    (ILESSP 0 J)
                    (LESSP (QUOTIENT I J) J)
                    (DISJOINT X K
                              (SUB 32 8
                                   (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                              20))
               (EQUAL (READ-MEM X (MC-MEM (STEPN S 10)) K)
                      (READ-MEM X (MC-MEM S) K))).

This simplifies, rewriting with SUB-NEG, NAT-TO-INT-INTEGERP,
READ-RN-NAT-RANGEP, NEGATIVEP-GUTS0, QUOTIENT-TIMES-LESSP, CDR-CONS, CAR-CONS,
MC-STATUS-REWRITE, MC-RFILE-REWRITE, MC-MEM-REWRITE, MC-PC-REWRITE,
ADD-NAT-RANGEP, MC-CCR-REWRITE, MC-CCR-RANGEP, PC-READ-MEM-MCODE2,
PC-READ-MEMP-ROM2, HEAD-READ-RN, SET-SET-CVZNX1, WRITE-WRITE-RN, SET-CVZNX-X,
DIVS_3232-OVERFLOW, READ-WRITE-RN, SET-CVZNX-NAT-RANGEP, ADD-ASSOCIATIVITY,
PC-READ-MEM-MCODE3, PC-READ-MEMP-ROM3, ADD-EVENP, SET-CVZNX-V,
IQUOT-NAT-RANGEP, HEAD-LEMMA, BITP-FIX-BIT, FIX-BIT-BITP, SUB-BGT, IQUOT-INT,
NAT-TO-INT-RANGEP, QUOTIENT-INT-RANGEP, SET-CVZNX-N, SUB-N-BITP, SET-CVZNX-Z,
SUB-Z-BITP, SUB-V-BITP, ADD-BVS&VC, ISQRT-NO-OVERFLOW, ADD-V-BITP, ADD-C-BITP,
BGE-V0, MOVE-BMI, ADD-INT, IPLUS-COMMUTATIVITY, MOVE-N-BITP, ADD-0,
MC-PC-RANGEP, STEPN-REWRITER0, and STEPN-REWRITER, and expanding NEG, PLUS,
READ-DN, IREAD-DN, NEGATIVE-GUTS, NEGP, ILESSP, LESSP, EQUAL, EXECUTE-INS,
OPCODE-FIELD, MOVE-INS, MOVE-ADDR-MODEP, CAR, EFFEC-ADDR, CONS, DN-DIRECT,
S_RN, S_MODE, MC-INSTATE, MC-HALTP, CDR, OPERAND, MAPPING, D-MAPPING,
MOVE-EFFECT, B0, MOVE-CVZNX, D_RN, MOVE-MAPPING, D_MODE, MOVE-GROUP, UPDATE-PC,
L, CURRENT-INS, READ-LST, LEN, LST-NUMBERP, PC-WORD-READ, PC-WORD-READP, WSZ,
INDEX-N, STEPI, MOVEM-EA-RN-SUBGROUP, DIV_L-INS, DQ, DR, UPDATE-CCR, WRITE-DN,
UPDATE-RFILE, DIVS-CVZNX, DIVSL_L, NUMBERP, MUL&DIV-ADDR-MODEP, BITS,
MUL-DIV_L-INS, B0P, BITN, MISC-GROUP, ADD, EVENP, NOP-SUBGROUP, B1P, BVS,
FIX-BIT, TRAPV-INS, OP-LEN, CMP-INS, CMP-ADDR-MODEP, CMP-CVZNX, Q, CMP-GROUP,
B, HEAD, BCC-RA-SR, IQUOTIENT, BRANCH-CC, EXT, COND-FIELD, BCC-GROUP,
OPMODE-FIELD, ADD-INS1, ADD-ADDR-MODEP1, ADD-CVZNX, ADD-EFFECT, ADD-GROUP,
IPLUS, B-NOT, REGISTER-SHIFT-ROTATE, ASR-EFFECT, ASR-X, ASR-CVZNX, SR-CNT,
I-DATA, REGISTER-ASR-INS, and S&R-GROUP, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT-S0-S0-MEM


(PROVE-LEMMA ISQRT-S0P-J_NONZEROP
             (REWRITE)
             (IMPLIES (ISQRT-S0P S I J)
                      (AND (NOT (EQUAL J 0)) (NUMBERP J))))

WARNING:  Note that ISQRT-S0P-J_NONZEROP contains the free variables I and S
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


WARNING:  Note that ISQRT-S0P-J_NONZEROP contains the free variables I and S
which will be chosen by instantiating the hypothesis (ISQRT-S0P S I J).


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


This formula can be simplified, using the abbreviations READ-AN, ISQRT-CODE,
ISQRT-S0P, and IMPLIES, to:

      (IMPLIES (AND (EQUAL (MC-STATUS S) 'RUNNING)
                    (EVENP (MC-PC S))
                    (ROM-ADDRP (SUB 32 44 (MC-PC S))
                               (MC-MEM S)
                               70)
                    (MCODE-ADDRP (SUB 32 44 (MC-PC S))
                                 (MC-MEM S)
                                 '(78 86 255 252 34 2 108 6 6 129 0 0 0 1 226
                                      129 32 2 76 65 8 0 78 118 178 128 111
                                      28 208 129 78 118 34 0 108 6 6 129 0 0
                                      0 1 226 129 32 2 76 65 8 0 78 118 178
                                      128 110 228 32 1 78 94 78 117))
                    (RAM-ADDRP (SUB 32 4
                                    (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                               (MC-MEM S)
                               12)
                    (EQUAL I (IREAD-DN 32 2 S))
                    (EQUAL J (IREAD-DN 32 1 S))
                    (INT-RANGEP (TIMES 2 J) 32)
                    (ILESSP 1 I)
                    (ILESSP 0 J))
               (AND (NOT (EQUAL J 0)) (NUMBERP J))),

which simplifies, rewriting with SUB-NEG, NAT-TO-INT-INTEGERP,
READ-RN-NAT-RANGEP, and NEGATIVEP-GUTS0, and expanding the definitions of NEG,
PLUS, READ-DN, IREAD-DN, NEGATIVE-GUTS, NEGP, ILESSP, LESSP, EQUAL, NOT, and
AND, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ISQRT-S0P-J_NONZEROP


(DISABLE ISQRT-STATEP)

[ 0.0 0.0 0.0 ]

ISQRT-STATEP-OFF


(DISABLE ISQRT-S0P)

[ 0.0 0.0 0.0 ]

ISQRT-S0P-OFF


(PROVE-LEMMA ISQRT-S0-EXIT
             (REWRITE)
             (LET ((SN (STEPN S (ISQRT1-T I J))))
                  (IMPLIES (ISQRT-S0P S I J)
                           (AND (EQUAL (MC-STATUS SN) 'RUNNING)
                                (EQUAL (MC-PC SN) (LINKED-RTS-ADDR S))
                                (EQUAL (IREAD-DN 32 0 SN)
                                       (ISQRT1 I J))
                                (EQUAL (READ-RN 32 14 (MC-RFILE SN))
                                       (LINKED-A6 S))
                                (EQUAL (READ-RN 32 15 (MC-RFILE SN))
                                       (ADD 32 (READ-AN 32 6 S) 8)))))
             ((INDUCT (ISQRT-INDUCT S I J))
              (DISABLE QUOTIENT-TIMES-LESSP LINKED-RTS-ADDR LINKED-A6
                       IREAD-DN)))

WARNING:  Note that the rewrite rule ISQRT-S0-EXIT will be stored so as to
apply only to terms with the nonrecursive function symbol IREAD-DN.


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


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

Case 3. (IMPLIES (AND (ZEROP J) (ISQRT-S0P S I J))
                 (AND (EQUAL (MC-STATUS (STEPN S (ISQRT1-T I J)))
                             'RUNNING)
                      (EQUAL (MC-PC (STEPN S (ISQRT1-T I J)))
                             (LINKED-RTS-ADDR S))
                      (EQUAL (IREAD-DN 32 0
                                       (STEPN S (ISQRT1-T I J)))
                             (ISQRT1 I J))
                      (EQUAL (READ-RN 32 14
                                      (MC-RFILE (STEPN S (ISQRT1-T I J))))
                             (LINKED-A6 S))
                      (EQUAL (READ-RN 32 15
                                      (MC-RFILE (STEPN S (ISQRT1-T I J))))
                             (ADD 32
                                  (READ-RN 32 (PLUS 8 6) (MC-RFILE S))
                                  8)))),

  which simplifies, rewriting with the lemma ISQRT-S0P-J_NONZEROP, and
  expanding the definition of ZEROP, to:

        T.

Case 2. (IMPLIES
         (AND
          (NOT (EQUAL J 0))
          (NUMBERP J)
          (LESSP (QUOTIENT I J) J)
          (IMPLIES
           (ISQRT-S0P (STEPN S 10)
                      I
                      (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
           (AND
            (EQUAL
                  (MC-STATUS (STEPN (STEPN S 10)
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))
                  'RUNNING)
            (EQUAL (MC-PC (STEPN (STEPN S 10)
                                 (ISQRT1-T I
                                           (QUOTIENT (PLUS J (QUOTIENT I J))
                                                     2))))
                   (LINKED-RTS-ADDR (STEPN S 10)))
            (EQUAL (IREAD-DN 32 0
                             (STEPN (STEPN S 10)
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))
                   (ISQRT1 I
                           (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
            (EQUAL
             (READ-RN 32 14
                   (MC-RFILE (STEPN (STEPN S 10)
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))
             (LINKED-A6 (STEPN S 10)))
            (EQUAL
             (READ-RN 32 15
                   (MC-RFILE (STEPN (STEPN S 10)
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))
             (ADD 32
                  (READ-RN 32
                           (PLUS 8 6)
                           (MC-RFILE (STEPN S 10)))
                  8))))
          (ISQRT-S0P S I J))
         (AND (EQUAL (MC-STATUS (STEPN S (ISQRT1-T I J)))
                     'RUNNING)
              (EQUAL (MC-PC (STEPN S (ISQRT1-T I J)))
                     (LINKED-RTS-ADDR S))
              (EQUAL (IREAD-DN 32 0
                               (STEPN S (ISQRT1-T I J)))
                     (ISQRT1 I J))
              (EQUAL (READ-RN 32 14
                              (MC-RFILE (STEPN S (ISQRT1-T I J))))
                     (LINKED-A6 S))
              (EQUAL (READ-RN 32 15
                              (MC-RFILE (STEPN S (ISQRT1-T I J))))
                     (ADD 32
                          (READ-RN 32 (PLUS 8 6) (MC-RFILE S))
                          8)))),

  which simplifies, rewriting with ISQRT-S0P-J_NONZEROP, ISQRT-S0-S0, and
  STEPN-LEMMA, and opening up the functions PLUS, AND, IMPLIES, ISQRT1-T,
  EQUAL, and ISQRT1, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (QUOTIENT I J) J))
                      (ISQRT-S0P S I J))
                 (AND (EQUAL (MC-STATUS (STEPN S (ISQRT1-T I J)))
                             'RUNNING)
                      (EQUAL (MC-PC (STEPN S (ISQRT1-T I J)))
                             (LINKED-RTS-ADDR S))
                      (EQUAL (IREAD-DN 32 0
                                       (STEPN S (ISQRT1-T I J)))
                             (ISQRT1 I J))
                      (EQUAL (READ-RN 32 14
                                      (MC-RFILE (STEPN S (ISQRT1-T I J))))
                             (LINKED-A6 S))
                      (EQUAL (READ-RN 32 15
                                      (MC-RFILE (STEPN S (ISQRT1-T I J))))
                             (ADD 32
                                  (READ-RN 32 (PLUS 8 6) (MC-RFILE S))
                                  8)))).

  This simplifies, applying ISQRT-S0P-J_NONZEROP and ISQRT-S0-EXIT-BASE, and
  unfolding the functions ISQRT1-T, EQUAL, ISQRT1, PLUS, READ-AN, and AND, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT-S0-EXIT


(PROVE-LEMMA ISQRT-S0-EXIT-RFILE
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J) (D2-7A2-5P RN))
                      (EQUAL (READ-RN OPLEN RN
                                      (MC-RFILE (STEPN S (ISQRT1-T I J))))
                             (READ-RN OPLEN RN (MC-RFILE S))))
             ((INDUCT (ISQRT-INDUCT S I J))))

This formula can be simplified, using the abbreviations ZEROP, D2-7A2-5P,
IMPLIES, NOT, OR, and AND, to the following three new formulas:

Case 3. (IMPLIES (AND (ZEROP J)
                      (ISQRT-S0P S I J)
                      (NOT (EQUAL RN 0))
                      (NUMBERP RN)
                      (NOT (EQUAL RN 1))
                      (NOT (EQUAL RN 8))
                      (NOT (EQUAL RN 9))
                      (NOT (EQUAL RN 14))
                      (NOT (EQUAL RN 15)))
                 (EQUAL (READ-RN OPLEN RN
                                 (MC-RFILE (STEPN S (ISQRT1-T I J))))
                        (READ-RN OPLEN RN (MC-RFILE S)))).

  This simplifies, applying ISQRT-S0P-J_NONZEROP, and expanding the definition
  of ZEROP, to:

        T.

Case 2. (IMPLIES
         (AND
          (NOT (EQUAL J 0))
          (NUMBERP J)
          (LESSP (QUOTIENT I J) J)
          (IMPLIES
           (AND (ISQRT-S0P (STEPN S 10)
                           I
                           (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                (D2-7A2-5P RN))
           (EQUAL
            (READ-RN OPLEN RN
                   (MC-RFILE (STEPN (STEPN S 10)
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))
            (READ-RN OPLEN RN
                     (MC-RFILE (STEPN S 10)))))
          (ISQRT-S0P S I J)
          (NOT (EQUAL RN 0))
          (NUMBERP RN)
          (NOT (EQUAL RN 1))
          (NOT (EQUAL RN 8))
          (NOT (EQUAL RN 9))
          (NOT (EQUAL RN 14))
          (NOT (EQUAL RN 15)))
         (EQUAL (READ-RN OPLEN RN
                         (MC-RFILE (STEPN S (ISQRT1-T I J))))
                (READ-RN OPLEN RN (MC-RFILE S)))),

  which simplifies, using linear arithmetic, applying ISQRT-S0P-J_NONZEROP,
  QUOTIENT-TIMES-LESSP, ISQRT-S0-S0, ISQRT-S0-S0-RFILE, and STEPN-LEMMA, and
  expanding D2-7A2-5P, AND, IMPLIES, and ISQRT1-T, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (QUOTIENT I J) J))
                      (ISQRT-S0P S I J)
                      (NOT (EQUAL RN 0))
                      (NUMBERP RN)
                      (NOT (EQUAL RN 1))
                      (NOT (EQUAL RN 8))
                      (NOT (EQUAL RN 9))
                      (NOT (EQUAL RN 14))
                      (NOT (EQUAL RN 15)))
                 (EQUAL (READ-RN OPLEN RN
                                 (MC-RFILE (STEPN S (ISQRT1-T I J))))
                        (READ-RN OPLEN RN (MC-RFILE S)))).

  This simplifies, using linear arithmetic, rewriting with
  ISQRT-S0P-J_NONZEROP, QUOTIENT-TIMES-LESSP, and ISQRT1-S0-EXIT-RFILE-BASE,
  and expanding the definitions of ISQRT1-T and D2-7A2-5P, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT-S0-EXIT-RFILE


(PROVE-LEMMA ISQRT-S0-EXIT-MEM
             (REWRITE)
             (IMPLIES (AND (ISQRT-S0P S I J)
                           (DISJOINT X K
                                     (SUB 32 8 (READ-AN 32 6 S))
                                     20))
                      (EQUAL (READ-MEM X
                                       (MC-MEM (STEPN S (ISQRT1-T I J)))
                                       K)
                             (READ-MEM X (MC-MEM S) K)))
             ((INDUCT (ISQRT-INDUCT S I J))))

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

Case 3. (IMPLIES (AND (ZEROP J)
                      (ISQRT-S0P S I J)
                      (DISJOINT X K
                                (SUB 32 8
                                     (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                                20))
                 (EQUAL (READ-MEM X
                                  (MC-MEM (STEPN S (ISQRT1-T I J)))
                                  K)
                        (READ-MEM X (MC-MEM S) K))),

  which simplifies, applying ISQRT-S0P-J_NONZEROP, and unfolding the
  definition of ZEROP, to:

        T.

Case 2. (IMPLIES
         (AND
          (NOT (EQUAL J 0))
          (NUMBERP J)
          (LESSP (QUOTIENT I J) J)
          (IMPLIES
           (AND (ISQRT-S0P (STEPN S 10)
                           I
                           (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                (DISJOINT X K
                          (SUB 32 8
                               (READ-RN 32
                                        (PLUS 8 6)
                                        (MC-RFILE (STEPN S 10))))
                          20))
           (EQUAL
            (READ-MEM X
                     (MC-MEM (STEPN (STEPN S 10)
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))
                     K)
            (READ-MEM X (MC-MEM (STEPN S 10)) K)))
          (ISQRT-S0P S I J)
          (DISJOINT X K
                    (SUB 32 8
                         (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                    20))
         (EQUAL (READ-MEM X
                          (MC-MEM (STEPN S (ISQRT1-T I J)))
                          K)
                (READ-MEM X (MC-MEM S) K))).

  This simplifies, using linear arithmetic, rewriting with
  ISQRT-S0P-J_NONZEROP, QUOTIENT-TIMES-LESSP, ISQRT-S0-S0, SUB-NEG,
  STEPN-LEMMA, DISJOINT-10, and ISQRT-S0-S0-MEM, and opening up the functions
  PLUS, NEG, AND, IMPLIES, ISQRT1-T, INDEX-N, LESSP, and READ-AN, to:

        T.

Case 1. (IMPLIES (AND (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (LESSP (QUOTIENT I J) J))
                      (ISQRT-S0P S I J)
                      (DISJOINT X K
                                (SUB 32 8
                                     (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                                20))
                 (EQUAL (READ-MEM X
                                  (MC-MEM (STEPN S (ISQRT1-T I J)))
                                  K)
                        (READ-MEM X (MC-MEM S) K))),

  which simplifies, using linear arithmetic, applying ISQRT-S0P-J_NONZEROP,
  QUOTIENT-TIMES-LESSP, SUB-NEG, and ISQRT1-S0-EXIT-MEM-BASE, and unfolding
  the definitions of PLUS, NEG, and ISQRT1-T, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT-S0-EXIT-MEM


(DISABLE ISQRT-S0P-J_NONZEROP)

[ 0.0 0.0 0.0 ]

ISQRT-S0P-J_NONZEROP-OFF


(PROVE-LEMMA ISQRT-CORRECTNESS
           (REWRITE)
           (LET ((SN (STEPN S (ISQRT-T I))))
                (IMPLIES (ISQRT-STATEP S I)
                         (AND (EQUAL (MC-STATUS SN) 'RUNNING)
                              (EQUAL (MC-PC SN) (RTS-ADDR S))
                              (EQUAL (READ-RN 32 14 (MC-RFILE SN))
                                     (READ-AN 32 6 S))
                              (EQUAL (READ-RN 32 15 (MC-RFILE SN))
                                     (ADD 32 (READ-AN 32 7 S) 4))
                              (IMPLIES (D2-7A2-5P RN)
                                       (EQUAL (READ-RN OPLEN RN (MC-RFILE SN))
                                              (READ-RN OPLEN RN (MC-RFILE S))))
                              (IMPLIES (DISJOINT X K
                                                 (SUB 32 12 (READ-SP S))
                                                 20)
                                       (EQUAL (READ-MEM X (MC-MEM SN) K)
                                              (READ-MEM X (MC-MEM S) K)))
                              (EQUAL (IREAD-DN 32 0 SN)
                                     (ISQRT I)))))
           ((DISABLE RTS-ADDR LINKED-RTS-ADDR LINKED-A6 IREAD-DN
                     QUOTIENT-TIMES-LESSP)))

WARNING:  Note that the rewrite rule ISQRT-CORRECTNESS will be stored so as to
apply only to terms with the nonrecursive function symbol IREAD-DN.


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


This formula can be simplified, using the abbreviations IMPLIES, SP, L,
READ-SP, and READ-AN, to the new formula:

      (IMPLIES
             (ISQRT-STATEP S I)
             (AND (EQUAL (MC-STATUS (STEPN S (ISQRT-T I)))
                         'RUNNING)
                  (EQUAL (MC-PC (STEPN S (ISQRT-T I)))
                         (RTS-ADDR S))
                  (EQUAL (READ-RN 32 14
                                  (MC-RFILE (STEPN S (ISQRT-T I))))
                         (READ-RN 32 (PLUS 8 6) (MC-RFILE S)))
                  (EQUAL (READ-RN 32 15
                                  (MC-RFILE (STEPN S (ISQRT-T I))))
                         (ADD 32
                              (READ-RN 32 (PLUS 8 7) (MC-RFILE S))
                              4))
                  (IMPLIES (D2-7A2-5P RN)
                           (EQUAL (READ-RN OPLEN RN
                                           (MC-RFILE (STEPN S (ISQRT-T I))))
                                  (READ-RN OPLEN RN (MC-RFILE S))))
                  (IMPLIES (DISJOINT X K
                                     (SUB 32 12
                                          (READ-RN 32 (PLUS 8 7) (MC-RFILE S)))
                                     20)
                           (EQUAL (READ-MEM X
                                            (MC-MEM (STEPN S (ISQRT-T I)))
                                            K)
                                  (READ-MEM X (MC-MEM S) K)))
                  (EQUAL (IREAD-DN 32 0 (STEPN S (ISQRT-T I)))
                         (ISQRT I)))),

which simplifies, rewriting with SUB-NEG, and opening up SQ, ISQRT-T, PLUS,
D2-7A2-5P, IMPLIES, NEG, ISQRT, and AND, to the following 14 new formulas:

Case 14.(IMPLIES (AND (ISQRT-STATEP S I)
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (EQUAL (MC-STATUS (STEPN S 12))
                        'RUNNING)).

  This again simplifies, rewriting with ISQRT-S-EXIT, and opening up the
  definition of EQUAL, to:

        T.

Case 13.(IMPLIES
         (AND (ISQRT-STATEP S I)
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (EQUAL
          (MC-STATUS
           (STEPN S
                  (SPLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))
          'RUNNING)).

  This again simplifies, rewriting with the lemmas STEPN-LEMMA, ISQRT-S-S0,
  and ISQRT-S0-EXIT, and opening up EQUAL, to:

        T.

Case 12.(IMPLIES (AND (ISQRT-STATEP S I)
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (EQUAL (MC-PC (STEPN S 12))
                        (RTS-ADDR S))),

  which again simplifies, applying ISQRT-S-EXIT, to:

        T.

Case 11.(IMPLIES
         (AND (ISQRT-STATEP S I)
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (EQUAL
          (MC-PC
           (STEPN S
                  (SPLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))
          (RTS-ADDR S))).

  But this again simplifies, applying the lemmas STEPN-LEMMA, ISQRT-S-S0, and
  ISQRT-S0-EXIT, to:

        T.

Case 10.(IMPLIES (AND (ISQRT-STATEP S I)
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (EQUAL (READ-RN 32 14
                                 (MC-RFILE (STEPN S 12)))
                        (READ-RN 32 14 (MC-RFILE S)))),

  which again simplifies, applying ISQRT-S-EXIT, to:

        T.

Case 9. (IMPLIES
         (AND (ISQRT-STATEP S I)
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (EQUAL
          (READ-RN 32 14
           (MC-RFILE
            (STEPN S
                  (SPLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2))))))
          (READ-RN 32 14 (MC-RFILE S)))).

  But this again simplifies, applying STEPN-LEMMA, ISQRT-S-S0, and
  ISQRT-S0-EXIT, and opening up the definitions of PLUS and READ-AN, to:

        T.

Case 8. (IMPLIES (AND (ISQRT-STATEP S I)
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (EQUAL (READ-RN 32 15
                                 (MC-RFILE (STEPN S 12)))
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4))).

  This again simplifies, applying ISQRT-S-EXIT, and expanding READ-AN, PLUS,
  SP, L, and READ-SP, to:

        T.

Case 7. (IMPLIES
         (AND (ISQRT-STATEP S I)
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (EQUAL
          (READ-RN 32 15
           (MC-RFILE
            (STEPN S
                  (SPLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2))))))
          (ADD 32
               (READ-RN 32 15 (MC-RFILE S))
               4))).

  This again simplifies, applying STEPN-LEMMA, ISQRT-S-S0, SUB-NEG,
  ADD-ASSOCIATIVITY, and ISQRT-S0-EXIT, and unfolding the functions NEG,
  READ-SP, L, SP, PLUS, READ-AN, and ADD, to:

        T.

Case 6. (IMPLIES
         (AND (ISQRT-STATEP S I)
              (NOT (EQUAL RN 0))
              (NUMBERP RN)
              (NOT (EQUAL RN 1))
              (NOT (EQUAL RN 8))
              (NOT (EQUAL RN 9))
              (NOT (EQUAL RN 14))
              (NOT (EQUAL RN 15))
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (EQUAL
          (READ-RN OPLEN RN
           (MC-RFILE
            (STEPN S
                  (SPLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2))))))
          (READ-RN OPLEN RN (MC-RFILE S)))).

  But this again simplifies, rewriting with STEPN-LEMMA, ISQRT-S-S0,
  ISQRT-S-S0-RFILE, and ISQRT-S0-EXIT-RFILE, and expanding D2-7A2-5P, to:

        T.

Case 5. (IMPLIES (AND (ISQRT-STATEP S I)
                      (NOT (EQUAL RN 0))
                      (NUMBERP RN)
                      (NOT (EQUAL RN 1))
                      (NOT (EQUAL RN 8))
                      (NOT (EQUAL RN 9))
                      (NOT (EQUAL RN 14))
                      (NOT (EQUAL RN 15))
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (EQUAL (READ-RN OPLEN RN
                                 (MC-RFILE (STEPN S 12)))
                        (READ-RN OPLEN RN (MC-RFILE S)))).

  However this again simplifies, applying ISQRT-S-EXIT-RFILE, and opening up
  D2-7A2-5P, to:

        T.

Case 4. (IMPLIES
         (AND (ISQRT-STATEP S I)
              (DISJOINT X K
                        (ADD 32
                             (READ-RN 32 15 (MC-RFILE S))
                             4294967284)
                        20)
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (EQUAL
          (READ-MEM X
           (MC-MEM
            (STEPN S
                  (SPLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))
           K)
          (READ-MEM X (MC-MEM S) K))).

  However this again simplifies, using linear arithmetic, rewriting with
  STEPN-LEMMA, DISJOINT-10, ADD-ASSOCIATIVITY, SUB-NEG, ISQRT-S-S0,
  ISQRT-S-S0-MEM, and ISQRT-S0-EXIT-MEM, and expanding the functions INDEX-N,
  LESSP, ADD, READ-AN, PLUS, SP, L, READ-SP, and NEG, to:

        T.

Case 3. (IMPLIES (AND (ISQRT-STATEP S I)
                      (DISJOINT X K
                                (ADD 32
                                     (READ-RN 32 15 (MC-RFILE S))
                                     4294967284)
                                20)
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (EQUAL (READ-MEM X (MC-MEM (STEPN S 12)) K)
                        (READ-MEM X (MC-MEM S) K))).

  This again simplifies, using linear arithmetic, applying the lemmas
  DISJOINT-10, SUB-NEG, and ISQRT-S-EXIT-MEM, and expanding INDEX-N, LESSP,
  NEG, READ-SP, L, SP, PLUS, and READ-AN, to:

        T.

Case 2. (IMPLIES (AND (ISQRT-STATEP S I)
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (EQUAL (IREAD-DN 32 0 (STEPN S 12))
                        (QUOTIENT I 2))),

  which again simplifies, applying ISQRT-S-EXIT, to:

        T.

Case 1. (IMPLIES
         (AND (ISQRT-STATEP S I)
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (EQUAL
          (IREAD-DN 32 0
           (STEPN S
                  (SPLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))
          (ISQRT1 I
                  (QUOTIENT (PLUS (QUOTIENT I 2)
                                  (QUOTIENT I (QUOTIENT I 2)))
                            2)))).

  This again simplifies, applying STEPN-LEMMA, ISQRT-S-S0, and ISQRT-S0-EXIT,
  to:

        T.

Q.E.D.


[ 0.0 0.6 0.1 ]

ISQRT-CORRECTNESS


(DISABLE ISQRT-T)

[ 0.0 0.0 0.0 ]

ISQRT-T-OFF


(PROVE-LEMMA ISQRT1-LOWER-BOUND
             (REWRITE)
             (IMPLIES (NOT (ZEROP J))
                      (NOT (LESSP I (SQ (ISQRT1 I J))))))

WARNING:  Note that the linear lemma ISQRT1-LOWER-BOUND is being stored under
the term (SQ (ISQRT1 I J)), which is unusual because SQ is a nonrecursive
function symbol.


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


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

      (IMPLIES (AND (NOT (EQUAL J 0)) (NUMBERP J))
               (NOT (LESSP I (SQ (ISQRT1 I J))))),

which simplifies, unfolding the function SQ, to:

      (IMPLIES (AND (NOT (EQUAL J 0)) (NUMBERP J))
               (NOT (LESSP I
                           (TIMES (ISQRT1 I J) (ISQRT1 I J))))).

Call the above conjecture *1.


     Perhaps we can prove it by induction.  The recursive terms in the
conjecture suggest three inductions.  They merge into two likely candidate
inductions.  However, only one is unflawed.  We will induct according to the
following scheme:
      (AND (IMPLIES (ZEROP J) (p I J))
           (IMPLIES (AND (NOT (ZEROP J))
                         (LESSP (QUOTIENT I J) J)
                         (p I
                            (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
                    (p I J))
           (IMPLIES (AND (NOT (ZEROP J))
                         (NOT (LESSP (QUOTIENT I J) J)))
                    (p I J))).
The lemmas MEAN-LESSP, COUNT-NUMBERP, and QUOTIENT-TIMES-LESSP and the
definition of ZEROP inform us that the measure (COUNT J) decreases according
to the well-founded relation LESSP in each induction step of the scheme.  The
above induction scheme generates the following four new conjectures:

Case 4. (IMPLIES (AND (ZEROP J)
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (NOT (LESSP I
                             (TIMES (ISQRT1 I J) (ISQRT1 I J))))).

  This simplifies, opening up ZEROP, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP J))
                      (LESSP (QUOTIENT I J) J)
                      (EQUAL (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                             0)
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (NOT (LESSP I
                             (TIMES (ISQRT1 I J) (ISQRT1 I J))))).

  This simplifies, rewriting with QUOTIENT-TIMES-LESSP, PLUS-EQUAL-0,
  LESSP-OF-1, SUB1-OF-1, and QUOTIENT-EQUAL-0, and opening up the functions
  ZEROP, EQUAL, NUMBERP, SUB1, LESSP, and ISQRT1, to:

        (IMPLIES
               (AND (LESSP I (TIMES J J))
                    (EQUAL (PLUS J (QUOTIENT I J)) 1)
                    (NOT (EQUAL J 0))
                    (NUMBERP J))
               (NOT (LESSP I
                           (TIMES (ISQRT1 I
                                          (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                                  (ISQRT1 I
                                          (QUOTIENT (PLUS J (QUOTIENT I J))
                                                    2)))))).

  However this again simplifies, opening up the functions QUOTIENT, EQUAL, and
  ISQRT1, to two new formulas:

  Case 3.2.
          (IMPLIES (AND (LESSP I (TIMES J J))
                        (EQUAL (PLUS J (QUOTIENT I J)) 1)
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (NUMBERP I)))
                   (NOT (LESSP I (TIMES 0 0)))),

    which again simplifies, using linear arithmetic, appealing to the lemmas
    LESSP-OF-1 and TIMES-LESSP, and opening up TIMES, EQUAL, and LESSP, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LESSP I (TIMES J J))
                        (EQUAL (PLUS J (QUOTIENT I J)) 1)
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NUMBERP I))
                   (NOT (LESSP I (TIMES I I)))),

    which again simplifies, using linear arithmetic, applying TIMES-LESSP, and
    unfolding the function LESSP, to:

          (IMPLIES (AND (LESSP I (TIMES J J))
                        (EQUAL (PLUS J (QUOTIENT I J)) 1)
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NUMBERP I)
                        (NOT (EQUAL I 0)))
                   (EQUAL I 1)).

    Applying the lemma REMAINDER-QUOTIENT-ELIM, replace I by
    (PLUS Z (TIMES J X)) to eliminate (QUOTIENT I J) and (REMAINDER I J).  We
    employ REMAINDER-LESSP, the type restriction lemma noted when QUOTIENT was
    introduced, and the type restriction lemma noted when REMAINDER was
    introduced to restrict the new variables.  We thus obtain:

          (IMPLIES (AND (NUMBERP X)
                        (NUMBERP Z)
                        (EQUAL (LESSP Z J) (NOT (ZEROP J)))
                        (LESSP (PLUS Z (TIMES J X))
                               (TIMES J J))
                        (EQUAL (PLUS J X) 1)
                        (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (NOT (EQUAL (PLUS Z (TIMES J X)) 0)))
                   (EQUAL (PLUS Z (TIMES J X)) 1)),

    which further simplifies, applying TIMES-EQUAL-0 and PLUS-EQUAL-0, and
    unfolding ZEROP and NOT, to the following two new conjectures:

    Case 3.1.2.
            (IMPLIES (AND (NUMBERP X)
                          (NUMBERP Z)
                          (LESSP Z J)
                          (LESSP (PLUS Z (TIMES J X))
                                 (TIMES J J))
                          (EQUAL (PLUS J X) 1)
                          (NOT (EQUAL J 0))
                          (NUMBERP J)
                          (NOT (EQUAL Z 0)))
                     (EQUAL (PLUS Z (TIMES J X)) 1)).

      However this finally simplifies, using linear arithmetic, to:

            T.

    Case 3.1.1.
            (IMPLIES (AND (NUMBERP X)
                          (NUMBERP Z)
                          (LESSP Z J)
                          (LESSP (PLUS Z (TIMES J X))
                                 (TIMES J J))
                          (EQUAL (PLUS J X) 1)
                          (NOT (EQUAL J 0))
                          (NUMBERP J)
                          (NOT (EQUAL X 0)))
                     (EQUAL (PLUS Z (TIMES J X)) 1)),

      which finally simplifies, using linear arithmetic, to:

            T.

Case 2. (IMPLIES
          (AND (NOT (ZEROP J))
               (LESSP (QUOTIENT I J) J)
               (NOT (LESSP I
                           (TIMES (ISQRT1 I
                                          (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                                  (ISQRT1 I
                                          (QUOTIENT (PLUS J (QUOTIENT I J))
                                                    2)))))
               (NOT (EQUAL J 0))
               (NUMBERP J))
          (NOT (LESSP I
                      (TIMES (ISQRT1 I J) (ISQRT1 I J))))),

  which simplifies, applying QUOTIENT-TIMES-LESSP, and opening up the
  functions ZEROP and ISQRT1, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP J))
                      (NOT (LESSP (QUOTIENT I J) J))
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (NOT (LESSP I
                             (TIMES (ISQRT1 I J) (ISQRT1 I J))))).

  This simplifies, appealing to the lemma QUOTIENT-TIMES-LESSP, and opening up
  ZEROP and ISQRT1, to:

        T.


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


[ 0.0 0.1 0.1 ]

ISQRT1-LOWER-BOUND


(PROVE-LEMMA QUOTIENT-BY-2
             (REWRITE)
             (NOT (LESSP (PLUS (QUOTIENT X 2) (QUOTIENT X 2))
                         (SUB1 X))))

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


.

Appealing to the lemma REMAINDER-QUOTIENT-ELIM, we now replace X by
(PLUS V (TIMES 2 Z)) to eliminate (QUOTIENT X 2) and (REMAINDER X 2).  We
employ REMAINDER-LESSP, the type restriction lemma noted when QUOTIENT was
introduced, and the type restriction lemma noted when REMAINDER was introduced
to constrain the new variables.  The result is four new formulas:

Case 4. (IMPLIES (NOT (NUMBERP X))
                 (NOT (LESSP (PLUS (QUOTIENT X 2) (QUOTIENT X 2))
                             (SUB1 X)))),

  which simplifies, appealing to the lemmas QUOTIENT-EQUAL-0, SUB1-NNUMBERP,
  and QUOTIENT-TIMES-LESSP, and opening up the definitions of PLUS, EQUAL,
  NUMBERP, TIMES, and LESSP, to:

        T.

Case 3. (IMPLIES (EQUAL 2 0)
                 (NOT (LESSP (PLUS (QUOTIENT X 2) (QUOTIENT X 2))
                             (SUB1 X)))),

  which simplifies, using linear arithmetic, to:

        T.

Case 2. (IMPLIES (NOT (NUMBERP 2))
                 (NOT (LESSP (PLUS (QUOTIENT X 2) (QUOTIENT X 2))
                             (SUB1 X)))),

  which simplifies, clearly, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP Z)
                      (NUMBERP V)
                      (EQUAL (LESSP V 2) (NOT (ZEROP 2)))
                      (NOT (EQUAL 2 0)))
                 (NOT (LESSP (PLUS Z Z)
                             (SUB1 (PLUS V (TIMES 2 Z)))))).

  However this simplifies, applying LESSP-OF-1, SUB1-OF-1, PLUS-0, PLUS-ADD1,
  SUB1-ADD1, and MEAN-LESSP-LEMMA, and opening up SUB1, NUMBERP, EQUAL, LESSP,
  ZEROP, and NOT, to the following two new goals:

  Case 1.2.
          (IMPLIES (AND (NUMBERP Z)
                        (NUMBERP V)
                        (EQUAL V 0))
                   (NOT (LESSP (PLUS Z Z)
                               (SUB1 (TIMES 2 Z))))).

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

          (IMPLIES (AND (EQUAL (TIMES 2 Z) 0)
                        (NUMBERP Z)
                        (NUMBERP 0))
                   (NOT (LESSP (PLUS Z Z)
                               (SUB1 (TIMES 2 Z))))).

    This again simplifies, rewriting with TIMES-EQUAL-0, and opening up the
    definitions of EQUAL, NUMBERP, PLUS, SUB1, and LESSP, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NUMBERP Z)
                        (NUMBERP V)
                        (EQUAL V 1))
                   (NOT (LESSP Z Z))).

    This again simplifies, using linear arithmetic, to:

          T.

Q.E.D.


[ 0.0 0.0 0.0 ]

QUOTIENT-BY-2


(PROVE-LEMMA MAIN-TRICK
             (REWRITE)
             (NOT (LESSP (SQ (ADD1 (QUOTIENT (PLUS J K) 2)))
                         (PLUS (TIMES J K) J)))
             ((INDUCT (DIFFERENCE J K))))

WARNING:  Note that the linear lemma MAIN-TRICK is being stored under the term:
      (SQ (ADD1 (QUOTIENT (PLUS J K) 2))),
which is unusual because SQ is a nonrecursive function symbol.


WARNING:  Note that the proposed lemma MAIN-TRICK 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, OR, and
AND, to three new goals:

Case 3. (IMPLIES (ZEROP J)
                 (NOT (LESSP (SQ (ADD1 (QUOTIENT (PLUS J K) 2)))
                             (PLUS (TIMES J K) J)))),

  which simplifies, rewriting with PLUS-0, PLUS-COMMUTATIVITY1, SUB1-ADD1,
  TIMES-COMMUTATIVITY, TIMES-ADD1, and TIMES-ZERO, and unfolding the
  definitions of ZEROP, PLUS, SQ, OR, EQUAL, and LESSP, to:

        T.

Case 2. (IMPLIES (AND (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (ZEROP K))
                 (NOT (LESSP (SQ (ADD1 (QUOTIENT (PLUS J K) 2)))
                             (PLUS (TIMES J K) J)))).

  This simplifies, rewriting with PLUS-0, PLUS-COMMUTATIVITY,
  PLUS-COMMUTATIVITY1, SUB1-ADD1, TIMES-COMMUTATIVITY, TIMES-ADD1, and
  TIMES-ZERO, and expanding ZEROP, PLUS, SQ, and OR, to two new goals:

  Case 2.2.
          (IMPLIES (AND (NOT (EQUAL J 0))
                        (NUMBERP J)
                        (EQUAL K 0))
                   (NOT (LESSP (PLUS (QUOTIENT J 2)
                                     (ADD1 (PLUS (QUOTIENT J 2)
                                                 (TIMES (QUOTIENT J 2)
                                                        (QUOTIENT J 2)))))
                               J))),

    which again simplifies, using linear arithmetic and rewriting with
    QUOTIENT-BY-2, to:

          T.

  Case 2.1.
          (IMPLIES
               (AND (NOT (EQUAL J 0))
                    (NUMBERP J)
                    (NOT (NUMBERP K)))
               (NOT (LESSP (PLUS (QUOTIENT (PLUS J K) 2)
                                 (ADD1 (PLUS (QUOTIENT (PLUS J K) 2)
                                             (TIMES (QUOTIENT (PLUS J K) 2)
                                                    (QUOTIENT (PLUS J K) 2)))))
                           J))).

    However this again simplifies, using linear arithmetic and appealing to
    the lemma QUOTIENT-BY-2, to:

          T.

Case 1. (IMPLIES (AND (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (NOT (EQUAL K 0))
                      (NUMBERP K)
                      (NOT (LESSP (SQ (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                      2)))
                                  (PLUS (TIMES (SUB1 J) (SUB1 K))
                                        (SUB1 J)))))
                 (NOT (LESSP (SQ (ADD1 (QUOTIENT (PLUS J K) 2)))
                             (PLUS (TIMES J K) J)))),

  which simplifies, applying PLUS-COMMUTATIVITY1, SUB1-ADD1,
  TIMES-COMMUTATIVITY, TIMES-ADD1, PLUS-COMMUTATIVITY, REMAINDER-ADD1,
  QUOTIENT-ADD1, and PLUS-EQUAL-0, and unfolding the definitions of PLUS, SQ,
  EQUAL, NUMBERP, SUB1, and LESSP, to the following three new formulas:

  Case 1.3.
          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2)))))
                 (PLUS (SUB1 J)
                       (TIMES (SUB1 J) (SUB1 K)))))
            (EQUAL (ADD1 (REMAINDER (PLUS (SUB1 J) (SUB1 K))
                                    2))
                   1))
           (NOT
            (LESSP
             (SUB1
              (PLUS
                (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2))
                (ADD1 (PLUS (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2))
                            (TIMES (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2))
                                   (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                   2)))))))
             (PLUS (SUB1 J) (TIMES J K))))).

    However this again simplifies, rewriting with the lemmas ADD1-EQUAL,
    TIMES-ADD1, TIMES-COMMUTATIVITY, SUB1-ADD1, and PLUS-COMMUTATIVITY1, and
    expanding NUMBERP and PLUS, to the goal:

          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2)))))
                 (PLUS (SUB1 J)
                       (TIMES (SUB1 J) (SUB1 K)))))
            (EQUAL (REMAINDER (PLUS (SUB1 J) (SUB1 K)) 2)
                   0))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
              (ADD1
               (PLUS
                (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                (ADD1
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2)))))))))
             (PLUS (SUB1 J) (TIMES J K))))).

    Appealing to the lemma SUB1-ELIM, we now replace J by (ADD1 X) to
    eliminate (SUB1 J).  We employ the type restriction lemma noted when SUB1
    was introduced to constrain the new variable.  The result is:

          (IMPLIES
           (AND
            (NUMBERP X)
            (NOT (EQUAL (ADD1 X) 0))
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                          (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                      (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                             (QUOTIENT (PLUS X (SUB1 K)) 2)))))
                    (PLUS X (TIMES X (SUB1 K)))))
            (EQUAL (REMAINDER (PLUS X (SUB1 K)) 2)
                   0))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X (SUB1 K)) 2)
              (ADD1
               (PLUS
                (QUOTIENT (PLUS X (SUB1 K)) 2)
                (ADD1
                 (PLUS
                      (QUOTIENT (PLUS X (SUB1 K)) 2)
                      (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                  (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                         (QUOTIENT (PLUS X (SUB1 K)) 2)))))))))
             (PLUS X (TIMES (ADD1 X) K))))).

    However this further simplifies, rewriting with TIMES-ADD1,
    TIMES-COMMUTATIVITY, and PLUS-COMMUTATIVITY1, to:

          (IMPLIES
           (AND
            (NUMBERP X)
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                          (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                      (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                             (QUOTIENT (PLUS X (SUB1 K)) 2)))))
                    (PLUS X (TIMES X (SUB1 K)))))
            (EQUAL (REMAINDER (PLUS X (SUB1 K)) 2)
                   0))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X (SUB1 K)) 2)
              (ADD1
               (PLUS
                (QUOTIENT (PLUS X (SUB1 K)) 2)
                (ADD1
                 (PLUS
                      (QUOTIENT (PLUS X (SUB1 K)) 2)
                      (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                  (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                         (QUOTIENT (PLUS X (SUB1 K)) 2)))))))))
             (PLUS K X (TIMES K X))))).

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

          (IMPLIES
           (AND
               (NUMBERP Z)
               (NUMBERP X)
               (NOT (EQUAL (ADD1 Z) 0))
               (NOT (LESSP (PLUS (QUOTIENT (PLUS X Z) 2)
                                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                             (TIMES (QUOTIENT (PLUS X Z) 2)
                                                    (QUOTIENT (PLUS X Z) 2)))))
                           (PLUS X (TIMES X Z))))
               (EQUAL (REMAINDER (PLUS X Z) 2) 0))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X Z) 2)
              (ADD1
               (PLUS
                 (QUOTIENT (PLUS X Z) 2)
                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                             (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                         (TIMES (QUOTIENT (PLUS X Z) 2)
                                                (QUOTIENT (PLUS X Z) 2)))))))))
             (PLUS (ADD1 Z)
                   X
                   (TIMES (ADD1 Z) X))))),

    which further simplifies, rewriting with TIMES-ADD1, TIMES-COMMUTATIVITY,
    SUB1-ADD1, and PLUS-COMMUTATIVITY1, and unfolding PLUS, to the new formula:

          (IMPLIES
           (AND
               (NUMBERP Z)
               (NUMBERP X)
               (NOT (LESSP (PLUS (QUOTIENT (PLUS X Z) 2)
                                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                             (TIMES (QUOTIENT (PLUS X Z) 2)
                                                    (QUOTIENT (PLUS X Z) 2)))))
                           (PLUS X (TIMES X Z))))
               (EQUAL (REMAINDER (PLUS X Z) 2) 0))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X Z) 2)
              (ADD1
               (PLUS
                 (QUOTIENT (PLUS X Z) 2)
                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                             (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                         (TIMES (QUOTIENT (PLUS X Z) 2)
                                                (QUOTIENT (PLUS X Z) 2)))))))))
             (PLUS X X
                   (ADD1 (PLUS Z (TIMES X Z))))))),

    which finally simplifies, using linear arithmetic and applying the lemma
    QUOTIENT-BY-2, to:

          T.

  Case 1.2.
          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2)))))
                 (PLUS (SUB1 J)
                       (TIMES (SUB1 J) (SUB1 K)))))
            (EQUAL (REMAINDER (PLUS (SUB1 J) (SUB1 K)) 2)
                   1))
           (NOT
            (LESSP
             (SUB1
              (PLUS
                (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2))
                (ADD1 (PLUS (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2))
                            (TIMES (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2))
                                   (ADD1 (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                   2)))))))
             (PLUS (SUB1 J) (TIMES J K))))),

    which again simplifies, rewriting with TIMES-ADD1, TIMES-COMMUTATIVITY,
    SUB1-ADD1, and PLUS-COMMUTATIVITY1, and expanding the definition of PLUS,
    to:

          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2)))))
                 (PLUS (SUB1 J)
                       (TIMES (SUB1 J) (SUB1 K)))))
            (EQUAL (REMAINDER (PLUS (SUB1 J) (SUB1 K)) 2)
                   1))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
              (ADD1
               (PLUS
                (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                (ADD1
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2)))))))))
             (PLUS (SUB1 J) (TIMES J K))))).

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

          (IMPLIES
           (AND
            (NUMBERP X)
            (NOT (EQUAL (ADD1 X) 0))
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                          (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                      (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                             (QUOTIENT (PLUS X (SUB1 K)) 2)))))
                    (PLUS X (TIMES X (SUB1 K)))))
            (EQUAL (REMAINDER (PLUS X (SUB1 K)) 2)
                   1))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X (SUB1 K)) 2)
              (ADD1
               (PLUS
                (QUOTIENT (PLUS X (SUB1 K)) 2)
                (ADD1
                 (PLUS
                      (QUOTIENT (PLUS X (SUB1 K)) 2)
                      (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                  (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                         (QUOTIENT (PLUS X (SUB1 K)) 2)))))))))
             (PLUS X (TIMES (ADD1 X) K))))),

    which further simplifies, rewriting with the lemmas TIMES-ADD1,
    TIMES-COMMUTATIVITY, and PLUS-COMMUTATIVITY1, to:

          (IMPLIES
           (AND
            (NUMBERP X)
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                          (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                      (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                             (QUOTIENT (PLUS X (SUB1 K)) 2)))))
                    (PLUS X (TIMES X (SUB1 K)))))
            (EQUAL (REMAINDER (PLUS X (SUB1 K)) 2)
                   1))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X (SUB1 K)) 2)
              (ADD1
               (PLUS
                (QUOTIENT (PLUS X (SUB1 K)) 2)
                (ADD1
                 (PLUS
                      (QUOTIENT (PLUS X (SUB1 K)) 2)
                      (ADD1 (PLUS (QUOTIENT (PLUS X (SUB1 K)) 2)
                                  (TIMES (QUOTIENT (PLUS X (SUB1 K)) 2)
                                         (QUOTIENT (PLUS X (SUB1 K)) 2)))))))))
             (PLUS K X (TIMES K X))))).

    Appealing to the lemma SUB1-ELIM, we now replace K by (ADD1 Z) to
    eliminate (SUB1 K).  We rely upon the type restriction lemma noted when
    SUB1 was introduced to constrain the new variable.  The result is the
    formula:

          (IMPLIES
           (AND
               (NUMBERP Z)
               (NUMBERP X)
               (NOT (EQUAL (ADD1 Z) 0))
               (NOT (LESSP (PLUS (QUOTIENT (PLUS X Z) 2)
                                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                             (TIMES (QUOTIENT (PLUS X Z) 2)
                                                    (QUOTIENT (PLUS X Z) 2)))))
                           (PLUS X (TIMES X Z))))
               (EQUAL (REMAINDER (PLUS X Z) 2) 1))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X Z) 2)
              (ADD1
               (PLUS
                 (QUOTIENT (PLUS X Z) 2)
                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                             (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                         (TIMES (QUOTIENT (PLUS X Z) 2)
                                                (QUOTIENT (PLUS X Z) 2)))))))))
             (PLUS (ADD1 Z)
                   X
                   (TIMES (ADD1 Z) X))))).

    However this further simplifies, rewriting with TIMES-ADD1,
    TIMES-COMMUTATIVITY, SUB1-ADD1, and PLUS-COMMUTATIVITY1, and opening up
    PLUS, to:

          (IMPLIES
           (AND
               (NUMBERP Z)
               (NUMBERP X)
               (NOT (LESSP (PLUS (QUOTIENT (PLUS X Z) 2)
                                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                             (TIMES (QUOTIENT (PLUS X Z) 2)
                                                    (QUOTIENT (PLUS X Z) 2)))))
                           (PLUS X (TIMES X Z))))
               (EQUAL (REMAINDER (PLUS X Z) 2) 1))
           (NOT
            (LESSP
             (PLUS
              (QUOTIENT (PLUS X Z) 2)
              (ADD1
               (PLUS
                 (QUOTIENT (PLUS X Z) 2)
                 (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                             (ADD1 (PLUS (QUOTIENT (PLUS X Z) 2)
                                         (TIMES (QUOTIENT (PLUS X Z) 2)
                                                (QUOTIENT (PLUS X Z) 2)))))))))
             (PLUS X X
                   (ADD1 (PLUS Z (TIMES X Z))))))),

    which finally simplifies, using linear arithmetic and rewriting with
    QUOTIENT-BY-2, to:

          T.

  Case 1.1.
          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (NOT (EQUAL K 0))
            (NUMBERP K)
            (NOT
             (LESSP
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2)))))
                 (PLUS (SUB1 J)
                       (TIMES (SUB1 J) (SUB1 K)))))
            (NOT (EQUAL (REMAINDER (PLUS (SUB1 J) (SUB1 K)) 2)
                        1))
            (NOT (EQUAL (ADD1 (REMAINDER (PLUS (SUB1 J) (SUB1 K))
                                         2))
                        1)))
           (NOT
            (LESSP
             (SUB1
                 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                       (ADD1 (PLUS (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                   (TIMES (QUOTIENT (PLUS (SUB1 J) (SUB1 K)) 2)
                                          (QUOTIENT (PLUS (SUB1 J) (SUB1 K))
                                                    2))))))
             (PLUS (SUB1 J) (TIMES J K))))).

    But this again simplifies, using linear arithmetic and rewriting with
    REMAINDER-WRT-2, to:

          T.

Q.E.D.


[ 0.0 1.6 0.0 ]

MAIN-TRICK


(PROVE-LEMMA SQ-ADD1-NON-ZERO
             (REWRITE)
             (NOT (EQUAL (SQ (ADD1 X)) 0)))

This conjecture simplifies, appealing to the lemmas PLUS-COMMUTATIVITY1,
PLUS-COMMUTATIVITY, SUB1-ADD1, TIMES-COMMUTATIVITY, TIMES-ADD1, and
PLUS-EQUAL-0, and expanding the functions PLUS and SQ, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

SQ-ADD1-NON-ZERO


(PROVE-LEMMA MAIN
             (REWRITE)
             (IMPLIES (NOT (ZEROP J))
                      (LESSP I
                             (SQ (ADD1 (QUOTIENT (PLUS J (QUOTIENT I J))
                                                 2)))))
             ((DISABLE SQ)))

WARNING:  Note that the linear lemma MAIN is being stored under the term:
      (SQ (ADD1 (QUOTIENT (PLUS J (QUOTIENT I J))
                          2))),
which is unusual because SQ is a nonrecursive function symbol.


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


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

      (IMPLIES (AND (NOT (EQUAL J 0)) (NUMBERP J))
               (LESSP I
                      (SQ (ADD1 (QUOTIENT (PLUS J (QUOTIENT I J))
                                          2))))).

Applying the lemma REMAINDER-QUOTIENT-ELIM, replace I by (PLUS Z (TIMES J X))
to eliminate (QUOTIENT I J) and (REMAINDER I J).  We use REMAINDER-LESSP, the
type restriction lemma noted when QUOTIENT was introduced, and the type
restriction lemma noted when REMAINDER was introduced to restrict the new
variables.  This produces the following two new formulas:

Case 2. (IMPLIES (AND (NOT (NUMBERP I))
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (LESSP I
                        (SQ (ADD1 (QUOTIENT (PLUS J (QUOTIENT I J))
                                            2))))).

  This simplifies, rewriting with the lemma SQ-ADD1-NON-ZERO, and opening up
  LESSP, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP X)
                      (NUMBERP Z)
                      (EQUAL (LESSP Z J) (NOT (ZEROP J)))
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (LESSP (PLUS Z (TIMES J X))
                        (SQ (ADD1 (QUOTIENT (PLUS J X) 2))))),

  which simplifies, opening up ZEROP and NOT, to:

        (IMPLIES (AND (NUMBERP X)
                      (NUMBERP Z)
                      (LESSP Z J)
                      (NOT (EQUAL J 0))
                      (NUMBERP J))
                 (LESSP (PLUS Z (TIMES J X))
                        (SQ (ADD1 (QUOTIENT (PLUS J X) 2))))).

  However this again simplifies, using linear arithmetic and rewriting with
  MAIN-TRICK and PLUS-COMMUTATIVITY, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

MAIN


(PROVE-LEMMA ISQRT1-UPPER-BOUND
             (REWRITE)
             (IMPLIES (LESSP I (SQ (ADD1 J)))
                      (LESSP I (SQ (ADD1 (ISQRT1 I J)))))
             ((DISABLE SQ)))

WARNING:  Note that the linear lemma ISQRT1-UPPER-BOUND is being stored under
the term (SQ (ADD1 (ISQRT1 I J))), which is unusual because SQ is a
nonrecursive function symbol.


WARNING:  Note that the proposed lemma ISQRT1-UPPER-BOUND 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.


     Let us appeal to the induction principle.  The recursive terms in the
conjecture suggest three inductions.  They merge into two likely candidate
inductions.  However, only one is unflawed.  We will induct according to the
following scheme:
      (AND (IMPLIES (ZEROP J) (p I J))
           (IMPLIES (AND (NOT (ZEROP J))
                         (LESSP (QUOTIENT I J) J)
                         (p I
                            (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
                    (p I J))
           (IMPLIES (AND (NOT (ZEROP J))
                         (NOT (LESSP (QUOTIENT I J) J)))
                    (p I J))).
The lemmas MEAN-LESSP, COUNT-NUMBERP, and QUOTIENT-TIMES-LESSP and the
definition of ZEROP can be used to show that the measure (COUNT J) decreases
according to the well-founded relation LESSP in each induction step of the
scheme.  The above induction scheme generates the following four new
conjectures:

Case 4. (IMPLIES (AND (ZEROP J)
                      (LESSP I (SQ (ADD1 J))))
                 (LESSP I (SQ (ADD1 (ISQRT1 I J))))).

  This simplifies, appealing to the lemmas LESSP-OF-1 and
  SUB1-TYPE-RESTRICTION, and expanding the functions ZEROP, ADD1, SQ, ISQRT1,
  LESSP, EQUAL, and NUMBERP, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP J))
                      (LESSP (QUOTIENT I J) J)
                      (NOT (LESSP I
                                  (SQ (ADD1 (QUOTIENT (PLUS J (QUOTIENT I J))
                                                      2)))))
                      (LESSP I (SQ (ADD1 J))))
                 (LESSP I (SQ (ADD1 (ISQRT1 I J))))).

  This simplifies, applying QUOTIENT-TIMES-LESSP, and expanding the
  definitions of ZEROP and ISQRT1, to:

        (IMPLIES (AND (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (LESSP I (TIMES J J))
                      (NOT (LESSP I
                                  (SQ (ADD1 (QUOTIENT (PLUS J (QUOTIENT I J))
                                                      2)))))
                      (LESSP I (SQ (ADD1 J))))
                 (LESSP I
                        (SQ (ADD1 (ISQRT1 I
                                          (QUOTIENT (PLUS J (QUOTIENT I J))
                                                    2)))))).

  This again simplifies, using linear arithmetic and rewriting with MAIN, to:

        T.

Case 2. (IMPLIES
                (AND (NOT (ZEROP J))
                     (LESSP (QUOTIENT I J) J)
                     (LESSP I
                            (SQ (ADD1 (ISQRT1 I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))
                     (LESSP I (SQ (ADD1 J))))
                (LESSP I (SQ (ADD1 (ISQRT1 I J))))).

  This simplifies, appealing to the lemma QUOTIENT-TIMES-LESSP, and unfolding
  the functions ZEROP and ISQRT1, to:

        T.

Case 1. (IMPLIES (AND (NOT (ZEROP J))
                      (NOT (LESSP (QUOTIENT I J) J))
                      (LESSP I (SQ (ADD1 J))))
                 (LESSP I (SQ (ADD1 (ISQRT1 I J))))).

  This simplifies, applying the lemma QUOTIENT-TIMES-LESSP, and opening up
  ZEROP and ISQRT1, to:

        T.


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


[ 0.0 0.1 0.0 ]

ISQRT1-UPPER-BOUND


(PROVE-LEMMA ISQRT->ISQRT1
             (REWRITE)
             (IMPLIES (LESSP 1 I)
                      (LESSP I (SQ (ADD1 (QUOTIENT I 2))))))

WARNING:  Note that the linear lemma ISQRT->ISQRT1 is being stored under the
term (SQ (ADD1 (QUOTIENT I 2))), which is unusual because SQ is a nonrecursive
function symbol.


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


This formula simplifies, applying PLUS-COMMUTATIVITY1, SUB1-ADD1,
TIMES-COMMUTATIVITY, and TIMES-ADD1, and unfolding PLUS and SQ, to:

      (IMPLIES (LESSP 1 I)
               (LESSP I
                      (PLUS (QUOTIENT I 2)
                            (ADD1 (PLUS (QUOTIENT I 2)
                                        (TIMES (QUOTIENT I 2)
                                               (QUOTIENT I 2))))))),

which again simplifies, using linear arithmetic and applying QUOTIENT-BY-2, to
the following two new goals:

Case 2. (IMPLIES (AND (NOT (NUMBERP I)) (LESSP 1 I))
                 (LESSP I
                        (PLUS (QUOTIENT I 2)
                              (ADD1 (PLUS (QUOTIENT I 2)
                                          (TIMES (QUOTIENT I 2)
                                                 (QUOTIENT I 2))))))).

  But this again simplifies, opening up LESSP, to:

        T.

Case 1. (IMPLIES
         (AND (NUMBERP I)
              (EQUAL I
                     (PLUS 1 (TIMES 2 (QUOTIENT I 2))))
              (LESSP 1
                     (PLUS 1 (TIMES 2 (QUOTIENT I 2)))))
         (LESSP
           (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
           (PLUS (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                           2)
                 (ADD1 (PLUS (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                                       2)
                             (TIMES (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                                              2)
                                    (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                                              2))))))),

  which again simplifies, applying PLUS-ADD1, to:

        (IMPLIES (AND (EQUAL I
                             (ADD1 (TIMES 2 (QUOTIENT I 2))))
                      (LESSP 1 I))
                 (LESSP I
                        (PLUS (QUOTIENT I 2)
                              (ADD1 (PLUS (QUOTIENT I 2)
                                          (TIMES (QUOTIENT I 2)
                                                 (QUOTIENT I 2))))))).

  Applying the lemma REMAINDER-QUOTIENT-ELIM, replace I by
  (PLUS Z (TIMES 2 X)) to eliminate (QUOTIENT I 2) and (REMAINDER I 2).  We
  rely upon REMAINDER-LESSP, the type restriction lemma noted when QUOTIENT
  was introduced, and the type restriction lemma noted when REMAINDER was
  introduced to restrict the new variables.  This produces the following four
  new goals:

  Case 1.4.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (EQUAL I
                               (ADD1 (TIMES 2 (QUOTIENT I 2))))
                        (LESSP 1 I))
                   (LESSP I
                          (PLUS (QUOTIENT I 2)
                                (ADD1 (PLUS (QUOTIENT I 2)
                                            (TIMES (QUOTIENT I 2)
                                                   (QUOTIENT I 2))))))).

    This further simplifies, trivially, to:

          T.

  Case 1.3.
          (IMPLIES (AND (EQUAL 2 0)
                        (EQUAL I
                               (ADD1 (TIMES 2 (QUOTIENT I 2))))
                        (LESSP 1 I))
                   (LESSP I
                          (PLUS (QUOTIENT I 2)
                                (ADD1 (PLUS (QUOTIENT I 2)
                                            (TIMES (QUOTIENT I 2)
                                                   (QUOTIENT I 2))))))).

    However this further simplifies, using linear arithmetic, to:

          T.

  Case 1.2.
          (IMPLIES (AND (NOT (NUMBERP 2))
                        (EQUAL I
                               (ADD1 (TIMES 2 (QUOTIENT I 2))))
                        (LESSP 1 I))
                   (LESSP I
                          (PLUS (QUOTIENT I 2)
                                (ADD1 (PLUS (QUOTIENT I 2)
                                            (TIMES (QUOTIENT I 2)
                                                   (QUOTIENT I 2))))))),

    which further simplifies, obviously, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NUMBERP X)
                        (NUMBERP Z)
                        (EQUAL (LESSP Z 2) (NOT (ZEROP 2)))
                        (NOT (EQUAL 2 0))
                        (EQUAL (PLUS Z (TIMES 2 X))
                               (ADD1 (TIMES 2 X)))
                        (LESSP 1 (PLUS Z (TIMES 2 X))))
                   (LESSP (PLUS Z (TIMES 2 X))
                          (PLUS X
                                (ADD1 (PLUS X (TIMES X X)))))).

    This further simplifies, using linear arithmetic, applying LESSP-OF-1,
    SUB1-OF-1, PLUS-0, PLUS-ADD1, SUB1-ADD1, TIMES-LESSP, and PLUS-EQUAL-0,
    and unfolding the definitions of SUB1, NUMBERP, EQUAL, LESSP, ZEROP, and
    NOT, to:

          (IMPLIES (AND (NUMBERP X)
                        (NUMBERP Z)
                        (EQUAL Z 1)
                        (NOT (EQUAL X 0)))
                   (LESSP (TIMES 2 X)
                          (SUB1 (PLUS X
                                      (ADD1 (PLUS X (TIMES X X))))))),

    which again simplifies, expanding NUMBERP, to:

          (IMPLIES (AND (NUMBERP X) (NOT (EQUAL X 0)))
                   (LESSP (TIMES 2 X)
                          (SUB1 (PLUS X
                                      (ADD1 (PLUS X (TIMES X X))))))),

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


     So now let us consider:

(IMPLIES (LESSP 1 I)
         (LESSP I (SQ (ADD1 (QUOTIENT I 2))))),

which we named *1 above.  We will appeal to induction.  There are two
plausible inductions.  However, they merge into one likely candidate induction.
We will induct according to the following scheme:
      (AND (IMPLIES (OR (EQUAL I 0) (NOT (NUMBERP I)))
                    (p I))
           (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I))))
                         (OR (EQUAL 1 0) (NOT (NUMBERP 1))))
                    (p I))
           (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I))))
                         (NOT (OR (EQUAL 1 0) (NOT (NUMBERP 1))))
                         (p (SUB1 I)))
                    (p I))).
Linear arithmetic, the lemmas SUB1-LESSEQP and SUB1-LESSP, and the definitions
of OR and NOT establish that the measure (COUNT I) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates the following four new goals:

Case 4. (IMPLIES (AND (OR (EQUAL I 0) (NOT (NUMBERP I)))
                      (LESSP 1 I))
                 (LESSP I (SQ (ADD1 (QUOTIENT I 2))))).

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

        T.

Case 3. (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I))))
                      (OR (EQUAL 1 0) (NOT (NUMBERP 1)))
                      (LESSP 1 I))
                 (LESSP I (SQ (ADD1 (QUOTIENT I 2))))).

  This simplifies, expanding NOT, OR, EQUAL, and NUMBERP, to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I))))
                      (NOT (OR (EQUAL 1 0) (NOT (NUMBERP 1))))
                      (NOT (LESSP 1 (SUB1 I)))
                      (LESSP 1 I))
                 (LESSP I (SQ (ADD1 (QUOTIENT I 2))))).

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

  Case 2.2.
          (IMPLIES (AND (NOT (NUMBERP I))
                        (NOT (OR (EQUAL I 0) (NOT (NUMBERP I))))
                        (NOT (OR (EQUAL 1 0) (NOT (NUMBERP 1))))
                        (NOT (LESSP 1 (SUB1 I)))
                        (LESSP 1 I))
                   (LESSP I (SQ (ADD1 (QUOTIENT I 2))))).

    However this again simplifies, unfolding NOT and OR, to:

          T.

  Case 2.1.
          (IMPLIES (AND (NUMBERP I)
                        (NOT (OR (EQUAL 2 0) (NOT (NUMBERP 2))))
                        (NOT (OR (EQUAL 1 0) (NOT (NUMBERP 1))))
                        (NOT (LESSP 1 (SUB1 2)))
                        (LESSP 1 2))
                   (LESSP 2 (SQ (ADD1 (QUOTIENT 2 2))))),

    which again simplifies, opening up EQUAL, NUMBERP, NOT, OR, SUB1, LESSP,
    QUOTIENT, ADD1, and SQ, to:

          T.

Case 1. (IMPLIES (AND (NOT (OR (EQUAL I 0) (NOT (NUMBERP I))))
                      (NOT (OR (EQUAL 1 0) (NOT (NUMBERP 1))))
                      (LESSP (SUB1 I)
                             (SQ (ADD1 (QUOTIENT (SUB1 I) 2))))
                      (LESSP 1 I))
                 (LESSP I (SQ (ADD1 (QUOTIENT I 2))))),

  which simplifies, applying SUB1-OF-1, PLUS-COMMUTATIVITY1, SUB1-ADD1,
  TIMES-COMMUTATIVITY, and TIMES-ADD1, and unfolding the definitions of NOT,
  OR, EQUAL, NUMBERP, LESSP, SUB1, PLUS, and SQ, to:

        (IMPLIES (AND (NOT (EQUAL I 0))
                      (NUMBERP I)
                      (LESSP (SUB1 I)
                             (SQ (ADD1 (QUOTIENT (SUB1 I) 2))))
                      (NOT (EQUAL I 1)))
                 (LESSP I
                        (PLUS (QUOTIENT I 2)
                              (ADD1 (PLUS (QUOTIENT I 2)
                                          (TIMES (QUOTIENT I 2)
                                                 (QUOTIENT I 2))))))),

  which again simplifies, using linear arithmetic and appealing to the lemma
  QUOTIENT-BY-2, to:

        (IMPLIES
         (AND
            (EQUAL I
                   (PLUS 1 (TIMES 2 (QUOTIENT I 2))))
            (NOT (EQUAL (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                        0))
            (NUMBERP (PLUS 1 (TIMES 2 (QUOTIENT I 2))))
            (LESSP (SUB1 (PLUS 1 (TIMES 2 (QUOTIENT I 2))))
                   (SQ (ADD1 (QUOTIENT (SUB1 (PLUS 1 (TIMES 2 (QUOTIENT I 2))))
                                       2))))
            (NOT (EQUAL (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                        1)))
         (LESSP
           (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
           (PLUS (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                           2)
                 (ADD1 (PLUS (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                                       2)
                             (TIMES (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                                              2)
                                    (QUOTIENT (PLUS 1 (TIMES 2 (QUOTIENT I 2)))
                                              2))))))).

  This again simplifies, rewriting with the lemmas PLUS-ADD1, QUOTIENT-SUB1,
  PLUS-COMMUTATIVITY1, SUB1-ADD1, TIMES-COMMUTATIVITY, and TIMES-ADD1, and
  expanding the definitions of PLUS and SQ, to two new conjectures:

  Case 1.2.
          (IMPLIES (AND (EQUAL I
                               (ADD1 (TIMES 2 (QUOTIENT I 2))))
                        (NOT (EQUAL I 0))
                        (NOT (EQUAL (REMAINDER I 2) 0))
                        (LESSP (SUB1 I)
                               (PLUS (QUOTIENT I 2)
                                     (ADD1 (PLUS (QUOTIENT I 2)
                                                 (TIMES (QUOTIENT I 2)
                                                        (QUOTIENT I 2))))))
                        (NOT (EQUAL I 1)))
                   (LESSP I
                          (PLUS (QUOTIENT I 2)
                                (ADD1 (PLUS (QUOTIENT I 2)
                                            (TIMES (QUOTIENT I 2)
                                                   (QUOTIENT I 2))))))),

    which again simplifies, using linear arithmetic and appealing to the lemma
    REMAINDER-WRT-2, to:

          (IMPLIES
           (AND
            (EQUAL I
                   (PLUS 1
                         (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                         (TIMES 2 (QUOTIENT I 2))))
            (EQUAL (REMAINDER (PLUS 1
                                    (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                    (TIMES 2 (QUOTIENT I 2)))
                              2)
                   1)
            (EQUAL
             (PLUS 1
                   (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                   (TIMES 2 (QUOTIENT I 2)))
             (ADD1 (TIMES 2
                          (QUOTIENT (PLUS 1
                                          (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                          (TIMES 2 (QUOTIENT I 2)))
                                    2))))
            (NOT (EQUAL (PLUS 1
                              (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                              (TIMES 2 (QUOTIENT I 2)))
                        0))
            (NOT (EQUAL 1 0))
            (LESSP
             (SUB1 (PLUS 1
                         (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                         (TIMES 2 (QUOTIENT I 2))))
             (PLUS
              (QUOTIENT (PLUS 1
                              (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                              (TIMES 2 (QUOTIENT I 2)))
                        2)
              (ADD1
               (PLUS
                   (QUOTIENT (PLUS 1
                                   (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                   (TIMES 2 (QUOTIENT I 2)))
                             2)
                   (TIMES (QUOTIENT (PLUS 1
                                          (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                          (TIMES 2 (QUOTIENT I 2)))
                                    2)
                          (QUOTIENT (PLUS 1
                                          (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                          (TIMES 2 (QUOTIENT I 2)))
                                    2))))))
            (NOT (EQUAL (PLUS 1
                              (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                              (TIMES 2 (QUOTIENT I 2)))
                        1)))
           (LESSP
            (PLUS 1
                  (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                  (TIMES 2 (QUOTIENT I 2)))
            (PLUS
             (QUOTIENT (PLUS 1
                             (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                             (TIMES 2 (QUOTIENT I 2)))
                       2)
             (ADD1
              (PLUS
                   (QUOTIENT (PLUS 1
                                   (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                   (TIMES 2 (QUOTIENT I 2)))
                             2)
                   (TIMES (QUOTIENT (PLUS 1
                                          (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                          (TIMES 2 (QUOTIENT I 2)))
                                    2)
                          (QUOTIENT (PLUS 1
                                          (TIMES (QUOTIENT I 2) (QUOTIENT I 2))
                                          (TIMES 2 (QUOTIENT I 2)))
                                    2))))))).

    But this again simplifies, rewriting with PLUS-COMMUTATIVITY and PLUS-ADD1,
    and expanding the definition of EQUAL, to the new conjecture:

          (IMPLIES (AND (EQUAL I
                               (ADD1 (PLUS (TIMES 2 (QUOTIENT I 2))
                                           (TIMES (QUOTIENT I 2)
                                                  (QUOTIENT I 2)))))
                        (EQUAL (REMAINDER I 2) 1)
                        (EQUAL I
                               (ADD1 (TIMES 2 (QUOTIENT I 2))))
                        (NOT (EQUAL I 0))
                        (LESSP (SUB1 I)
                               (PLUS (QUOTIENT I 2)
                                     (ADD1 (PLUS (QUOTIENT I 2)
                                                 (TIMES (QUOTIENT I 2)
                                                        (QUOTIENT I 2))))))
                        (NOT (EQUAL I 1)))
                   (LESSP I
                          (PLUS (QUOTIENT I 2)
                                (ADD1 (PLUS (QUOTIENT I 2)
                                            (TIMES (QUOTIENT I 2)
                                                   (QUOTIENT I 2))))))).

    Applying the lemma REMAINDER-QUOTIENT-ELIM, replace I by
    (PLUS Z (TIMES 2 X)) to eliminate (QUOTIENT I 2) and (REMAINDER I 2).  We
    employ REMAINDER-LESSP, the type restriction lemma noted when QUOTIENT was
    introduced, and the type restriction lemma noted when REMAINDER was
    introduced to restrict the new variables.  We would thus like to prove the
    following four new conjectures:

    Case 1.2.4.
            (IMPLIES (AND (NOT (NUMBERP I))
                          (EQUAL I
                                 (ADD1 (PLUS (TIMES 2 (QUOTIENT I 2))
                                             (TIMES (QUOTIENT I 2)
                                                    (QUOTIENT I 2)))))
                          (EQUAL (REMAINDER I 2) 1)
                          (EQUAL I
                                 (ADD1 (TIMES 2 (QUOTIENT I 2))))
                          (NOT (EQUAL I 0))
                          (LESSP (SUB1 I)
                                 (PLUS (QUOTIENT I 2)
                                       (ADD1 (PLUS (QUOTIENT I 2)
                                                   (TIMES (QUOTIENT I 2)
                                                          (QUOTIENT I 2))))))
                          (NOT (EQUAL I 1)))
                     (LESSP I
                            (PLUS (QUOTIENT I 2)
                                  (ADD1 (PLUS (QUOTIENT I 2)
                                              (TIMES (QUOTIENT I 2)
                                                     (QUOTIENT I 2))))))).

      This finally simplifies, trivially, to:

            T.

    Case 1.2.3.
            (IMPLIES (AND (EQUAL 2 0)
                          (EQUAL I
                                 (ADD1 (PLUS (TIMES 2 (QUOTIENT I 2))
                                             (TIMES (QUOTIENT I 2)
                                                    (QUOTIENT I 2)))))
                          (EQUAL (REMAINDER I 2) 1)
                          (EQUAL I
                                 (ADD1 (TIMES 2 (QUOTIENT I 2))))
                          (NOT (EQUAL I 0))
                          (LESSP (SUB1 I)
                                 (PLUS (QUOTIENT I 2)
                                       (ADD1 (PLUS (QUOTIENT I 2)
                                                   (TIMES (QUOTIENT I 2)
                                                          (QUOTIENT I 2))))))
                          (NOT (EQUAL I 1)))
                     (LESSP I
                            (PLUS (QUOTIENT I 2)
                                  (ADD1 (PLUS (QUOTIENT I 2)
                                              (TIMES (QUOTIENT I 2)
                                                     (QUOTIENT I 2))))))).

      But this finally simplifies, using linear arithmetic, to:

            T.

    Case 1.2.2.
            (IMPLIES (AND (NOT (NUMBERP 2))
                          (EQUAL I
                                 (ADD1 (PLUS (TIMES 2 (QUOTIENT I 2))
                                             (TIMES (QUOTIENT I 2)
                                                    (QUOTIENT I 2)))))
                          (EQUAL (REMAINDER I 2) 1)
                          (EQUAL I
                                 (ADD1 (TIMES 2 (QUOTIENT I 2))))
                          (NOT (EQUAL I 0))
                          (LESSP (SUB1 I)
                                 (PLUS (QUOTIENT I 2)
                                       (ADD1 (PLUS (QUOTIENT I 2)
                                                   (TIMES (QUOTIENT I 2)
                                                          (QUOTIENT I 2))))))
                          (NOT (EQUAL I 1)))
                     (LESSP I
                            (PLUS (QUOTIENT I 2)
                                  (ADD1 (PLUS (QUOTIENT I 2)
                                              (TIMES (QUOTIENT I 2)
                                                     (QUOTIENT I 2))))))),

      which finally simplifies, obviously, to:

            T.

    Case 1.2.1.
            (IMPLIES (AND (NUMBERP X)
                          (NUMBERP Z)
                          (EQUAL (LESSP Z 2) (NOT (ZEROP 2)))
                          (NOT (EQUAL 2 0))
                          (EQUAL (PLUS Z (TIMES 2 X))
                                 (ADD1 (PLUS (TIMES 2 X) (TIMES X X))))
                          (EQUAL Z 1)
                          (EQUAL (PLUS Z (TIMES 2 X))
                                 (ADD1 (TIMES 2 X)))
                          (NOT (EQUAL (PLUS Z (TIMES 2 X)) 0))
                          (LESSP (SUB1 (PLUS Z (TIMES 2 X)))
                                 (PLUS X (ADD1 (PLUS X (TIMES X X)))))
                          (NOT (EQUAL (PLUS Z (TIMES 2 X)) 1)))
                     (LESSP (PLUS Z (TIMES 2 X))
                            (PLUS X
                                  (ADD1 (PLUS X (TIMES X X)))))).

      This finally simplifies, applying PLUS-ADD1,
      CORRECTNESS-OF-CANCEL-EQUAL-PLUS, TIMES-EQUAL-0, and ADD1-EQUAL, and
      opening up NUMBERP, LESSP, ZEROP, NOT, EQUAL, FIX, TIMES, PLUS, ADD1,
      and SUB1, to:

            T.

  Case 1.1.
          (IMPLIES
                (AND (EQUAL I
                            (ADD1 (TIMES 2 (QUOTIENT I 2))))
                     (NOT (EQUAL I 0))
                     (EQUAL (REMAINDER I 2) 0)
                     (LESSP (SUB1 I)
                            (PLUS (SUB1 (QUOTIENT I 2))
                                  (ADD1 (PLUS (SUB1 (QUOTIENT I 2))
                                              (TIMES (SUB1 (QUOTIENT I 2))
                                                     (SUB1 (QUOTIENT I 2)))))))
                     (NOT (EQUAL I 1)))
                (LESSP I
                       (PLUS (QUOTIENT I 2)
                             (ADD1 (PLUS (QUOTIENT I 2)
                                         (TIMES (QUOTIENT I 2)
                                                (QUOTIENT I 2))))))).

    Appealing to the lemmas REMAINDER-QUOTIENT-ELIM and SUB1-ELIM, we now
    replace I by (PLUS Z (TIMES 2 X)) to eliminate (QUOTIENT I 2) and
    (REMAINDER I 2) and X by (ADD1 V) to eliminate (SUB1 X).  We employ
    REMAINDER-LESSP, the type restriction lemma noted when QUOTIENT was
    introduced, the type restriction lemma noted when REMAINDER was introduced,
    and the type restriction lemma noted when SUB1 was introduced to constrain
    the new variables.  The result is five new goals:

    Case 1.1.5.
            (IMPLIES
                (AND (NOT (NUMBERP I))
                     (EQUAL I
                            (ADD1 (TIMES 2 (QUOTIENT I 2))))
                     (NOT (EQUAL I 0))
                     (EQUAL (REMAINDER I 2) 0)
                     (LESSP (SUB1 I)
                            (PLUS (SUB1 (QUOTIENT I 2))
                                  (ADD1 (PLUS (SUB1 (QUOTIENT I 2))
                                              (TIMES (SUB1 (QUOTIENT I 2))
                                                     (SUB1 (QUOTIENT I 2)))))))
                     (NOT (EQUAL I 1)))
                (LESSP I
                       (PLUS (QUOTIENT I 2)
                             (ADD1 (PLUS (QUOTIENT I 2)
                                         (TIMES (QUOTIENT I 2)
                                                (QUOTIENT I 2))))))),

      which further simplifies, obviously, to:

            T.

    Case 1.1.4.
            (IMPLIES
                (AND (EQUAL 2 0)
                     (EQUAL I
                            (ADD1 (TIMES 2 (QUOTIENT I 2))))
                     (NOT (EQUAL I 0))
                     (EQUAL (REMAINDER I 2) 0)
                     (LESSP (SUB1 I)
                            (PLUS (SUB1 (QUOTIENT I 2))
                                  (ADD1 (PLUS (SUB1 (QUOTIENT I 2))
                                              (TIMES (SUB1 (QUOTIENT I 2))
                                                     (SUB1 (QUOTIENT I 2)))))))
                     (NOT (EQUAL I 1)))
                (LESSP I
                       (PLUS (QUOTIENT I 2)
                             (ADD1 (PLUS (QUOTIENT I 2)
                                         (TIMES (QUOTIENT I 2)
                                                (QUOTIENT I 2))))))).

      This further simplifies, using linear arithmetic, to:

            T.

    Case 1.1.3.
            (IMPLIES
                (AND (NOT (NUMBERP 2))
                     (EQUAL I
                            (ADD1 (TIMES 2 (QUOTIENT I 2))))
                     (NOT (EQUAL I 0))
                     (EQUAL (REMAINDER I 2) 0)
                     (LESSP (SUB1 I)
                            (PLUS (SUB1 (QUOTIENT I 2))
                                  (ADD1 (PLUS (SUB1 (QUOTIENT I 2))
                                              (TIMES (SUB1 (QUOTIENT I 2))
                                                     (SUB1 (QUOTIENT I 2)))))))
                     (NOT (EQUAL I 1)))
                (LESSP I
                       (PLUS (QUOTIENT I 2)
                             (ADD1 (PLUS (QUOTIENT I 2)
                                         (TIMES (QUOTIENT I 2)
                                                (QUOTIENT I 2))))))),

      which further simplifies, trivially, to:

            T.

    Case 1.1.2.
            (IMPLIES
                    (AND (EQUAL X 0)
                         (NUMBERP X)
                         (NUMBERP Z)
                         (EQUAL (LESSP Z 2) (NOT (ZEROP 2)))
                         (NOT (EQUAL 2 0))
                         (EQUAL (PLUS Z (TIMES 2 X))
                                (ADD1 (TIMES 2 X)))
                         (NOT (EQUAL (PLUS Z (TIMES 2 X)) 0))
                         (EQUAL Z 0)
                         (LESSP (SUB1 (PLUS Z (TIMES 2 X)))
                                (PLUS (SUB1 X)
                                      (ADD1 (PLUS (SUB1 X)
                                                  (TIMES (SUB1 X) (SUB1 X))))))
                         (NOT (EQUAL (PLUS Z (TIMES 2 X)) 1)))
                    (LESSP (PLUS Z (TIMES 2 X))
                           (PLUS X
                                 (ADD1 (PLUS X (TIMES X X)))))).

      However this further simplifies, using linear arithmetic, to:

            T.

    Case 1.1.1.
            (IMPLIES (AND (NUMBERP V)
                          (NOT (EQUAL (ADD1 V) 0))
                          (NUMBERP Z)
                          (EQUAL (LESSP Z 2) (NOT (ZEROP 2)))
                          (NOT (EQUAL 2 0))
                          (EQUAL (PLUS Z (TIMES 2 (ADD1 V)))
                                 (ADD1 (TIMES 2 (ADD1 V))))
                          (NOT (EQUAL (PLUS Z (TIMES 2 (ADD1 V))) 0))
                          (EQUAL Z 0)
                          (LESSP (SUB1 (PLUS Z (TIMES 2 (ADD1 V))))
                                 (PLUS V (ADD1 (PLUS V (TIMES V V)))))
                          (NOT (EQUAL (PLUS Z (TIMES 2 (ADD1 V)))
                                      1)))
                     (LESSP (PLUS Z (TIMES 2 (ADD1 V)))
                            (PLUS (ADD1 V)
                                  (ADD1 (PLUS (ADD1 V)
                                              (TIMES (ADD1 V) (ADD1 V))))))),

      which further simplifies, using linear arithmetic, to:

            T.


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


[ 0.0 0.7 0.0 ]

ISQRT->ISQRT1


(PROVE-LEMMA ISQRT-LOGIC-CORRECTNESS NIL
             (IMPLIES (LESSP 1 I)
                      (AND (LESSP I (SQ (ADD1 (ISQRT I))))
                           (NOT (LESSP I (SQ (ISQRT I))))))
             ((DISABLE SQ ISQRT1)))

This simplifies, unfolding the definitions of ISQRT, NOT, and AND, to the
following three new formulas:

Case 3. (IMPLIES (AND (LESSP 1 I)
                      (NOT (LESSP I (SQ (QUOTIENT I 2)))))
                 (LESSP I (SQ (ADD1 (QUOTIENT I 2))))).

  This again simplifies, using linear arithmetic and rewriting with the lemma
  ISQRT->ISQRT1, to:

        T.

Case 2. (IMPLIES
          (AND (LESSP 1 I)
               (LESSP I (SQ (QUOTIENT I 2))))
          (LESSP I
                 (SQ (ADD1 (ISQRT1 I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))),

  which again simplifies, using linear arithmetic and rewriting with
  ISQRT1-UPPER-BOUND, MAIN, and QUOTIENT-BY-2, to:

        T.

Case 1. (IMPLIES
           (AND (LESSP 1 I)
                (LESSP I (SQ (QUOTIENT I 2))))
           (NOT (LESSP I
                       (SQ (ISQRT1 I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))).

  However this again simplifies, using linear arithmetic and applying
  ISQRT1-LOWER-BOUND, QUOTIENT-BY-2, and J-NONZEROP, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ISQRT-LOGIC-CORRECTNESS


(PROVE-LEMMA QUOTIENT-MONO-1
             (REWRITE)
             (IMPLIES (AND (LEQ Y Z)
                           (NOT (ZEROP Y))
                           (NOT (ZEROP Z)))
                      (NOT (LESSP (QUOTIENT X Y)
                                  (QUOTIENT X Z)))))

WARNING:  When the linear lemma QUOTIENT-MONO-1 is stored under (QUOTIENT X Z)
it contains the free variable Y which will be chosen by instantiating the
hypothesis (NOT (LESSP Z Y)).


WARNING:  When the linear lemma QUOTIENT-MONO-1 is stored under (QUOTIENT X Y)
it contains the free variable Z which will be chosen by instantiating the
hypothesis (NOT (LESSP Z Y)).


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


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

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

which simplifies, applying QUOTIENT-TIMES-LESSP, to:

      (IMPLIES (AND (NOT (LESSP Z Y))
                    (NOT (EQUAL Y 0))
                    (NUMBERP Y)
                    (NOT (EQUAL Z 0))
                    (NUMBERP Z))
               (NOT (LESSP X (TIMES Y (QUOTIENT X Z))))).

Applying the lemma REMAINDER-QUOTIENT-ELIM, replace X by (PLUS W (TIMES Z V))
to eliminate (QUOTIENT X Z) and (REMAINDER X Z).  We employ REMAINDER-LESSP,
the type restriction lemma noted when QUOTIENT was introduced, and the type
restriction lemma noted when REMAINDER was introduced to restrict the new
variables.  We would thus like to prove the following two new goals:

Case 2. (IMPLIES (AND (NOT (NUMBERP X))
                      (NOT (LESSP Z Y))
                      (NOT (EQUAL Y 0))
                      (NUMBERP Y)
                      (NOT (EQUAL Z 0))
                      (NUMBERP Z))
                 (NOT (LESSP X (TIMES Y (QUOTIENT X Z))))).

  This further simplifies, applying the lemmas QUOTIENT-EQUAL-0 and TIMES-ZERO,
  and opening up the definitions of OR, ZEROP, EQUAL, and LESSP, to:

        T.

Case 1. (IMPLIES (AND (NUMBERP V)
                      (NUMBERP W)
                      (EQUAL (LESSP W Z) (NOT (ZEROP Z)))
                      (NOT (LESSP Z Y))
                      (NOT (EQUAL Y 0))
                      (NUMBERP Y)
                      (NOT (EQUAL Z 0))
                      (NUMBERP Z))
                 (NOT (LESSP (PLUS W (TIMES Z V))
                             (TIMES Y V)))),

  which further simplifies, applying TIMES-COMMUTATIVITY, and unfolding ZEROP
  and NOT, to the new conjecture:

        (IMPLIES (AND (NUMBERP V)
                      (NUMBERP W)
                      (LESSP W Z)
                      (NOT (LESSP Z Y))
                      (NOT (EQUAL Y 0))
                      (NUMBERP Y)
                      (NOT (EQUAL Z 0))
                      (NUMBERP Z))
                 (NOT (LESSP (PLUS W (TIMES V Z))
                             (TIMES V Y)))),

  which again simplifies, using linear arithmetic and rewriting with
  TIMES-LESSP-LINEAR, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

QUOTIENT-MONO-1


(PROVE-LEMMA MEAN-LESSP-1
             (REWRITE)
             (IMPLIES (NOT (LESSP X Y))
                      (NOT (LESSP X (QUOTIENT (PLUS X Y) 2))))
             ((INDUCT (DIFFERENCE X Y))))

WARNING:  Note that the proposed lemma MEAN-LESSP-1 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, IMPLIES, NOT,
OR, and AND, to three new goals:

Case 3. (IMPLIES (AND (ZEROP X) (NOT (LESSP X Y)))
                 (NOT (LESSP X (QUOTIENT (PLUS X Y) 2)))),

  which simplifies, applying the lemmas PLUS-0 and PLUS-COMMUTATIVITY, and
  unfolding the functions ZEROP, EQUAL, LESSP, PLUS, and QUOTIENT, to:

        T.

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

  which simplifies, rewriting with PLUS-0 and PLUS-COMMUTATIVITY, and
  expanding the definitions of ZEROP, EQUAL, and LESSP, to the following two
  new conjectures:

  Case 2.2.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (EQUAL Y 0))
                   (NOT (LESSP X (QUOTIENT X 2)))).

    However this again simplifies, using linear arithmetic and applying
    QUOTIENT-LEQ, to:

          T.

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

    But this again simplifies, using linear arithmetic and applying
    QUOTIENT-LEQ, to:

          T.

Case 1. (IMPLIES (AND (NOT (EQUAL X 0))
                      (NUMBERP X)
                      (NOT (EQUAL Y 0))
                      (NUMBERP Y)
                      (IMPLIES (NOT (LESSP (SUB1 X) (SUB1 Y)))
                               (NOT (LESSP (SUB1 X)
                                           (QUOTIENT (PLUS (SUB1 X) (SUB1 Y))
                                                     2))))
                      (NOT (LESSP X Y)))
                 (NOT (LESSP X (QUOTIENT (PLUS X Y) 2)))).

  This simplifies, applying the lemmas PLUS-COMMUTATIVITY, REMAINDER-ADD1, and
  QUOTIENT-ADD1, and expanding NOT, IMPLIES, LESSP, PLUS, EQUAL, NUMBERP, and
  SUB1, to the following three new conjectures:

  Case 1.3.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (EQUAL Y 0))
                        (NUMBERP Y)
                        (NOT (LESSP (SUB1 X)
                                    (QUOTIENT (PLUS (SUB1 X) (SUB1 Y))
                                              2)))
                        (NOT (LESSP (SUB1 X) (SUB1 Y)))
                        (EQUAL (ADD1 (REMAINDER (PLUS (SUB1 X) (SUB1 Y))
                                                2))
                               1))
                   (NOT (LESSP X
                               (ADD1 (QUOTIENT (PLUS (SUB1 X) (SUB1 Y))
                                               2))))).

    This again simplifies, using linear arithmetic, to:

          T.

  Case 1.2.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (EQUAL Y 0))
                        (NUMBERP Y)
                        (NOT (LESSP (SUB1 X)
                                    (QUOTIENT (PLUS (SUB1 X) (SUB1 Y))
                                              2)))
                        (NOT (LESSP (SUB1 X) (SUB1 Y)))
                        (EQUAL (REMAINDER (PLUS (SUB1 X) (SUB1 Y)) 2)
                               1))
                   (NOT (LESSP X
                               (ADD1 (QUOTIENT (PLUS (SUB1 X) (SUB1 Y))
                                               2))))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES (AND (NOT (EQUAL X 0))
                        (NUMBERP X)
                        (NOT (EQUAL Y 0))
                        (NUMBERP Y)
                        (NOT (LESSP (SUB1 X)
                                    (QUOTIENT (PLUS (SUB1 X) (SUB1 Y))
                                              2)))
                        (NOT (LESSP (SUB1 X) (SUB1 Y)))
                        (NOT (EQUAL (REMAINDER (PLUS (SUB1 X) (SUB1 Y)) 2)
                                    1))
                        (NOT (EQUAL (ADD1 (REMAINDER (PLUS (SUB1 X) (SUB1 Y))
                                                     2))
                                    1)))
                   (NOT (LESSP X
                               (QUOTIENT (PLUS (SUB1 X) (SUB1 Y))
                                         2)))),

    which again simplifies, using linear arithmetic, to:

          T.

Q.E.D.


[ 0.0 0.1 0.0 ]

MEAN-LESSP-1


(PROVE-LEMMA ISQRT1-T-LA-0 NIL
             (LET ((J1 (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
                  (IMPLIES (AND (LEQ (QUOTIENT I J) J)
                                (LESSP 1 I)
                                (LESSP 0 J))
                           (NOT (LESSP (DIFFERENCE X (QUOTIENT I J))
                                       (DIFFERENCE X (QUOTIENT I J1))))))
             ((USE (QUOTIENT-MONO-1 (X I)
                                    (Y (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                                    (Z J)))
              (DISABLE QUOTIENT-TIMES-LESSP)))

This conjecture simplifies, applying the lemmas J-NONZEROP, QUOTIENT-0, and
QUOTIENT-EQUAL-0, and unfolding ZEROP, NOT, AND, IMPLIES, EQUAL, and LESSP, to
the following two new formulas:

Case 2. (IMPLIES
            (AND (LESSP J
                        (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                 (NOT (LESSP J (QUOTIENT I J)))
                 (LESSP 1 I)
                 (NOT (EQUAL J 0))
                 (NUMBERP J))
            (NOT (LESSP (DIFFERENCE X (QUOTIENT I J))
                        (DIFFERENCE X
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))).

  However this again simplifies, using linear arithmetic and rewriting with
  the lemma MEAN-LESSP-1, to:

        T.

Case 1. (IMPLIES
            (AND (NOT (LESSP (QUOTIENT I
                                       (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                             (QUOTIENT I J)))
                 (NOT (LESSP J (QUOTIENT I J)))
                 (LESSP 1 I)
                 (NOT (EQUAL J 0))
                 (NUMBERP J))
            (NOT (LESSP (DIFFERENCE X (QUOTIENT I J))
                        (DIFFERENCE X
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))),

  which again simplifies, using linear arithmetic, to:

        (IMPLIES
            (AND (LESSP X
                        (QUOTIENT I
                                  (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
                 (NOT (LESSP (QUOTIENT I
                                       (QUOTIENT (PLUS J (QUOTIENT I J)) 2))
                             (QUOTIENT I J)))
                 (NOT (LESSP J (QUOTIENT I J)))
                 (LESSP 1 I)
                 (NOT (EQUAL J 0))
                 (NUMBERP J))
            (NOT (LESSP (DIFFERENCE X (QUOTIENT I J))
                        (DIFFERENCE X
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))).

  This again simplifies, using linear arithmetic, applying the lemma
  DIFFERENCE-0, and unfolding the definitions of EQUAL and LESSP, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT1-T-LA-0


(PROVE-LEMMA MEAN-DIFFERENCE-1-1
             (REWRITE)
             (IMPLIES (LEQ I J)
                      (EQUAL (DIFFERENCE (QUOTIENT (PLUS J I) 2) I)
                             (QUOTIENT (DIFFERENCE J I) 2))))

This conjecture simplifies, rewriting with the lemmas PLUS-COMMUTATIVITY and
MEAN-DIFFERENCE-1, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

MEAN-DIFFERENCE-1-1


(PROVE-LEMMA ISQRT1-T-LA-1
             (REWRITE)
             (LET ((J1 (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
                  (IMPLIES (AND (LESSP (QUOTIENT I J) J)
                                (LESSP 1 I)
                                (LESSP 0 J))
                           (NOT (LESSP (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                                 2)
                                       (DIFFERENCE J1 (QUOTIENT I J1))))))
             ((USE (ISQRT1-T-LA-0 (X (QUOTIENT (PLUS J (QUOTIENT I J))
                                               2))))
              (DISABLE QUOTIENT-TIMES-LESSP)))

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


This conjecture simplifies, using linear arithmetic, rewriting with
QUOTIENT-LEQ, MEAN-DIFFERENCE-1-1, and QUOTIENT-0, and opening up the
functions EQUAL, LESSP, AND, NOT, and IMPLIES, to:

      (IMPLIES
       (AND
        (LESSP J (QUOTIENT I J))
        (IMPLIES
            (AND (IF (LESSP J (QUOTIENT I J)) F T)
                 (LESSP 1 I)
                 (LESSP 0 J))
            (NOT (LESSP (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I J))
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))))
        (LESSP (QUOTIENT I J) J)
        (LESSP 1 I)
        (NOT (EQUAL J 0))
        (NUMBERP J))
       (NOT (LESSP (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                             2)
                   (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                               (QUOTIENT I
                                         (QUOTIENT (PLUS J (QUOTIENT I J))
                                                   2)))))),

which again simplifies, using linear arithmetic, to:

      T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ISQRT1-T-LA-1


(PROVE-LEMMA ISQRT1-T-LA-2
         (REWRITE)
         (LET ((J1 (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
              (IMPLIES (AND (LESSP (QUOTIENT I J) J)
                            (LESSP 1 I)
                            (LESSP 0 J))
                       (NOT (LESSP (LOG 2
                                        (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                                  2))
                                   (LOG 2
                                        (DIFFERENCE J1 (QUOTIENT I J1)))))))
         ((USE (ISQRT1-T-LA-1))
          (DISABLE QUOTIENT-TIMES-LESSP LOG)))

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


This formula simplifies, applying QUOTIENT-0, and opening up EQUAL, LESSP, AND,
NOT, and IMPLIES, to:

      (IMPLIES
       (AND (NOT (LESSP (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                  2)
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))
            (LESSP (QUOTIENT I J) J)
            (LESSP 1 I)
            (NOT (EQUAL J 0))
            (NUMBERP J))
       (NOT (LESSP (LOG 2
                        (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                  2))
                   (LOG 2
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))))),

which again simplifies, using linear arithmetic and rewriting with LOG-LEQ, to:

      T.

Q.E.D.


[ 0.0 0.2 0.0 ]

ISQRT1-T-LA-2


(PROVE-LEMMA ISQRT-T1-UBOUND NIL
        (IMPLIES (AND (LESSP 1 I) (LESSP 0 J))
                 (NOT (LESSP (PLUS 18
                                   (TIMES 10
                                          (LOG 2
                                               (DIFFERENCE J (QUOTIENT I J)))))
                             (ISQRT1-T I J))))
        ((ENABLE SPLUS)
         (DISABLE QUOTIENT-TIMES-LESSP LOG)
         (EXPAND (LOG 2
                      (DIFFERENCE J (QUOTIENT I J))))))

This formula simplifies, applying LESSP-OF-1, SUB1-OF-1, DIFFERENCE-IS-1, and
DIFFERENCE=0, and expanding the functions EQUAL, LESSP, LOG, NUMBERP, and SUB1,
to three new goals:

Case 3. (IMPLIES
         (AND (LESSP 1 I)
              (NOT (EQUAL J 0))
              (NUMBERP J)
              (LESSP (QUOTIENT I J) J)
              (NOT (EQUAL J (ADD1 (QUOTIENT I J)))))
         (NOT
          (LESSP
                (PLUS 18
                      (TIMES 10
                             (ADD1 (LOG 2
                                        (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                                  2)))))
                (ISQRT1-T I J)))),

  which again simplifies, applying the lemmas TIMES-ADD1 and
  PLUS-COMMUTATIVITY1, to:

        (IMPLIES
          (AND (LESSP 1 I)
               (NOT (EQUAL J 0))
               (NUMBERP J)
               (LESSP (QUOTIENT I J) J)
               (NOT (EQUAL J (ADD1 (QUOTIENT I J)))))
          (NOT (LESSP (PLUS 10 18
                            (TIMES 10
                                   (LOG 2
                                        (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                                  2))))
                      (ISQRT1-T I J)))).

  Appealing to the lemma REMAINDER-QUOTIENT-ELIM, we now replace I by
  (PLUS Z (TIMES J X)) to eliminate (QUOTIENT I J) and (REMAINDER I J).  We
  use REMAINDER-LESSP, the type restriction lemma noted when QUOTIENT was
  introduced, and the type restriction lemma noted when REMAINDER was
  introduced to constrain the new variables.  We must thus prove two new
  conjectures:

  Case 3.2.
          (IMPLIES
           (AND (NOT (NUMBERP I))
                (LESSP 1 I)
                (NOT (EQUAL J 0))
                (NUMBERP J)
                (LESSP (QUOTIENT I J) J)
                (NOT (EQUAL J (ADD1 (QUOTIENT I J)))))
           (NOT
               (LESSP (PLUS 10 18
                            (TIMES 10
                                   (LOG 2
                                        (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                                  2))))
                      (ISQRT1-T I J)))),

    which further simplifies, unfolding LESSP, to:

          T.

  Case 3.1.
          (IMPLIES
                 (AND (NUMBERP X)
                      (NUMBERP Z)
                      (EQUAL (LESSP Z J) (NOT (ZEROP J)))
                      (LESSP 1 (PLUS Z (TIMES J X)))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (LESSP X J)
                      (NOT (EQUAL J (ADD1 X))))
                 (NOT (LESSP (PLUS 10 18
                                   (TIMES 10
                                          (LOG 2
                                               (QUOTIENT (DIFFERENCE J X) 2))))
                             (ISQRT1-T (PLUS Z (TIMES J X)) J)))),

    which further simplifies, opening up the definitions of ZEROP and NOT, to
    the formula:

          (IMPLIES
                 (AND (NUMBERP X)
                      (NUMBERP Z)
                      (LESSP Z J)
                      (LESSP 1 (PLUS Z (TIMES J X)))
                      (NOT (EQUAL J 0))
                      (NUMBERP J)
                      (LESSP X J)
                      (NOT (EQUAL J (ADD1 X))))
                 (NOT (LESSP (PLUS 10 18
                                   (TIMES 10
                                          (LOG 2
                                               (QUOTIENT (DIFFERENCE J X) 2))))
                             (ISQRT1-T (PLUS Z (TIMES J X)) 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:

(IMPLIES (AND (LESSP 1 I) (LESSP 0 J))
         (NOT (LESSP (PLUS 18
                           (TIMES 10
                                  (LOG 2
                                       (DIFFERENCE J (QUOTIENT I J)))))
                     (ISQRT1-T I J)))),

which we named *1 above.  We will appeal to induction.  There are four
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 (ZEROP J) (p J I))
           (IMPLIES (AND (NOT (ZEROP J))
                         (LESSP (QUOTIENT I J) J)
                         (p (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                            I))
                    (p J I))
           (IMPLIES (AND (NOT (ZEROP J))
                         (NOT (LESSP (QUOTIENT I J) J)))
                    (p J I))).
The lemmas MEAN-LESSP, COUNT-NUMBERP, and QUOTIENT-TIMES-LESSP and the
definition of ZEROP can be used to establish that the measure (COUNT J)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates four new goals:

Case 4. (IMPLIES (AND (ZEROP J)
                      (LESSP 1 I)
                      (LESSP 0 J))
                 (NOT (LESSP (PLUS 18
                                   (TIMES 10
                                          (LOG 2
                                               (DIFFERENCE J (QUOTIENT I J)))))
                             (ISQRT1-T I J)))),

  which simplifies, opening up ZEROP and LESSP, to:

        T.

Case 3. (IMPLIES (AND (NOT (ZEROP J))
                      (LESSP (QUOTIENT I J) J)
                      (NOT (LESSP 0
                                  (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
                      (LESSP 1 I)
                      (LESSP 0 J))
                 (NOT (LESSP (PLUS 18
                                   (TIMES 10
                                          (LOG 2
                                               (DIFFERENCE J (QUOTIENT I J)))))
                             (ISQRT1-T I J)))),

  which simplifies, using linear arithmetic, appealing to the lemmas
  QUOTIENT-LESSP-LINEAR and QUOTIENT-BY-2, and unfolding LESSP, to two new
  conjectures:

  Case 3.2.
          (IMPLIES
                 (AND (NOT (NUMBERP J))
                      (NOT (ZEROP J))
                      (LESSP (QUOTIENT I J) J)
                      (NOT (LESSP 0
                                  (QUOTIENT (PLUS J (QUOTIENT I J)) 2)))
                      (LESSP 1 I)
                      (LESSP 0 J))
                 (NOT (LESSP (PLUS 18
                                   (TIMES 10
                                          (LOG 2
                                               (DIFFERENCE J (QUOTIENT I J)))))
                             (ISQRT1-T I J)))),

    which again simplifies, unfolding ZEROP, to:

          T.

  Case 3.1.
          (IMPLIES
                 (AND (NUMBERP J)
                      (NOT (ZEROP 1))
                      (LESSP (QUOTIENT I 1) 1)
                      (NOT (LESSP 0
                                  (QUOTIENT (PLUS 1 (QUOTIENT I 1)) 2)))
                      (LESSP 1 I)
                      (LESSP 0 1))
                 (NOT (LESSP (PLUS 18
                                   (TIMES 10
                                          (LOG 2
                                               (DIFFERENCE 1 (QUOTIENT I 1)))))
                             (ISQRT1-T I 1)))),

    which again simplifies, applying QUOTIENT-1 and LESSP-OF-1, and opening up
    ZEROP, QUOTIENT, PLUS, and LESSP, to:

          T.

Case 2. (IMPLIES
         (AND
          (NOT (ZEROP J))
          (LESSP (QUOTIENT I J) J)
          (NOT
           (LESSP
            (PLUS 18
             (TIMES 10
                   (LOG 2
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))))
            (ISQRT1-T I
                      (QUOTIENT (PLUS J (QUOTIENT I J))
                                2))))
          (LESSP 1 I)
          (LESSP 0 J))
         (NOT (LESSP (PLUS 18
                           (TIMES 10
                                  (LOG 2
                                       (DIFFERENCE J (QUOTIENT I J)))))
                     (ISQRT1-T I J)))).

  This simplifies, applying LESSP-OF-1, SUB1-OF-1, DIFFERENCE-IS-1, and
  DIFFERENCE=0, and unfolding ZEROP, EQUAL, LESSP, LOG, NUMBERP, SUB1,
  ISQRT1-T, and SPLUS, to two new conjectures:

  Case 2.2.
          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (LESSP (QUOTIENT I J) J)
            (NOT
             (LESSP
              (PLUS 18
               (TIMES 10
                   (LOG 2
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))))
              (ISQRT1-T I
                        (QUOTIENT (PLUS J (QUOTIENT I J))
                                  2))))
            (LESSP 1 I)
            (NOT (EQUAL J (ADD1 (QUOTIENT I J)))))
           (NOT
            (LESSP
                (PLUS 18
                      (TIMES 10
                             (ADD1 (LOG 2
                                        (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                                  2)))))
                (PLUS 10
                      (ISQRT1-T I
                                (QUOTIENT (PLUS J (QUOTIENT I J))
                                          2)))))),

    which again simplifies, applying TIMES-ADD1, PLUS-COMMUTATIVITY1, and
    CORRECTNESS-OF-CANCEL-LESSP-PLUS, and expanding the function FIX, to:

          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (LESSP (QUOTIENT I J) J)
            (NOT
             (LESSP
              (PLUS 18
               (TIMES 10
                   (LOG 2
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))))
              (ISQRT1-T I
                        (QUOTIENT (PLUS J (QUOTIENT I J))
                                  2))))
            (LESSP 1 I)
            (NOT (EQUAL J (ADD1 (QUOTIENT I J)))))
           (NOT
               (LESSP (PLUS 18
                            (TIMES 10
                                   (LOG 2
                                        (QUOTIENT (DIFFERENCE J (QUOTIENT I J))
                                                  2))))
                      (ISQRT1-T I
                                (QUOTIENT (PLUS J (QUOTIENT I J))
                                          2))))),

    which again simplifies, using linear arithmetic and applying ISQRT1-T-LA-2,
    to:

          T.

  Case 2.1.
          (IMPLIES
           (AND
            (NOT (EQUAL J 0))
            (NUMBERP J)
            (LESSP (QUOTIENT I J) J)
            (NOT
             (LESSP
              (PLUS 18
               (TIMES 10
                   (LOG 2
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))))
              (ISQRT1-T I
                        (QUOTIENT (PLUS J (QUOTIENT I J))
                                  2))))
            (LESSP 1 I)
            (EQUAL J (ADD1 (QUOTIENT I J))))
           (NOT (LESSP (PLUS 18 (TIMES 10 0))
                       (PLUS 10
                             (ISQRT1-T I
                                       (QUOTIENT (PLUS J (QUOTIENT I J))
                                                 2)))))).

    But this again simplifies, using linear arithmetic, rewriting with
    MEAN-LESSP-1, QUOTIENT-BY-2, QUOTIENT-LEQ, QUOTIENT-LESSP-LINEAR,
    ISQRT1-T-LA-1, and DIFFERENCE-0, and unfolding the functions LESSP, LOG,
    TIMES, and PLUS, to the following two new formulas:

    Case 2.1.2.
            (IMPLIES
             (AND
              (NOT (EQUAL J 0))
              (LESSP (QUOTIENT I J) J)
              (LESSP J (QUOTIENT I J))
              (NOT
               (LESSP
                (PLUS 18
                 (TIMES 10
                   (LOG 2
                        (DIFFERENCE (QUOTIENT (PLUS J (QUOTIENT I J)) 2)
                                    (QUOTIENT I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2))))))
                (ISQRT1-T I
                          (QUOTIENT (PLUS J (QUOTIENT I J))
                                    2))))
              (LESSP 1 I)
              (EQUAL J (ADD1 (QUOTIENT I J))))
             (NOT (LESSP 18
                         (PLUS 10
                               (ISQRT1-T I
                                         (QUOTIENT (PLUS J (QUOTIENT I J))
                                                   2)))))).

      But this again simplifies, using linear arithmetic, to:

            T.

    Case 2.1.1.
            (IMPLIES
                  (AND (NOT (EQUAL J 0))
                       (LESSP (QUOTIENT I J) J)
                       (NOT (LESSP J (QUOTIENT I J)))
                       (NOT (LESSP 18
                                   (ISQRT1-T I
                                             (QUOTIENT (PLUS J (QUOTIENT I J))
                                                       2))))
                       (LESSP 1 I)
                       (EQUAL J (ADD1 (QUOTIENT I J))))
                  (NOT (LESSP 18
                              (PLUS 10
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))).

      Applying the lemma REMAINDER-QUOTIENT-ELIM, replace I by
      (PLUS Z (TIMES J X)) to eliminate (QUOTIENT I J) and (REMAINDER I J).
      We employ REMAINDER-LESSP, the type restriction lemma noted when
      QUOTIENT was introduced, and the type restriction lemma noted when
      REMAINDER was introduced to restrict the new variables.  We thus obtain
      the following three new formulas:

      Case 2.1.1.3.
              (IMPLIES
                  (AND (NOT (NUMBERP I))
                       (NOT (EQUAL J 0))
                       (LESSP (QUOTIENT I J) J)
                       (NOT (LESSP J (QUOTIENT I J)))
                       (NOT (LESSP 18
                                   (ISQRT1-T I
                                             (QUOTIENT (PLUS J (QUOTIENT I J))
                                                       2))))
                       (LESSP 1 I)
                       (EQUAL J (ADD1 (QUOTIENT I J))))
                  (NOT (LESSP 18
                              (PLUS 10
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))).

        But this further simplifies, appealing to the lemma QUOTIENT-EQUAL-0,
        and expanding LESSP, to:

              T.

      Case 2.1.1.2.
              (IMPLIES
                  (AND (NOT (NUMBERP J))
                       (NOT (EQUAL J 0))
                       (LESSP (QUOTIENT I J) J)
                       (NOT (LESSP J (QUOTIENT I J)))
                       (NOT (LESSP 18
                                   (ISQRT1-T I
                                             (QUOTIENT (PLUS J (QUOTIENT I J))
                                                       2))))
                       (LESSP 1 I)
                       (EQUAL J (ADD1 (QUOTIENT I J))))
                  (NOT (LESSP 18
                              (PLUS 10
                                    (ISQRT1-T I
                                              (QUOTIENT (PLUS J (QUOTIENT I J))
                                                        2)))))),

        which further simplifies, obviously, to:

              T.

      Case 2.1.1.1.
              (IMPLIES
                      (AND (NUMBERP X)
                           (NUMBERP Z)
                           (EQUAL (LESSP Z J) (NOT (ZEROP J)))
                           (NUMBERP J)
                           (NOT (EQUAL J 0))
                           (LESSP X J)
                           (NOT (LESSP J X))
                           (NOT (LESSP 18
                                       (ISQRT1-T (PLUS Z (TIMES J X))
                                                 (QUOTIENT (PLUS J X) 2))))
                           (LESSP 1 (PLUS Z (TIMES J X)))
                           (EQUAL J (ADD1 X)))
                      (NOT (LESSP 18
                                  (PLUS 10
                                        (ISQRT1-T (PLUS Z (TIMES J X))
                                                  (QUOTIENT (PLUS J X) 2)))))).

        But this further simplifies, applying the lemmas SUB1-ADD1, LESSP-SUB1,
        TIMES-ADD1, TIMES-COMMUTATIVITY, PLUS-0, PLUS-COMMUTATIVITY,
        QUOTIENT-2X-ADD1, QUOTIENT-PLUS-TIMES2, PLUS-ADD1, QUOTIENT-X-X,
        PLUS-COMMUTATIVITY1, CORRECTNESS-OF-CANCEL-LESSP-PLUS,
        QUOTIENT-PLUS-PLUS, QUOTIENT-TIMES, QUOTIENT-PLUS2, REMAINDER-X-X, and
        REMAINDER-TIMES, and opening up the definitions of LESSP, ZEROP, NOT,
        ADD1, TIMES, PLUS, QUOTIENT, ISQRT1-T, and EQUAL, to:

              T.

Case 1. (IMPLIES (AND (NOT (ZEROP J))
                      (NOT (LESSP (QUOTIENT I J) J))
                      (LESSP 1 I)
                      (LESSP 0 J))
                 (NOT (LESSP (PLUS 18
                                   (TIMES 10
                                          (LOG 2
                                               (DIFFERENCE J (QUOTIENT I J)))))
                             (ISQRT1-T I J)))),

  which simplifies, applying DIFFERENCE-0, and unfolding the definitions of
  ZEROP, EQUAL, LESSP, LOG, TIMES, PLUS, and ISQRT1-T, to:

        T.


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


[ 0.0 1.2 0.1 ]

ISQRT-T1-UBOUND


(PROVE-LEMMA ISQRT-T->ISQRT1-T NIL
             (IMPLIES (LESSP 1 I)
                      (NOT (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                                  (ISQRT-T I))))
             ((ENABLE SPLUS ISQRT-T)))

This formula simplifies, unfolding the functions SPLUS, SQ, and ISQRT-T, to
two new goals:

Case 2. (IMPLIES (AND (LESSP 1 I)
                      (NOT (LESSP I
                                  (TIMES (QUOTIENT I 2)
                                         (QUOTIENT I 2)))))
                 (NOT (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                             12))),

  which again simplifies, applying the lemmas QUOTIENT-TIMES-LESSP,
  QUOTIENT-EQUAL-0, SUB1-OF-1, and LESSP-OF-1, and opening up LESSP, SUB1,
  NUMBERP, EQUAL, and ISQRT1-T, to four new goals:

  Case 2.4.
          (IMPLIES (AND (LESSP 1 I)
                        (NOT (LESSP I
                                    (TIMES (QUOTIENT I 2)
                                           (QUOTIENT I 2))))
                        (EQUAL I 0))
                   (NOT (LESSP (PLUS 4 0) 12))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.3.
          (IMPLIES (AND (LESSP 1 I)
                        (NOT (LESSP I
                                    (TIMES (QUOTIENT I 2)
                                           (QUOTIENT I 2))))
                        (NOT (NUMBERP I)))
                   (NOT (LESSP (PLUS 4 0) 12))),

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

          T.

  Case 2.2.
          (IMPLIES (AND (LESSP 1 I)
                        (NOT (LESSP I
                                    (TIMES (QUOTIENT I 2)
                                           (QUOTIENT I 2))))
                        (EQUAL I 1))
                   (NOT (LESSP (PLUS 4 0) 12))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LESSP 1 I)
                        (NOT (LESSP I
                                    (TIMES (QUOTIENT I 2)
                                           (QUOTIENT I 2))))
                        (NOT (EQUAL I 0))
                        (NUMBERP I)
                        (NOT (EQUAL I 1)))
                   (NOT (LESSP (PLUS 4 8) 12))),

    which again simplifies, using linear arithmetic, to:

          T.

Case 1. (IMPLIES
         (AND (LESSP 1 I)
              (LESSP I
                     (TIMES (QUOTIENT I 2)
                            (QUOTIENT I 2))))
         (NOT
            (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                   (PLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))),

  which again simplifies, applying the lemmas QUOTIENT-TIMES-LESSP,
  QUOTIENT-EQUAL-0, SUB1-OF-1, and LESSP-OF-1, and unfolding the functions
  SPLUS, LESSP, SUB1, NUMBERP, EQUAL, and ISQRT1-T, to four new formulas:

  Case 1.4.
          (IMPLIES
           (AND (LESSP 1 I)
                (LESSP I
                       (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                (EQUAL I 0))
           (NOT
            (LESSP (PLUS 4 0)
                   (PLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.3.
          (IMPLIES
           (AND (LESSP 1 I)
                (LESSP I
                       (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                (NOT (NUMBERP I)))
           (NOT
            (LESSP (PLUS 4 0)
                   (PLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))),

    which again simplifies, expanding the function LESSP, to:

          T.

  Case 1.2.
          (IMPLIES
           (AND (LESSP 1 I)
                (LESSP I
                       (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                (EQUAL I 1))
           (NOT
            (LESSP (PLUS 4 0)
                   (PLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))),

    which again simplifies, using linear arithmetic, to:

          T.

  Case 1.1.
          (IMPLIES
           (AND (LESSP 1 I)
                (LESSP I
                       (TIMES (QUOTIENT I 2) (QUOTIENT I 2)))
                (NOT (EQUAL I 0))
                (NUMBERP I)
                (NOT (EQUAL I 1)))
           (NOT
            (LESSP (PLUS 4 10
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))
                   (PLUS 14
                         (ISQRT1-T I
                                   (QUOTIENT (PLUS (QUOTIENT I 2)
                                                   (QUOTIENT I (QUOTIENT I 2)))
                                             2)))))),

    which again simplifies, using linear arithmetic, to:

          T.

Q.E.D.


[ 0.0 0.2 0.0 ]

ISQRT-T->ISQRT1-T


(PROVE-LEMMA LOG-MONO
             (REWRITE)
             (NOT (LESSP (LOG B Y)
                         (LOG B (DIFFERENCE Y X))))
             ((USE (LOG-LEQ (X (DIFFERENCE Y X))))))

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


This simplifies, using linear arithmetic, to:

      (IMPLIES (AND (LESSP Y X)
                    (LESSP Y (DIFFERENCE Y X)))
               (NOT (LESSP (LOG B Y)
                           (LOG B (DIFFERENCE Y X))))),

which again simplifies, using linear arithmetic, applying the lemma
DIFFERENCE-0, and unfolding the definitions of EQUAL and LESSP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

LOG-MONO


(PROVE-LEMMA ISQRT-T-UBOUND-LA
             (REWRITE)
             (IMPLIES (LESSP 1 I)
                      (NOT (LESSP (PLUS 12 (TIMES 10 (LOG 2 I)))
                                  (ISQRT-T I))))
             ((USE (ISQRT-T->ISQRT1-T)
                   (ISQRT-T1-UBOUND (J (QUOTIENT I 2))))))

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


This simplifies, rewriting with QUOTIENT-EQUAL-0, LESSP-OF-1, and SUB1-OF-1,
and expanding the functions NOT, IMPLIES, NUMBERP, EQUAL, LESSP, SUB1, AND,
and LOG, to the following four new goals:

Case 4. (IMPLIES
         (AND
          (NOT (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                      (ISQRT-T I)))
          (NOT
           (LESSP (PLUS 18
                        (TIMES 10
                               (LOG 2
                                    (DIFFERENCE (QUOTIENT I 2)
                                                (QUOTIENT I (QUOTIENT I 2))))))
                  (ISQRT1-T I (QUOTIENT I 2))))
          (LESSP 1 I)
          (EQUAL I 0))
         (NOT (LESSP (PLUS 12 (TIMES 10 0))
                     (ISQRT-T I)))).

  However this again simplifies, using linear arithmetic, to:

        T.

Case 3. (IMPLIES
         (AND
          (NOT (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                      (ISQRT-T I)))
          (NOT
           (LESSP (PLUS 18
                        (TIMES 10
                               (LOG 2
                                    (DIFFERENCE (QUOTIENT I 2)
                                                (QUOTIENT I (QUOTIENT I 2))))))
                  (ISQRT1-T I (QUOTIENT I 2))))
          (LESSP 1 I)
          (NOT (NUMBERP I)))
         (NOT (LESSP (PLUS 12 (TIMES 10 0))
                     (ISQRT-T I)))),

  which again simplifies, using linear arithmetic, applying QUOTIENT-EQUAL-0,
  QUOTIENT-LEQ, and DIFFERENCE-0, and unfolding ISQRT1-T, PLUS, LOG, TIMES,
  and LESSP, to:

        T.

Case 2. (IMPLIES
         (AND
          (NOT (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                      (ISQRT-T I)))
          (NOT
           (LESSP (PLUS 18
                        (TIMES 10
                               (LOG 2
                                    (DIFFERENCE (QUOTIENT I 2)
                                                (QUOTIENT I (QUOTIENT I 2))))))
                  (ISQRT1-T I (QUOTIENT I 2))))
          (LESSP 1 I)
          (EQUAL I 1))
         (NOT (LESSP (PLUS 12 (TIMES 10 0))
                     (ISQRT-T I)))).

  This again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES
         (AND
          (NOT (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                      (ISQRT-T I)))
          (NOT
           (LESSP (PLUS 18
                        (TIMES 10
                               (LOG 2
                                    (DIFFERENCE (QUOTIENT I 2)
                                                (QUOTIENT I (QUOTIENT I 2))))))
                  (ISQRT1-T I (QUOTIENT I 2))))
          (LESSP 1 I)
          (NOT (EQUAL I 0))
          (NUMBERP I)
          (NOT (EQUAL I 1)))
         (NOT (LESSP (PLUS 12
                           (TIMES 10
                                  (ADD1 (LOG 2 (QUOTIENT I 2)))))
                     (ISQRT-T I)))),

  which again simplifies, rewriting with TIMES-ADD1 and PLUS-COMMUTATIVITY1,
  to:

        (IMPLIES
         (AND
          (NOT (LESSP (PLUS 4 (ISQRT1-T I (QUOTIENT I 2)))
                      (ISQRT-T I)))
          (NOT
           (LESSP (PLUS 18
                        (TIMES 10
                               (LOG 2
                                    (DIFFERENCE (QUOTIENT I 2)
                                                (QUOTIENT I (QUOTIENT I 2))))))
                  (ISQRT1-T I (QUOTIENT I 2))))
          (LESSP 1 I)
          (NOT (EQUAL I 0))
          (NUMBERP I)
          (NOT (EQUAL I 1)))
         (NOT (LESSP (PLUS 10 12
                           (TIMES 10 (LOG 2 (QUOTIENT I 2))))
                     (ISQRT-T I)))),

  which again simplifies, using linear arithmetic and rewriting with LOG-MONO,
  to:

        T.

Q.E.D.


[ 0.0 0.2 0.0 ]

ISQRT-T-UBOUND-LA


(PROVE-LEMMA ISQRT-T-UBOUND NIL
             (IMPLIES (AND (LESSP I (EXP 2 31)) (LESSP 1 I))
                      (LEQ (ISQRT-T I) 322))
             ((USE (TA-LEMMA-1 (A I)
                               (A1 (EXP 2 31))
                               (X 12)
                               (Y 10)))))

This formula can be simplified, using the abbreviations AND, IMPLIES, and
PLUS-LESSP-CANCEL-1, to:

      (IMPLIES (AND (IMPLIES (IF (LESSP (EXP 2 31) I) F T)
                             (IF (LESSP (TIMES 10 (LOG 2 (EXP 2 31)))
                                        (TIMES 10 (LOG 2 I)))
                                 F T))
                    (LESSP I (EXP 2 31))
                    (LESSP 1 I))
               (NOT (LESSP 322 (ISQRT-T I)))),

which simplifies, expanding the functions EXP, LOG, TIMES, and IMPLIES, to two
new formulas:

Case 2. (IMPLIES (AND (LESSP 2147483648 I)
                      (LESSP I 2147483648)
                      (LESSP 1 I))
                 (NOT (LESSP 322 (ISQRT-T I)))),

  which again simplifies, using linear arithmetic, to:

        T.

Case 1. (IMPLIES (AND (NOT (LESSP 310 (TIMES 10 (LOG 2 I))))
                      (LESSP I 2147483648)
                      (LESSP 1 I))
                 (NOT (LESSP 322 (ISQRT-T I)))),

  which again simplifies, using linear arithmetic and applying
  ISQRT-T-UBOUND-LA, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

ISQRT-T-UBOUND