(UNSET-WATERFALL-PARALLELISM)
(ASSIGN SCRIPT-MODE T)
 T
(SET-LD-PROMPT T STATE)
 T
ACL2 !>>(SET-INHIBITED-SUMMARY-TYPES '(TIME STEPS))
 (TIME STEPS)
ACL2 !>>(SET-INHIBIT-OUTPUT-LST '(PROOF-TREE))
 (PROOF-TREE)
ACL2 !>>(IN-PACKAGE "ACL2")
 "ACL2"
ACL2 !>>(SET-INHIBIT-OUTPUT-LST '(PROVE PROOF-TREE))
 (PROVE PROOF-TREE)
ACL2 !>>(SET-GAG-MODE NIL)
<state>
ACL2 !>>(SAVING-EVENT-DATA (LD "test1.lisp"))
ACL2 !>>>(IN-PACKAGE "ACL2")
 "ACL2"
ACL2 !>>>(DEFUN BAR (X)
           (DECLARE (XARGS :GUARD T))
           X)

Since BAR is non-recursive, its admission is trivial.  We observe that
the type of BAR is described by the theorem (EQUAL (BAR X) X).  

Computing the guard conjecture for BAR....

The guard conjecture for BAR is trivial to prove.  BAR is compliant
with Common Lisp.

Summary
Form:  ( DEFUN BAR ...)
Rules: NIL
 BAR
ACL2 !>>>(IN-THEORY (DISABLE REVERSE))

Summary
Form:  ( IN-THEORY (DISABLE ...))
Rules: NIL
 :CURRENT-THEORY-UPDATED
ACL2 !>>>(DEFUN FOO (X)
           (DECLARE (XARGS :GUARD (ALISTP X)
                           :VERIFY-GUARDS NIL))
           (APPEND (REVERSE X) X))

Since FOO is non-recursive, its admission is trivial.  We observe that
the type of FOO is described by the theorem 
(OR (CONSP (FOO X)) (EQUAL (FOO X) X)).  We used the :type-prescription
rule BINARY-APPEND.

Summary
Form:  ( DEFUN FOO ...)
Rules: ((:TYPE-PRESCRIPTION BINARY-APPEND))
 FOO
ACL2 !>>>(VERIFY-GUARDS FOO)

Computing the guard conjecture for FOO....

The non-trivial part of the guard conjecture for FOO, given the :forward-
chaining rule ALISTP-FORWARD-TO-TRUE-LISTP and the :type-prescription
rule ALISTP, is

Goal
(IMPLIES (ALISTP X)
         (TRUE-LISTP (REVERSE X))).


ACL2 Error in ( VERIFY-GUARDS FOO):  The proof of the guard conjecture
for FOO has failed.  You may wish to avoid specifying a guard, or to
supply option :VERIFY-GUARDS NIL with the :GUARD.  Otherwise, you may
wish to specify :GUARD-DEBUG T; see :DOC verify-guards.



Summary
Form:  ( VERIFY-GUARDS FOO)
Rules: ((:DEFINITION ALISTP)
        (:DEFINITION ATOM)
        (:DEFINITION NOT)
        (:DEFINITION TRUE-LISTP)
        (:ELIM CAR-CDR-ELIM)
        (:EXECUTABLE-COUNTERPART CONSP)
        (:EXECUTABLE-COUNTERPART NOT)
        (:EXECUTABLE-COUNTERPART REVERSE)
        (:FAKE-RUNE-FOR-TYPE-SET NIL)
        (:FORWARD-CHAINING ALISTP-FORWARD-TO-TRUE-LISTP)
        (:INDUCTION ALISTP)
        (:TYPE-PRESCRIPTION ALISTP)
        (:TYPE-PRESCRIPTION REVERSE))

---
The key checkpoint goals, below, may help you to debug this failure.
See :DOC failure and see :DOC set-checkpoint-summary-limit.
---

*** Key checkpoint at the top level: ***

Goal''
(IMPLIES (AND (ALISTP X)
              (NOT (CONSP (REVERSE X))))
         (NOT (REVERSE X)))

*** Key checkpoints under a top-level induction: ***

Subgoal *1/4''
(IMPLIES (AND (CONSP X)
              (CONSP (CAR X))
              (NOT (REVERSE (CDR X)))
              (ALISTP (CDR X))
              (NOT (CONSP (REVERSE X))))
         (NOT (REVERSE X)))

Subgoal *1/3''
(IMPLIES (AND (CONSP X)
              (CONSP (CAR X))
              (CONSP (REVERSE (CDR X)))
              (ALISTP (CDR X))
              (NOT (CONSP (REVERSE X))))
         (NOT (REVERSE X)))

ACL2 Error [Failure] in ( VERIFY-GUARDS FOO):  The proof of the guard
conjecture for FOO has failed; see the discussion above about :VERIFY-GUARDS
and :GUARD-DEBUG.  See :DOC failure.

******** FAILED ********
 (:STOP-LD 3)
ACL2 !>>(RUNES-DIFF "test1.lisp")
 ((:OLD ((:TYPE-PRESCRIPTION TRUE-LISTP-REVERSE)))
  (:NEW ((:DEFINITION ALISTP)
         (:DEFINITION ATOM)
         (:DEFINITION NOT)
         (:DEFINITION TRUE-LISTP)
         (:ELIM CAR-CDR-ELIM)
         (:EXECUTABLE-COUNTERPART CONSP)
         (:EXECUTABLE-COUNTERPART NOT)
         (:EXECUTABLE-COUNTERPART REVERSE)
         (:FAKE-RUNE-FOR-TYPE-SET NIL)
         (:INDUCTION ALISTP))))
ACL2 !>>Bye.
