ACL2 Version 1.7 (released October 1994) Notes
Major Section:  RELEASE-NOTES

Include-book now takes (optionally) an additional keyword argument, indicating whether a compiled file is to be loaded. The default behavior is unchanged, except that a warning is printed when a compiled file is not loaded. See include-book.

A markup language for documentation strings has been implemented, and many of the source files have been marked up using this language (thanks largely to the efforts of Laura Lawless). See markup. Moreover, there are translators that we have used to provide versions of the ACL2 documentation in info (for use in emacs), html (for Mosaic), and tex (for hardcopy) formats.

A new event defdoc has been implemented. It is like deflabel, but allows redefinition of doc strings and has other advantages. See defdoc.

We used to ignore corollaries when collecting up the axioms introduced about constrained functions. That bug has been fixed. We thank John Cowles for bringing this bug to our attention.

The macro defstub now allows a :doc keyword argument, so that documentation may be attached to the name being introduced.

A new command nqthm-to-acl2 has been added to help Nqthm users to make the transition to ACL2. See nqthm-to-acl2, which also includes a complete listing of the relevant tables.

Many function names, especially of the form ``foo-lst'', have been changed in order to support the following convention, for any ``foo'':

(foo-listp lst) represents the notion (for x in lst always foop x).
A complete list of these changes may be found at the end of this note. All of them except symbolp-listp and list-of-symbolp-listp have the string ``-lst'' in their names. Note also that keyword-listp has been renamed keyword-value-listp.

Accumulated persistence has been implemented. It is not connected to :brr or rule monitoring. See accumulated-persistence.

:Trigger-terms has been added for :linear rule classes, so you can hang a linear rule under any addend you want. See linear, which has been improved and expanded.

ACL2 now accepts 256 characters and includes the Common Lisp functions code-char and char-code. However, ACL2 controls the lisp reader so that #\c may only be used when c is a single standard character or one of Newline, Space, Page, Rubout, Tab. If you want to enter other characters use code-char, e.g., (coerce (list (code-char 7) (code-char 240) #a) 'string). See characters. Note: our current handling of characters makes the set of theorems different under Macintosh Common Lisp (MCL) than under other Common Lisps. We hope to rectify this situation before the final release of ACL2.

A new table, macro-aliases-table, has been implemented, that associates macro names with function names. So for example, since append is associated with binary-append, the form (disable append) it is interpreted as though it were (disable binary-append). See macro-aliases-table, see add-macro-alias and see remove-macro-alias.

The implementation of conditional metalemmas has been modified so that the metafunction is applied before the hypothesis metafunction is applied. See meta.

The Common Lisp functions acons and endp have been defined in the ACL2 logic.

We have added the symbol declare to the list *acl2-exports*, and hence to the package "ACL2-USER".

A new hint, :restrict, has been implemented. See hints.

It used to be that if :ubt were given a number that is greater than the largest current command number, it treated that number the same as :max. Now, an error is caused.

The table :force-table has been eliminated.

A command :disabledp (and macro disabledp) has been added; see disabledp.

Compilation via :set-compile-fns is now suppressed during include-book. In fact, whenever the state global variable ld-skip-proofsp has value 'include-book.

Here are some less important changes, additions, and so on.

Unlike previous releases, we have not proved all the theorems in axioms.lisp; instead we have simply assumed them. We have deferred such proofs because we anticipate a fairly major changed in Version 1.8 in how we deal with guards.

We used to (accidentally) prohibit the ``redefinition'' of a table as a function. That is no longer the case.

The check for whether a corollary follows tautologically has been sped up, at the cost of making the check less ``smart'' in the following sense: no longer do we expand primitive functions such as implies before checking this propositional implication.

The command ubt! has been modified so that it never causes or reports an error. See ubt!.

ACL2 now works in Harlequin Lispworks.

The user can now specify the :trigger-terms for :linear rules. See linear.

The name of the system is now ``ACL2''; no longer is it ``Acl2''.

The raw lisp counterpart of theory-invariant is now defined to be a no-op as is consistent with the idea that it is just a call of table.

A bug was fixed that caused proof-checker instructions to be executed when ld-skip-proofsp was t.

The function rassoc has been added, along with a corresponding function used in its guard, r-eqlable-alistp.

The in-theory event and hint now print a warning not only when certain ``primitive'' :definition rules are disabled, but also when certain ``primitive'' :executable-counterpart rules are disabled.

The modified version of trace provided by ACL2, for use in raw Lisp, has been modified so that the lisp special variable *trace-alist* is consulted. This alist associates, using eq, values with their print representations. For example, initially *trace-alist* is a one-element list containing the pair (cons state '|*the-live-state*|).

The system now prints an observation when a form is skipped because the default color is :red or :pink. (Technically: when-cool has been modified.)

Additional protection exists when you submit a form to raw Common Lisp that should only be submitted inside the ACL2 read-eval-print loop.

Here is a complete list of the changes in function names described near the top of this note, roughly of the form

foo-lst --> foo-listp
meaning: the name ``foo-lst'' has been changed to ``foo-listp.''
symbolp-listp    --> symbol-listp
list-of-symbolp-listp  --> symbol-list-listp
                       {for consistency with change to symbol-listp}
rational-lst     --> rational-listp
                     {which in fact was already defined as well}
integer-lst      --> integer-listp
character-lst    --> character-listp
stringp-lst      --> string-listp
32-bit-integer-lst   --> 32-bit-integer-listp
typed-io-lst     --> typed-io-listp
open-channel-lst --> open-channel-listp
readable-files-lst   --> readable-files-listp
written-file-lst --> written-file-listp
read-file-lst    --> read-file-listp
writeable-file-lst   --> writable-file-listp
                     {note change in spelling of ``writable''}
writeable-file-lst1  --> writable-file-listp1
pseudo-termp-lst     --> pseudo-term-listp
hot-termp-lst --> hot-term-listp {by analogy with pseudo-term-listp}
weak-termp-lst   --> weak-term-listp
weak-termp-lst-lst   --> weak-termp-list-listp
ts-builder-case-lstp -> ts-builder-case-listp
quotep-lst       --> quote-listp
termp-lst        --> term-listp
instr-lst        --> instr-listp
spliced-instr-lst    --> spliced-instr-listp
rewrite-fncallp-lst  --> rewrite-fncallp-listp
every-occurrence-equiv-hittablep1-lst -->
some-occurrence-equiv-hittablep1-lst  -->
            {by analogy with the preceding, even though it's a
             ``some'' instead of ``all'' predicate]
almost-quotep1-lst   --> almost-quotep1-listp
ffnnames-subsetp-lst --> ffnnames-subsetp-listp
boolean-lstp     --> boolean-listp
subst-expr1-lst-okp  --> subst-expr1-ok-listp


ACL2 Version 1.8 (May, 1995) Notes
Major Section:  RELEASE-NOTES

See note8-update for yet more recent changes.

Guards have been eliminated from the ACL2 logic. A summary is contained in this brief note. Also see defun-mode and see set-guard-checking.

Guards may be included in defuns as usual but are ignored from the perspective of admission to the logic: functions must terminate on all arguments.

As in Nqthm, primitive functions, e.g., + and car, logically default unexpected arguments to convenient values. Thus, (+ 'abc 3) is 3 and (car 'abc) is nil. See programming, and see the documentation for the individual primitive functions.

In contrast to earlier versions of ACL2, Version 1.8 logical functions are executed at Nqthm speeds even when guards have not been verified. In versions before 1.8, such functions were interpreted by ACL2.

Colors have been eliminated. Two ``defun-modes'' are supported, :program and :logic. Roughly speaking, :program does what :red used to do, namely, allow you to prototype functions for execution without any proof burdens. :Logic mode does what :blue used to do, namely, allow you to add a new definitional axiom to the logic. A global default-defun-mode is comparable to the old default color. The system comes up in :logic mode. To change the global defun-mode, type :program or :logic at the top-level. To specify the defun-mode of a defun locally use

(declare (xargs :mode mode)).

The prompt has changed. The initial prompt, indicating :logic mode, is

ACL2 !>
If you change to :program mode the prompt becomes
ACL2 p!>

Guards can be seen as having either of two roles: (a) they are a specification device allowing you to characterize the kinds of inputs a function ``should'' have, or (b) they are an efficiency device allowing logically defined functions to be executed directly in Common Lisp. If a guard is specified, as with xargs :guard, then it is ``verified'' at defun-time (unless you also specify xargs :verify-guards nil). Guard verification means what it always has: the input guard is shown to imply the guards on all subroutines in the body. If the guards of a function are verified, then a call of the function on inputs satisfying the guard can be computed directly by Common Lisp. Thus, verifying the guards on your functions will allow them to execute more efficiently. But it does not affect their logical behavior and since you will automatically get Nqthm speeds on unverified logical definitions, most users will probably use guards either as a specification device or only use them when execution efficiency is extremely important.

Given the presence of guards in the system, two issues are unavoidable. Are guards verified as part of the defun process? And are guards checked when terms are evaluated? We answer both of those questions below.

Roughly speaking, in its initial state the system will try to verify the guards of a defun if a :guard is supplied in the xargs and will not try otherwise. However, guard verification in defun can be inhibited ``locally'' by supplying the xargs :verify-guards nil. ``Global'' inhibition can be obtained via the :set-verify-guards-eagerness. If you do not use the :guard xargs, you will not need to think about guard verification.

We now turn to the evaluation of expressions. Even if your functions contain no guards, the primitive functions do and hence you have the choice: when you submit an expression for evaluation do you mean for guards to be checked at runtime or not? Put another way, do you mean for the expression to be evaluated in Common Lisp (if possible) or in the logic? Note: If Common Lisp delivers an answer, it will be the same as in the logic, but it might be erroneous to execute the form in Common Lisp. For example, should (car 'abc) cause a guard violation error or return nil?

The top-level ACL2 loop has a variable which controls which sense of execution is provided. To turn ``guard checking on,'' by which we mean that guards are checked at runtime, execute the top-level form :set-guard-checking t. To turn it off, do :set-guard-checking nil. The status of this variable is reflected in the prompt.

ACL2 !>
means guard checking is on and
ACL2 >
means guard checking is off. The exclamation mark can be thought of as ``barring'' certain computations. The absence of the mark suggests the absence of error messages or unbarred access to the logical axioms. Thus, for example
ACL2 !>(car 'abc)
will signal an error, while
ACL2 >(car 'abc)
will return nil.

Note that whether or not guards are checked at runtime is independent of whether you are operating in :program mode or :logic mode and whether theorems are being proved or not. (Although it must be added that functions defined in :program mode cannot help but check their guards because no logical definition exists.)

Version 1.8 permits the verification of the guards of theorems, thus insuring that all instances of the theorem will evaluate without error in Common Lisp. To verify the guards of a theorem named name execute the event

(verify-guards name).
If a theorem's guards have been verified, the theorem is guaranteed to evaluate without error to non-nil in Common Lisp (provided resource errors do not arise).

Caveat about verify-guards: implies is a function symbol, so in the term (implies p q), p cannot be assumed true when q is evaluated; they are both evaluated ``outside.'' Hence, you cannot generally verify the guards on a theorem if implies is used to state the hypotheses. Use if instead. In a future version of ACL2, implies will likely be a macro.

See sum-list-example.lisp for a nice example of the use of Version 1.8. This is roughly the same as the documentation for guard-example.

We have removed the capability to do ``old-style-forcing'' as existed before Version 1.5. See note5.

NOTE: Some low level details have, of course, changed. One such change is that there are no longer two distinct type prescriptions stored when a function is admitted with its guards verified. So for example, the type prescription rune for binary-append is now

(:type-prescription binary-append)
while in Versions 1.7 and earlier, there were two such runes:
(:type-prescription binary-append . 1)
(:type-prescription binary-append . 2)

Nqthm-style forcing on linear arithmetic assumptions is no longer executed when forcing is disabled.

Functional instantiation now benefits from a trick also used in Nqthm: once a constraint generated by a :functional-instance lemma instance (see lemma-instance) has been proved on behalf of a successful event, it will not have to be re-proved on behalf of a later event.

1+ and 1- are now macros in the logic, not functions. Hence, for example, it is ``safe'' to use them on left-hand sides of rewrite rules, without invoking the common warning about the presence of nonrecursive function symbols.

A new documentation section file-reading-example illustrates how to process forms in a file.

A new proof-checker command forwardchain has been added; see acl2-pc::forwardchain.

It is now possible to use quantifiers. See defun-sk and see defchoose.

There is a new event set-inhibit-warnings, which allows the user to turn off warnings of various types. see set-inhibit-warnings.

An unsoundness relating encapsulate and :functional-instance hints has been remedied, with a few small effects visible at the user level. The main observable effect is that defaxiom and non-local include-book events are no longer allowed in the scope of any encapsulate event that has a non-empty signature.

When certify-book is called, we now require that the default defun-mode (see default-defun-mode) be :logic. On a related note, the default defun-mode is irrelevant to include-book; the mode is always set to :logic initially, though it may be changed within the book and reverts to its original value at the conclusion of the include-book. A bug in include-book prevented it from acting this way even though the documentation said otherwise.

The documentation has been substantially improved. A new section ``Programming'' contains documentation of many useful functions provided by ACL2; see programming. Also, the documentation has been ``marked up'' extensively. Thus in particular, users of Mosaic will find many links in the documentation.

The symbols force, mv-nth, and acl2-count have been added to the list *acl2-exports*.

We now permit most names from the main Lisp package to be used as names, except for names that define functions, macros, or constants. See name.

We have changed the list of imports from the Common Lisp package to ACL2, i.e., the list *common-lisp-symbols-from-main-lisp-package*, to be exactly those external symbols of the Common Lisp package as specified by the draft Common Lisp standard. In order to accommodate this change, we have renamed some ACL2 functions as shown below, but these and other ramifications of this change should be transparent to most ACL2 users.

warning      --> warning$
print-object --> print-object$

Proof trees are no longer enabled by default. To start them up, :start-proof-tree.

We have added the capability of building smaller images. The easiest way to do this on a Unix (trademark of AT&T) system is: make small.

Here we will put some less important changes, additions, and so on.

We have added definitions for the Common Lisp function position (for the test eql), as well as corresponding versions position-equal and position-eq that use tests equal and eq, respectively. See position, see position-equal, and see position-eq.

The defthm event rational-listp-implies-rationalp-car no longer exists.

We fixed a bug in the hint mechanism that applied :by, :cases, and :use hints to the first induction goal when the prover reverted to proving the original goal by induction.

We fixed a bug in the handling of (set-irrelevant-formals-ok :warn).

In support of removing the old-style forcing capability, we deleted the initialization of state global old-style-forcing and deleted the definitions of recover-assumptions, recover-assumptions-from-goal, remove-assumptions1, remove-assumptions, and split-on-assumptions, and we renamed split-on-assumptions1 to split-on-assumptions.

The special value 'none in the proof-checker commands claim and = has been replaced by :none.

A bug in the handling of hints by subgoals has been fixed. For example, formerly a :do-not hint could be ``erased'' by a :use hint on a subgoal. Thanks go to Art Flatau for noticing the bug.

The functions weak-termp and weak-term-listp have been deleted, and their calls have been replaced by corresponding calls of pseudo-termp and pseudo-term-listp. The notion of pseudo-termp has been slightly strenthened by requiring that terms of the form (quote ...) have length 2.

Performance has been improved in various ways. At the prover level, backchaining through the recognizer alist has been eliminated in order to significantly speed up ACL2's rewriter. Among the other prover changes (of which there are several, all technical): we no longer clausify the input term when a proof is interrupted in favor of inducting on the input term. At the IO level, we have improved performance somewhat by suitable declarations and proclamations. These include technical modifications to the macros mv and mv-let, and introduction of a macro the-mv analogous to the macro the but for forms returning multiple values.

The function spaces now takes an extra argument, the current column.

A bug in the proof-checker equiv command was fixed.

The function intersectp has been deleted, because it was essentially duplicated by the function intersectp-equal.

We now proclaim functions in AKCL and GCL before compiling books. This should result in somewhat increased speed.

The function repeat has been eliminated; use make-list instead.

The proof-checker command expand has been fixed so that it eliminates let (lambda) expressions when one would expect it to.

A new primitive function, mv-nth, has been introduced. Mv-nth is equivalent to nth and is used in place of nth in the translation of mv-let expressions. This allows the user to control the simplification of mv-let expressions without affecting how nth is treated. In that spirit, the rewriter has been modified so that certain mv-nth expressions, namely those produced in the translation of (mv-let (a b c)(mv x y z) p), are given special treatment.

A minor bug in untranslate has been fixed, which for example will fix the printing of conjunctions.

Translate now takes a logicp argument, which indicates whether it enforces the restriction that :program mode functions do not occur in the result.

The modified version of trace provided by ACL2, for use in raw Lisp, has been modified so that the lisp special variable *trace-alist* has a slightly different functionality. This alist associates, using eq, symbols with the print representations of their values. For example, initially *trace-alist* is a one-element list containing the pair (cons 'state '|*the-live-state*|). Thus, one may cons the pair (cons '*foo* "It's a FOO!") on to *trace-alist*; then until *foo* is defined, this change will have no effect, but after for example

(defconst *foo* 17)
then trace will print 17 as "It's a FOO!".

Trace also traces the corresponding logic function.

Proof-tree display has been improved slightly in the case of successful proofs and certain event failures.

The function positive-integer-log2 has been deleted.

The macro skip-proofs now prints a warning message when it is encountered in the context of an encapsulate event or a book. See skip-proofs.

Some functions related to the-fn and wormhole1 now have defun-mode :program, but this change is almost certain to be inconsequential to all users.


ACL2 Version 1.8 (Summer, 1995) Notes
Major Section:  RELEASE-NOTES

ACL2 can now use Ordered Binary Decision Diagram technology. See bdd. There is also a proof-checker bdd command.

ACL2 is now more respectful of the intention of the function hide. In particular, it is more careful not to dive inside any call of hide during equality substitution and case splitting.

The ld special (see ld) ld-pre-eval-print may now be used to turn off printing of input forms during processing of encapsulate and certify-book forms, by setting it to the value :never, i.e., (set-ld-pre-eval-print :never state). See ld-pre-eval-print.

The TUTORIAL documentation section has, with much help from Bill Young, been substantially improved to a bona fide introduction, and has been renamed acl2-tutorial.

The term pretty-printer has been modified to introduce (<= X Y) as an abbreviation for (not (< Y X)).

Forward chaining and linear arithmetic now both benefit from the evaluation of ground subterms.

A new macro set-inhibit-output-lst has been defined. This should be used when setting the state global inhibit-output-lst; see set-inhibit-output-lst and see proof-tree.

The test for redundancy in definitions includes the guard and type declarations. See redundant-events.

See generalized-booleans for a discussion of a potential soundness problem for ACL2 related to the question: Which Common Lisp functions are known to return Boolean values?

Here we will put some less important changes, additions, and so on.

A bug has been fixed so that now, execution of :comp t (see comp) correctly handles non-standard characters.

A bug in digit-char-p has been fixed, so that the ``default'' is nil rather than 0.

True-listp now tests the final cdr against nil using eq instead of equal, for improved efficiency. The logical meaning is, however, unchanged.

Put-assoc-equal has been added to the logic (it used to have :defun-mode :program, and has been documented.


ACL2 Version 1.9 (Fall, 1996) Notes
Major Section:  RELEASE-NOTES

By default, when the system is started it is illegal to use the variable STATE as a formal parameter of a function definition. The aim is to prevent novice users from stumbling into the Byzantine syntactic restrictions on that variable symbol. Use

:set-state-ok t
or, equivalently,
(set-state-ok t)
to switch back to the old default mode. See set-state-ok

Set-state-ok is an event that affects the ACL2 defaults table (see acl2-defaults-table). Recall that when books are included, the defaults table is restored to its pre-inclusion state. Thus, while a set-state-ok form will permit the book to define a state-using function, it will not permit the user of the book to make such a definition. We recommend putting (set-state-ok t) in any book that defines a state using function.

Books certified under Version 1.8 must be recertified under Version 1.9. See :DOC version.

The simplifier has been made to look out for built-in clauses, whereas in past versions such clauses were only noticed by the ``preprocessor'' at the top of the waterfall. THIS CHANGE MAY PREVENT OLD SCRIPTS FROM REPLAYING! The undesirable side-effect is caused by the fact that :HINTS require you to refer to clauses by their exact name (see goal-spec) and because the new simplifier proves more clauses than before, the goals produced have different names. Thus, if a script uses :HINTS that refer to clauses other than "Goal", e.g., "Subgoal 1.3" then the hint may be applied to a different subgoal than originally intended.

The use of built-in-clauses has been made more efficient. If a set of clauses arise often in a piece of work, it might be advantageous to build them in even if that results in a large set (hundreds?) of built-in clauses. See built-in-clauses

Wormholes can now be used in :logic mode functions. See wormhole

It is now possible to provide ``computed hints.'' For example, have you ever wished to say ``in all goals with a name like this, :use that'' or ``if this term is in the subgoal, then :use that''? Well, see computed-hints and the extraordinarily long example in see using-computed-hints.

Hide terms may be rewritten with :rewrite rules about hide. See hide, where we also now explain why hide terms are sometimes introduced into your proof attempts.

A bug that sometimes caused the ``non-lazy IF'' hard error message was fixed.

A bug that sometimes caused a hard error in forward chaining was fixed.

A bug in print-rules (:pr) was fixed.

We report the use of :executable-counterparts in the evaluation of SYNTAXP forms.

Some documentation errors were fixed.

A bug in parent-tree tracking in add-literal-and-pt was fixed.

A bug in ok$, go$ and eval$ was fixed.

Clausify now optimizes (mv-nth 'k (list x0 ... xk ... xn)) to xk.