ACL2 Version 3.1 Installation Guide

NOTE: From time to time we may provide so-called incremental releases of ACL2. Please follow the recent changes to this page link on the ACL2 home page for more information.


Table of Contents




REQUIREMENTS

ACL2 Version 3.1 Copyright (C) 2006 University of Texas at Austin. ACL2 is licensed under the terms of the GNU General Public License. See below for details.

ACL2 works on Unix/Linux, Macintosh, and some Windows operating systems (at least including Windows 98, Windows 2000, and Windows XP). It can be built on top of any of the following Common Lisps:

Obtaining Common Lisp

ACL2 runs on top of most or all of the major Common Lisp implementations. These are enumerated below, with links. Often we put timing comparisons between different lisps in the ACL2 News.

Obtaining GCL

Gnu Common Lisp (GCL) has probably been the most commonly-used platform for ACL2, certainly among non-commercial Lisps. IMPORTANT: Here we are referring to the non-ANSI version (sometimes called the "CLtL1 version") of GCL. It is probably impossible to build ACL2 with ANSI GCL as of December 2005, but recent GCL advances suggest that this may be possible soon.

Debian package. You do not need to fetch GCL if you download the binary Debian package for ACL2. Thanks to Camm Maguire for maintaining this package.

GCL may be fetched from http://www.gnu.org/software/gcl/. If that site goes down, you may be able to find useful information from the GCL Temporary Distribution Site. GCL maintainer Camm Maguire suggests the following, in order of preference (most to least):

  1. apt-get -q install gcl gcl-doc if running Debian
  2. Download and install the prebuilt binaries otherwise (if available for your platform)
  3. Download the latest (stable) source tarball and build yourself otherwise
  4. Download the latest (stable) cvs branch and build yourself
As of December 2005, the latest recommended version is 2.6.7, and the latest development version is 2.7.0. But see below for suggestions for building GCL on a Macintosh running OS X.

You may obtain recent CVS versions by executing the following commands if you have CVS installed on your system, which will retrieve the latest development/unstable cvs sources by default.

export CVS_RSH=ssh [or, if using csh: setenv CVS_RSH ssh]
cvs -d:ext:anoncvs@subversions.gnu.org:/cvsroot/gcl co gcl
If you happen to know a particular version of GCL that you wish to obtain, perhaps by following GCL mailing lists, you can replace the commands above by commands such as the following.
export CVS_RSH=ssh [or, if using csh: setenv CVS_RSH ssh]
cvs -d:ext:anoncvs@subversions.gnu.org:/cvsroot/gcl co -r Version_x_y_z -d gcl-x.y.z gcl

Macintosh. Robert Krug has provided instructions for building GCL on Mac OS X, which we include here (very slightly modified, in part with help from Camm Maguire) in case others find them helpful.

The normal build process for GCL on Mac OS X assumes that
you have installed fink on your Mac.  (If you do not know
what this is, don't worry; you probably don't have it or
want it.)  Here we give instructions that have worked for
building GCL on OS X without fink.

   A. Obtain recent sources (there is a problem, e.g., with
      gcl-2.6.7).  For example, you can do the following:

      export CVSROOT=:pserver:anonymous@cvs.sv.gnu.org:/sources/gcl
      cvs -z9 -q co -d gcl-2.6.8pre -r Version_2_6_8pre gcl

      At some point you may be able to obtain GCL from
      ftp://ftp.gnu/org/, cd gnu, cd gcl, get
      gcl-2.6.8.tar.gz, tar xfz gcl-2.6.8.tar.gz)

   B. Make sure that /usr/local/bin is in your PATH; if not, run:
      PATH="$PATH:/usr/local/bin"

   C. cd <gcl directory>

   D. You now need to patch file h/powerpc-macosx.defs (this might not be
      necessary starting with GCL 2.6.8):

      Replace the line:
      LIBS := `echo $(LIBS) | sed -e 's/-lncurses/ /'` /sw/lib/libintl.dylib
      With:
      LIBS := `echo $(LIBS) | sed -e 's/-lncurses/ /'` /usr/local/lib/libintl.dylib

   E. Configure and start to build gcl:
      ./configure
      make

   F. Install gcl:
      sudo make install

Obtaining Allegro Common Lisp

Allegro Common Lisp is probably the most commonly-used commercial platform for ACL2. You may be able to obtain a trial version from its web site, http://www.franz.com/.

Obtaining CMU Common Lisp

CMU Common Lisp (sometimes called CMUCL) is a non-commercial Common Lisp implementation, available from http://www.cons.org/cmucl/.

Obtaining SBCL

SBCL (Steel Bank Common Lisp) is a non-commercial Common Lisp implementation, available from http://sbcl.sourceforge.net/.

Obtaining CLISP

CLISP is a non-commercial Common Lisp implementation, available from http://clisp.cons.org/.

Obtaining OpenMCL

OpenMCL, a free Common Lisp implementation that runs on Macintosh OS X, is available from http://openmcl.clozure.com/.

Obtaining Lispworks

Lispworks is a commercial Common Lisp available from http://www.lispworks.com/.

Lispworks note. We initially encountered a problem in getting ACL2 to run under LIspworks 4.2.0. The Lispworks folks provided a patch and suggested that we make the following announcement.

Users with LispWorks4.2.7 should ask us at lisp-support@xanalys.com for the transform-if-node patch. It will be helpful if they quote (Lisp Support Call #11372) when doing so. Also, they must send a bug form generated from their LispWorks image: instructions at http://www.lispworks.com/support/bug-report.html.

Performance comparisons

Please go to the ACL2 home page and follow the link "Recent changes to this page" to see recent performance numbers.


OBTAINING AND INSTALLING ACL2

ACL2 is more than just the executable image. You should obtain the standard books and a local copy of the documentation. Start here and we will take you through the whole process of obtaining and installing ACL2. First, create a directory in which to store ACL2 Version 3.1. We will call this directory dir. For example, dir might be /home/jones/acl2/v3-1.

NOTE: If you intend to obtain an incremental release (e.g. 2.9.4 as opposed to 2.9), please see the ACL2 News for instructions. Otherwise, continue reading here.

Begin by clicking on one of the following links.

The sources come with a books subdirectory (here for the latest non-incremental release) that you may find helpful in your proof development and programming with ACL2. The following two collections of books are not included with the sources. You can extract them in the books/ subdirectory of your ACL2 distribution; see the discussion below on certifying books for information on using them.




Pre-built Binary Distributions

Visit the "Recent changes to this page" link on the ACL2 home page to see if there are other shortcuts available.


Obtaining the Sources: Unix and Linux

For a Unix or Linux system, obtain the sources and place them in directory dir as follows. Now proceed to Creating An Executable Image.


Obtaining the Sources: Other than Unix and Linux Systems

For a non-Unix (and non-Linux) system, obtain the sources and place them in directory dir. The easiest way to do this is to fetch file http://www.cs.utexas.edu/users/moore/acl2/v3-1/distrib/acl2.tar.gz, and then extract using an appropriate tar utility. For example, for Windows systems you may be able to download a utility such as djtarnt.exe to be used as follows:
djtarnt.exe -x acl2.tar.gz
WARNING: At least one user experienced CR/LF issues when using WinZIP, but we have received the suggestion that people untarring with that utility should probably turn off smart cr/lf conversion.

For a non-incremental release, you may be able to fetch files individually from directory (and subdirectories, sub-subdirectories, etc., for example as follows: http://www.cs.utexas.edu/users/moore/acl2/v3-1/distrib/acl2-sources/.

You will find that the ACL2 distribution contains many files, subdirectories, sub-subdirectories, etc. We mean for you to copy over to your local connected directory the entire structure of files and subdirectories. Thus, when you have completed extracting from acl2.tar.gz, or fetching all files directly is done, your local connected directory should have a subdirectory named acl2-sources under which everything resides.

Now proceed to Creating An Executable Image.



Creating An Executable Image

The next step is to create an executable image. The common approach is to build that image from the sources you have already obtained. However, you may be able to take a short cut by downloading an ACL2 image, in which case you can skip ahead to Summary of Distribution. Otherwise you should click on one of the links just below. Choose the last option if you are using a Common Lisp on which you cannot save an image (e.g., a trial version of Allegro Common Lisp).

PLEASE NOTE: The available memory for ACL2 is determined by the underlying Common Lisp executable. If you need more memory, refer to your Common Lisp's instructions for building an executable.




Short Cut: Pre-Built ACL2 Images

The site http://www.cs.utexas.edu/users/moore/acl2/v3-1/distrib/images/Readme.html contains links to ACL2 executables and packages. Each -md5sum file was created using md5sum. We may add additional links from time to time.

Note that the Debian images may work with other Linux systems as well.

Now proceed to Using ACL2.



Building an Executable Image on a Unix or Linux System

We assume you have obtained ACL2 and placed it in directory dir, as described above. If you downloaded a pre-built ACL2 image, you may skip this section. Connect to dir as above and execute

cd acl2-sources
make LISP=xxx

where xxx is the command to run your local Common Lisp.

By default, if no LISP=xxx is specified, LISP=gcl is used. On our hosts, gcl is the name of GNU Common Lisp, which can be obtained as explained above.

This will create executable saved_acl2 in the acl2-sources directory.

The time taken to carry out this process depends on the host processor but may be only a few minutes for a fast processor. The size of the resulting binary image is dependent on which Lisp was used, but it may be in the vicinity of 17 megabytes.

This make works for the Common Lisps listed in Requirements above on Unix and Linux systems we have tested. See the file acl2-sources/GNUmakefile for further details. If this make command does not work for you, please see the instructions for non-Unix/Linux systems below.

You can now skip to Using ACL2.




Building an Executable Image on Other than Unix and Linux Systems

Next we describe how to create a suitable binary image containing ACL2. If you are using a trial version of Allegro Common Lisp, then you may not be able to save an image. In that case, skip to Running Without Building an Executable Image.

See also Building an Executable Image on Some Particular Systems, in case you want to skip directly to the instructions in one of its subtopics.

Otherwise, proceed as follows.

Your Common Lisp should be one of those listed in Requirements above. Filenames below should default to the dir/acl2-sources directory, e.g., for GCL, connect to dir/acl2-sources before invoking GCL or, after entering GCL, do (si::chdir "dir/acl2-sources/").

  1. Remove file nsaved_acl2 if it exists.

  2. Start up Common Lisp in the acl2-sources directory and submit the following sequence of commands.
      ; Compile
      (load "init.lisp")
      (in-package "ACL2")
      (compile-acl2)
    
    The commands above will compile the ACL2 sources and create compiled object files on your acl2-sources subdirectory.

  3. Now exit your Common Lisp and invoke a fresh copy of it (mainly to avoid saving an image with the garbage created by the compilation process). Again arrange to connect to the acl2-sources subdirectory. In the fresh Lisp type:
      ; Initialization, first pass
      (load "init.lisp")
      (in-package "ACL2")
      (load-acl2)
      (initialize-acl2)
    
    This will load the new object files in the Lisp image and bootstrap ACL2 by reading and processing the source files. But the attempt at initialization will end in an error saying that it is impossible to finish because a certain file was compiled during the processing, thus dirtying the image yet again. (If however the attempt ends with an error during compilation of file TMP1.lisp, see the first troubleshooting tip below.)

  4. So now exit your Common Lisp and invoke a fresh copy of it (again arranging to connect to your acl2-sources subdirectory). Then, in the fresh Lisp type:
      ; Initialization, second pass
      (load "init.lisp")
      (in-package "ACL2")
      (save-acl2 (quote (initialize-acl2))
                 "saved_acl2")
    
    You have now saved an image. Exit Lisp now. Subsequent steps will put the image in the right place.

  5. Remove osaved_acl2 if it exists.

  6. IF saved_acl2 and saved_acl2.dxl both exist THEN: ELSE IF saved_acl2 exists THEN:

  7. Move nsaved_acl2 to saved_acl2.

  8. For Allegro Common Lisp, Versions 5.0 and later, nsaved_acl2.dxl should exist; move it to saved_acl2.dxl

  9. Make sure saved_acl2 is executable.



Building an Executable Image on Some Particular Systems

Subtopics of this section are as follows.


How to build/install ACL2 on GCL on Mac OS X

See the directions above for bulding GCL on Mac OS X. Then follow the usual installation instructions to obtain the ACL2 sources and build an executable image on a Unix/Linux system.


Special Case: Building an Executable Image on a Windows System using GCL

You may want to skip this section and instead read Instructions from Jared Davis for building ACL2 on Windows using mingw. Or, you may be able to download a pre-built ACL2 image for GCL/Windows instead of reading this section.
Otherwise here are steps to follow.
  1. FIRST get GCL running on your Windows system using ONE of the following two options. Note that GCL can be unhappy with spaces in filenames, so you should probably save the GCL distribution to a directory whose path is free of spaces.
  2. SECOND, create an appropriate GCL batch file. When we tried running the script gclm/bin/gclm.bat that came with gcl-cvs-20021014-mingw32 from the above ftp site, a separate window popped up, and with an error. Many ACL2 users prefer running in an emacs shell buffer. (We obtained emacs for Windows from ftp://ftp.gnu.org/gnu/windows/emacs/21.2/emacs-21.2-fullbin-i386.tar.gz.) The following modification of gclm.bat seemed to solve the problem (your pathnames may vary).
    @
    % do not delete this line %
    @ECHO off
    set cwd=%cd%
    path C:\gcl\gclm\mingw\bin;%PATH%
    C:\gcl\gclm\lib\gcl-2.6.1\unixport\saved_gcl.exe -dir C:/gcl/gclm/lib/gcl-2.6.1/unixport/ -libdir  C:/gcl/gclm/lib/gcl-2.6.1/ -eval "(setq si::*allow-gzipped-file* t)" %1 %2 %3 %4 %5 %6 %7 %8 %9
    
  3. THIRD, follow the instructions for non-Unix/Linux systems above, though the resulting file may be called saved_acl2.exe rather than saved_acl2.
  4. FINALLY, create a file acl2.bat as explained in http://www.cs.utexas.edu/users/moore/acl2/v3-1/distrib/images/Readme.html.

We hope that the above simply works. If you experience problems, the following hints may help.

TROUBLESHOOTING:




Instructions from Jared Davis for building ACL2 on Windows using mingw

We thank Jared Davis for providing the following instructions for Version_2.8, which we include verbatim and expect apply to future versions.
	      Building ACL2 on Windows from Scratch
   _____________________________________________________________

   Note: The disk space requirements are large.  Not including
   emacs, I had about 275 MB taken up by msys/mingw32/gcl/acl2
   during the build process.  You can probably use much less
   space by removing files after you use them, but I didn't
   bother to do that.

   Here are the steps I took:

   Downloaded emacs 21.3 full distribution and installed
   Downloaded msys 1.10.10, installed to c:\acl2
   Downloaded mingw 3.1.0-1, installed to c:\acl2\mingw
   Downloaded gcl 2.5.3, extracted to c:\acl2\mingw
   Downloaded acl2 2.8, extracted to c:\acl2\sources



   Compiling gcl:

     in msys:

       cd /acl2/ming2/gcl-2.5.3
       ./configure
       make
       make install



   Compiling acl2:

     copy "etags.exe" to /mingw/bin.  you can find this program
     in your emacs folder, under "bin".

     in msys:

       cd /sources
       make



   Certifying ACL2 books:
   This took 111 minutes on my Athlon 2500+

     in msys:

       cd /sources

       mv nsaved_acl2.gcl.exe saved_acl2.exe

       vim books/Makefile-generic, remove "nice" from this line:
	   ACL2=time nice ../../saved_acl2

       make certify-books ACL2=/sources/saved_acl2.exe




Running Without Building an Executable Image

The most convenient way to use ACL2 is first to install an executable image as described above for Unix/Linux and other platforms. However, in some cases this is not possible, for example if you are using a trial version of Allegro Common Lisp. In that case you should follow the steps below each time you want to start up ACL2.

We assume you have obtained ACL2 and placed it in directory dir, as described above for Unix/Linux or other platforms. (If you downloaded a pre-built ACL2 image, then you may skip this section.) Connect to subdirectory acl2-sources of dir, start up your Common Lisp, and compile by executing the following forms. This sequence of steps need only be performed once.

  (load "init.lisp")
  (in-package "ACL2")
  (compile-acl2)
Now each time you want to use ACL2, you need only execute the following forms after starting up Common Lisp in subdirectory acl2-sources of dir.
  (load "init.lisp")
  (in-package "ACL2")
  (load-acl2)
  (initialize-acl2)
Note. The resulting process includes the ACL2 documentation, and hence will probably be considerably larger (perhaps twice the size) than the result of running an executable image created as described above.

Now proceed to read more about Using ACL2.



Summary of Distribution

The distribution includes the following. A list of all files in acl2-sources may be found in the file all-files.txt in that directory.
Readme.html; This file
acl2-sources/
  LICENSE  ; GNU General Public License
  GNUmakefile ; For Unix/Linux make.
  TAGS     ; Handy for looking at source files with emacs
  *.lisp   ; ACL2 source files
  all-files.txt    ; List of all files in this directory and subdirectories
  books/   ; Examples, potentially useful in others' proofs.  See books/Readme.html.
  doc/     ; ACL2 documentation in various formats
  emacs/   ; Miscellaneous emacs and file utilities, especially emacs-acl2.el
  init.lisp; Useful for building the system
  interface/
    emacs/ ; Support for ACL2 "proof trees".  See interface/emacs/README.doc.
    infix/ ; ACL2 infix printer by Mike Smith.  See interface/infix/README.
  saved/   ; Empty directory for backing up copies during make; not important
acl2.tar.gz; gzip'd tar file containing all of acl2-sources/ (see below)
images/    ; Some gzip'd tar'd executables; see images/Readme.html
split/     ; The result of splitting up acl2.tar.gz; see split/Readme.html

The entire acl2.tar.gz is a little more than 6 megabytes, which expands out to nearly 30 megabytes. Additional space is required to build an image, perhaps 30 to 120 megabytes depending on the Lisp, and to certify books.



Saving Space

For those really pressed for space, we note that it is not necessary to fetch the whole acl2.tar.gz file in order to build acl2. That file includes more than just the ACL2 sources proper. It suffices, for building ACL2, via the instructions above, to fetch only the acl2-sources/*.lisp files, which take up `only' about 5 megabytes, together with the file acl2-sources/GNUmakefile.


USING ACL2

Here we begin with a discussion of how to invoke ACL2 interactively. We then discuss testing as well as the certification of ACL2 books that come with the distribution. We conclude with a discussion of the documentation.


Invoking ACL2

At this point, dir has a subdirectory called acl2-sources. The sources and perhaps an executable image are located on that subdirectory. However, if you have not saved an image but instead use the directions above for Running Without Building an Executable Image, skip to When ACL2 Starts Up below.

The executable image is called acl2-sources/saved_acl2. You can invoke ACL2 by running that image, e.g.,

mycomputer% dir/acl2-sources/saved_acl2

If on a Unix/Linux system, then to make it easy to invoke ACL2 by typing a short command, e.g.,

mycomputer% acl2

you may want to install an executable file on your path, e.g., /usr/local/bin/acl2, containing the following two lines:

#!/bin/csh -f
dir/acl2-sources/saved_acl2


Note: A carriage return in the file after the last line above is important!


When ACL2 Starts Up

When you invoke ACL2, you should see the host Common Lisp print a header concerning the ACL2 version, license and copyright.

Some hosts then automatically enter the ACL2 ``command loop,'' an ACL2 read-eval-print loop with the prompt:

ACL2 !>
Other hosts will leave you in Common Lisp's read-eval-print loop. If yours is one of the latter, evaluate the Common Lisp expression (ACL2::LP) or simply (LP) if the current package is "ACL2".

Once in the ACL2 command loop, you can type an ACL2 term, typically followed by ``return'' or ``enter,'' and ACL2 will evaluate the term, print its value, and prompt you for another one. Below are three simple interactions:

ACL2 !>t
T
ACL2 !>'abc
ABC
ACL2 !>(+ 2 2)
4

To get out of the ACL2 command loop, type the :q command. This returns you to the host Common Lisp. We sometimes call this ``raw Lisp.'' You may re-enter the command loop with (LP) as above.

Note that when you are in raw Lisp you can overwrite or destroy ACL2 by executing inappropriate Common Lisp expressions. All bets are off once you've exited our loop. That said, many users do it. For example, you might exit our loop, activate some debugging or trace features in raw Lisp, and then reenter our loop. While developing proofs or tracking down problems, this is reasonable behavior.

Now you are ready to test your image.



Testing ACL2

An easy way to test the theorem prover is to type the following term to the ACL2 command loop:

:mini-proveall
This will cause a moderately long sequence of commands to be processed, each of which is first printed out as though you had typed it. Each will print some text, generally a proof of some conjecture. None should fail.

A more elaborate test is to certify the ``books'' that come with the distribution, which is a good idea anyhow; this is our next topic. On a Unix/Linux system, you can also certify just a small but useful subset of the books in a few minutes by executing, in directory dir/acl2-sources:

make certify-books-short



Certifying ACL2 Books

The ``books'' that come with the distribution have been contributed mainly by users and are on the subdirectory acl2-sources/books. See acl2-sources/books/Readme.html for information. The general topic of books is discussed thoroughly in the ACL2 documentation; see the BOOKS node in the documentation tree.

Books should be ``certified'' before they are used. We do not distribute certificates with our books, mainly because certification produces compiled code specific to the host. You should certify the books locally as a test of your ACL2 image.

It is easy to re-certify all the distributed books in Unix/Linux. We recommend you do this. If you have entered ACL2, exit to the operating system, e.g., by control-d in many systems.

While connected to dir/acl2-sources, execute

make certify-books
This will generate minimal output to the screen and will probably take an hour or two. Failure is indicated by the presence of **CERTIFICATION FAILED** in the log.

To remove the files thus created, invoke:

make clean-books

The certify-books target does not cause workshop books to be certified. If you want to certify those books as well, you will first need to download the gzipped tar file to the books/ directory, and then gunzip and extract it. You can certify all the books, including books for the workshops (including those from the 1999 workshop as described in the (hardbound) book Computer-Aided Reasoning: ACL2 Case Studies), using the command:

make regression

By default, certification uses the image dir/acl2-sources/saved_acl2. You may specify any ACL2 image, as long as it is either a command on your Unix/Linux path or an absolute file name, for example as follows.

make certify-books ACL2=my-acl2

make regression ACL2=/u/smith/projects/acl2/saved_acl2

We apologize to non-Unix/Linux users: we do not provide non-Unix/Linux instructions for recertifying the distributed books. The certification methods provided by the authors of the books vary greatly and we codified them in the Unix/Linux makefile (GNUmakefile) used above. Most subdirectories of acl2-sources/books contain either a README file or a certify.lsp file. Users who wish to certify one of these books and who cannot figure out (from these scant clues) what to type to ACL2 should not hesitate to contact the authors.

Next proceed to the section on Documentation.



Documentation

ACL2's documentation is a hypertext document that, if printed in book form, is about 1100 pages or more than 2 megabytes of text. Its hypertext character makes it far more pleasing to read with an interactive browser. The documentation is available in four formats: HTML, Texinfo, Postscript and ACL2 documentation strings. All of this material is copyrighted by the University of Texas at Austin and is derived under the GNU General Public License from material copyrighted by Computational Logic, Inc.

Two Web-based guided tours of ACL2 are available from the home page noted below. If you are already familiar with Nqthm, you might find it useful to look at the documentation node NQTHM-TO-ACL2. Another useful documentation topic for beginning ACL2 users is the node TUTORIAL.

HTML

The ACL2 Home Page is

http://www.cs.utexas.edu/users/moore/acl2/index.html

The home page provides a selected bibliography, a search button (near the top of the page), guided tours of the system, and the complete hypertext documentation tree.

Once you have installed ACL2, the HTML form of the documentation is available locally as dir/acl2-sources/doc/HTML/acl2-doc.html.

We urge you to browse your local copy of the documentation rather than our Web copy, simply to reduce Web traffic and the demand on our server. (Macintosh users using MacOS 9 and earlier may, however, find filenames being truncated and hence will want to avoid the local documentation.)

Emacs Info

This is a very convenient format for accessing the ACL2 documentation from within Emacs. In Emacs, invoke

meta-x info
and then, if you are unfamiliar with Info, type
control-h m
to see a list of commands available. In particular, type

g (dir/acl2-sources/doc/EMACS/acl2-doc-emacs.info)TOP

to enter the ACL2 documentation. Alternatively, your system administrator can add an ACL2 node to the top-level Info menu. The appropriate entry might read:

* ACL2 i.j: (dir/acl2-sources/doc/EMACS/acl2-doc-emacs).
          Documentation for ACL2 version i.j.

Note: The Emacs Info and Postscript versions of our documentation were created using the file acl2-sources/doc/texinfo.tex which is copyrighted by the Free Software Foundation, Inc. (See that file for copyright and license information.)

Users new to emacs may find it helpful to load into emacs the file dir/acl2-sources/emacs/emacs-acl2.el. Utilities offered by this file are documented near the top of the file.

Postscript

The Postscript version of the documentation is not included in our normal distribution because it is so much less useful than the hyper-text versions. But a gzipped Postscript (1.2 MB) version is available. It prints as a book of about 1000 pages and contains a Table of Contents and an index to all documented topics.

ACL2 Documentation Strings

The ACL2 system has facilities for browsing the documentation. When you are in the ACL2 command loop, you may query the documentation on a given topic by typing the command

:doc topic

where topic is the Lisp symbol naming the topic you want to learn about. To learn more about the on-line documentation, type :help and then return.

Note, however, that you may find it more convenient to view the documentation in a web browser (starting at doc/HTML/acl2-doc.html) or in Emacs info (starting at doc/EMACS/acl2-doc-emacs.info).

This completes the installation of ACL2 Version 3.1. You may wish to return to the Table of Contents.



MISCELLANEOUS INFORMATION

Please let us know if there is other information that you would find of use in this guide.


Problems

If you are having problems using the make utility, be sure that you are using GNU make.


Reasoning about the Real Numbers

ACL2 supports rational numbers but not real numbers. However, starting with Version 2.5, a variant of ACL2 called "ACL2(r)" supports the real numbers by way of non-standard analysis. ACL2(r) was conceived and first implemented by Ruben Gamboa in his Ph.D. dissertation work, supervised by Bob Boyer with active participation by Matt Kaufmann. See the documentation topic REAL for information about this extension and how to build it, and a warning about its experimental nature.

if you care to use ACL2(r), first download the non-standard analysis books (gzipped tar file) to the books/ subdirectory of your copy of the ACL2 distribution, say, dir/acl2-sources/books/. Then run:

tar xvfz nonstd.tar.gz

Next build an executable image and certify books. First, connect to your dir/acl2-sources/ directory and execute

cd acl2-sources
make large-acl2r LISP=xxx

where xxx is the command to run your local Common Lisp.

By default, if no LISP=xxx is specified, LISP=gcl is used. On our hosts, gcl is the name of GNU Common Lisp, which can be obtained as explained above.

This will create executable saved_acl2r in the dir/acl2-sources directory (notice the trailing ~code>r in the executable filename).

Finally, to certify books under directory dir/acl2-sources/books/nonstd/ with ACL2(r), stand in the dir/acl2-sources/ directory and execute the following command.

make regression-nonstd ACL2=dir/acl2-sources/saved_acl2r



Links and Mailing Lists

There are two mailing lists for ACL2 users. You can post messages to these lists only if you are a member. You may subscribe to or unsubscribe from these lists at http://www.cs.utexas.edu/users/moore/acl2/admin/forms/email.html. You should receive a confirmation of the request a short time later, along with instructions for use (e.g., how to retrieve archive messages). If you need further assistance, please send a message to acl2-request@lists.cc.utexas.edu.

You can retrieve archive files or search the archives using a web interface from http://www.cs.utexas.edu/users/moore/acl2/admin/forms/archive.html.

You can search the ACL2 documentation, workshops, and publications online from http://www.cs.utexas.edu/users/moore/acl2/admin/forms/search.html.

Finally, please report bugs in ACL2 to acl2-bugs@lists.cc.utexas.edu.



Export/Re-Export Limitations

ACL2 may be exported to any countries except those subject to embargoes under various laws administered by the Office of Foreign Assets Control ("OFAC") of the U. S. Department of the Treasury.


License and Copyright

ACL2 Version 3.1 -- A Computational Logic for Applicative Common Lisp
Copyright (C) 2006 University of Texas at Austin

This version of ACL2 is a descendent of ACL2 Version 1.9, Copyright (C) 1997 Computational Logic, Inc.

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Matt Kaufmann (Kaufmann@cs.utexas.edu)
J Strother Moore (Moore@cs.utexas.edu)

Department of Computer Sciences
University of Texas at Austin
Austin, TX 78712-1188 U.S.A.