Партнёры:
Хостинг:
Archive-name: lisp-faq/part6
Last-Modified: Wed Feb 19 16:45:11 1997 by Mark Kantrowitz
Version: 1.55
Maintainer: Mark Kantrowitz and Barry Margolin <[email protected]>
URL: http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/lisp/top.html
Size: 74922 bytes, 1431 lines
;;; ****************************************************************
;;; FTP Archives and Other Resources *******************************
;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin
;;; lisp_6.faq
This post contains Part 6 of the Lisp FAQ.
If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at [email protected].
Topics Covered (Part 6):
[6-0] General information about FTP Resources for Lisp
[6-1] Repositories of Lisp Software
[6-3] Publicly Redistributable Lisp Software
[6-6] Formatting code in LaTeX (WEB and other literate programming tools)
[6-7] Where can I get an implementation of Prolog in Lisp?
[6-8] World-Wide Web (WWW) Resources
Search for \[#\] to get to question number # quickly.
----------------------------------------------------------------
Subject: [6-0] General information about FTP Resources for Lisp
Remember, when ftping compressed or compacted files (.Z, .z, .arc, .fit,
etc.) to use binary mode for retrieving the files.
Files that end with a .z suffix were compressed with the patent-free
gzip (no relation to zip). Source for gzip is available from:
prep.ai.mit.edu:/pub/gnu/
as the files gzip-1.2.3.shar, gzip-1.2.3.tar,or gzip-1.2.3.msdos.exe.
FTP sites for Lisp and Scheme interpreters and compilers are discussed
in the answer to questions [4-0] and [4-2] and in the Scheme FAQ. See
the entry on Macintosh Common Lisp in question [4-1] for information
on the CD-ROM of Lisp code that Apple distributes with MCL 2.0.
----------------------------------------------------------------
Subject: [6-1] Repositories of Lisp Software
There are several repositories of publicly redistributable and
public domain Lisp code.
Common Lisp Repository:
The Common Lisp Repository is accessible by anonymous ftp to
ftp.cs.cmu.edu:/user/ai/lang/lisp/ [128.2.206.173]
through the AFS directory
/afs/cs.cmu.edu/project/ai-repository/ai/lang/lisp/
or by WWW from the URL
http://www.cs.cmu.edu/Web/Groups/AI/html/repository.html
and includes more than 250 megabytes of sources, including all
freely distributable implementations and many programs. This
repository supersedes the Lisp Utilities collection, and is now
part of the CMU Artificial Intelligence Repository.
Programs in the repository include XREF (portable cross referencing
tool for Lisp, similar to the Symbolics Who-Calls and the Xerox
MasterScope programs), Brad Miller's initializations package for
Allegro CL 4.0, DEFSYSTEM (portable system definition facility, a
"Make" for Lisp), a portable implementation of the X3J13 June 1989
specification for logical pathnames, METERING (a portable code
time/space profiling tool), SOURCE-COMPARE (a portable "diff" utility
for Lisp), USER-MANUAL (a program which helps with documenting Lisp
code), PSGRAPH (Joe Bates' PostScript DAG grapher), several matchers
for Lisp, NREGEX (a regular expressions matcher), a date formatter, an
infix reader macro for Lisp, SAVE-OBJECT (Kerry Koitzsch's package to
save ASCII representations of Lisp objects to a file), Stephen
Nicoud's semi-portable CLtL2 version of defpackage, LALR (Mark
Johnson's lisp YACC parser generator), various implementations of the
Loop Macro, William Schelter's sloop macro, Frank Ritter and Jim
Panagos' implementation of the Yale yloop macro (described in
McDermont, Charniak and Riesbeck's AI programming book), all free Lisp
GUIs, including Express Windows, the iterate macro, Waters' Series
Macro package, Waters' XP Lisp Pretty Printer, Bruno Haible's
implementation of the Simplex algorithm, MAPFORMS (Moon's code
walker), Brad Miller's resources package, and much much more.
The repository has standardized on using 'tar' for producing
archives of files and 'gzip' for compression.
To search the keyword index by mail, send a message to:
[email protected]
with one or more lines containing calls to the keys command, such as:
keys lisp iteration
in the message body. Keywords may be regular expressions and are
compared with the index in a case-insensitive conjunctive fashion.
You'll get a response by return mail. Do not include anything else
in the Subject line of the message or in the message body. For help on
the query mail server, include:
help
instead.
A Mosaic interface to the keyword searching program is in the
works. We also plan to make the source code (including indexes) to
this program available, as soon as it is stable.
Most of the Common Lisp Repository appears on Prime Time Freeware
for AI, Issue 1-1, a mixed-media book/CD-ROM publication. It
includes two ISO-9660 CD-ROMs bound into a 224 page book and sells
(list) for US$60 plus applicable sales tax and shipping and handling
charges. Payable through Visa, Mastercard, postal money orders in US
funds, and checks in US funds drawn on a US bank. For more
information write to Prime Time Freeware, 370 Altair Way, Suite 150,
Sunnyvale, CA 94086 USA, call 408-433-9662, 408-433-0727 (fax),
or send email to [email protected].
Contributions of software and other materials are always welcome but
must be accompanied by an unambiguous copyright statement that grants
permission for free use, copying, and distribution -- either a
declaration by the author that the materials are in the public domain,
that the materials are subject to the GNU General Public License (cite
version), or that the materials are subject to copyright, but the
copyright holder grants permission for free use, copying, and
distribution. (We will tell you if the copying permissions are too
restrictive for us to include the materials in the repository.)
Inclusion of materials in the repository does not modify their
copyright status in any way. Materials may be placed in:
ftp.cs.cmu.edu:/user/ai/new/
When you put anything in this directory, please send mail to
[email protected]
giving us permission to distribute the files, and state whether
this permission is just for the AI Repository, or also includes
publication on the CD-ROM version (Prime Time Freeware for AI).
We would also appreciate if you would include a 0.doc file for your
package; see /user/ai/new/package.doc for a template. (If you don't
have the time to write your own, we can write it for you based on
the information in your package.)
The Common Lisp Repository is maintained by Mark Kantrowitz,
[email protected].
Known mirrors:
ftp.sunet.se:/pub/lang/lisp/
CLOS:
The CLOS code repository is available by anonymous ftp to
nervous.cis.ohio-state.edu:/pub/lispusers/clos/ [128.146.61.200]
If you've got code you'd like to add to the repository, send mail to
Arun Welch, [email protected]. The CLOS code
repository includes dag.lisp.Z and 3DGeometry.lisp. [The AI
Repository's Lisp Section includes a directory of CLOS code as well,
in ftp.cs.cmu.edu:/user/ai/lang/lisp/oop/clos-code/.]
MCL:
The Macintosh Common Lisp repository contains Lisp code for
MCL contributed by MCL users. It is available by anonymous ftp from
ftp.digitool.com/pub/mcl/contrib/ [198.112.73.129]
http://www.digitool.com
and also contains the Info-MCL mailing list archives. The
repository contains, among other things, AV_Parser.hqx and Zebu
(general parser toolkits), babylon-2.2.sit.hqx (expert system shell
from GMD in Germany), btree.sit.hqx (binary trees), LGL.lisp (Lisp
Graphics Library for MCL), quicktime code, mmlisp.sit.hqx
(midi-manager interface), tips on optimizing MCL code, PARKA.sit.hqx
(a knowledge representation system), starsim.sit.hqx (*Lisp for MCL),
IP/TCP examples, and support for hypercard XCMDs and XFCNs. See the
file README for a quick overview of the contents of the MCL
repository.
CLIM:
The CLIM Library (a library of user contributed code for the CLIM
environment) is available by anonymous ftp on
cambridge.apple.com:/pub/clim [134.149.2.3]
For information on CLIM, see the entry in [6-5] below. For more
information on the CLIM Library, contact Vincent Keunen, [email protected].
MIT AI Lab:
ftp.ai.mit.edu:/pub/
loop-macro.tar [LOOP from CLtL1]
series/ [SERIES from CLtL2; older version]
Iterate/ [Alternative to series and loop.]
clmath.tar [Numeric math 1984]
ontic/ [ONTIC Knowledge Rep. for Mathematics]
clmath is a Lisp library of mathematical functions that calculate
hyperbolic and inverse hyperbolic functions, Bessel functions,
elliptic integrals, the gamma and beta functions, and the incomplete
gamma and beta functions. There are probability density functions,
cumulative distributions, and random number generators for the normal,
Poisson, chi-square, Student's T, and Snedecor's F functions. Discrete
Fourier Transforms. Multiple linear regression, Fletcher-Powell
unconstrained minimization, numerical integration, root finding,
and convergence. Code to factor numbers and to do the
Solovay-Strassen probabilistic prime test is included.
A technical report describing CLMath is available as MIT AI Lab
Memo 774, Gerald Roylance, "Some Scientific Subroutines in LISP",
September 1984. Iterate is Jonathan Amsterdam's alternative to
series and the Loop macro. For more information, contact [email protected].
LispUsers Archives:
The LispUsers Archives, a collection of programs for Medley, can be
found on
nervous.cis.ohio-state.edu:/pub/lispusers/medley/
The files include a plotting module, addressbook, chat program, clock,
call-grapher, grep implementation, Tower of Hanoi, Life, lisp dialect
translator, and fonts. Also on nervous.cis.ohio-state.edu is GTT, an
implementation of Chandrasekaran's Generic Tasks Toolset, in directory
pub/lispusers/toolset.
Amiga LISP implementations:
There's a repository of Amiga LISP implementations (and other Lisp-like
language implementations) on gatekeeper.pa.dec.com:/pub/micro/amiga/lisp/.
Inside Computer Understanding:
Common Lisp versions of the mini programs from "Inside Computer
Understanding" by Schank and Riesbeck, 1981, are available by
anonymous ftp from
cs.umd.edu:/pub/schank/icu/
This includes the SAM and ELI miniatures. It will eventually include copies
of the miniature versions of PAM, POLITICS, and Tale-Spin. The FOR
macro is also available in this directory, as are a set of functions
for manipulating and matching lisp representations of Conceptual
Dependency formulas. Contact Bill Andersen <[email protected]> for
more information.
Norvig:
The software from Peter Norvig's book "Paradigms of AI Programming" is
available by anonymous ftp from unix.sri.com:/pub/norvig/ and on disk in
Macintosh or DOS format from the publisher, Morgan Kaufmann.
Software includes Common Lisp implementations of:
Eliza and pattern matchers, Emycin, Othello, Parsers,
Scheme interpreters and compilers, Unification and a prolog
interpreter and compiler, Waltz line-labelling,
implementation of GPS, macsyma, and random number generators.
For more information, contact:
Morgan Kaufmann, Dept. P1, 2929 Campus Drive, Suite 260
San Mateo CA 94403, (800) 745-7323; FAX: (415) 578-0672
Mac ISBN 1-55860-227-5
DOS 3.5" ISBN 1-55860-228-3
DOS 5.25" ISBN 1-55860-229-1
NL Software Registry:
A catalog of free and commercial natural language software is
available from the Natural Language Software Registry, by anonymous
ftp from
ftp.dfki.uni-sb.de:/registry/
or by email to [email protected].
TI Explorer Lisp Code:
sumex-aim.stanford.edu:/pub/exp/
The Knowledge Systems Lab's set of Explorer patches and tools. It
includes in the jwz subdirectory a set of tools written and collected
by Jamie Zawinski. Send questions to [email protected].
Waters' Programs:
Dick Waters' XP Lisp Pretty Printer is available by anonymous ftp
from
merl.com:/pub/xp/
as the files xp-code.lisp, xp-doc.txt, and xp-test.lisp.
The Series Macro is available from
merl.com:/pub/series/
as the files s-code.lisp, s-test.lisp, and s-doc.txt. The
Series macro package is described fully in Waters, R.C., "Automatic
Transformation of Series Expressions into Loops", ACM Transactions on
Programming Languages and Systems, 13(1):52--98, January 1991,
MIT/AIM-1082 and MIT/AIM-1083.
Both programs are also available from the Common Lisp Repository
described above.
For further information, contact Dick Waters, <[email protected]> or
<[email protected]>. An improved version of Series is in the works.
----------------------------------------------------------------
Subject: [6-3] Publicly Redistributable Lisp Software
AI Algorithms and Tools:
PAIL (Portable AI Lab) is a computing environment containing a
collection of state-of-the-art AI tools, examples, and documentation.
It is aimed at those involved in teaching AI courses at university
level or equivalent. The system has enough built-in functionality to
enable its users to get practical experience with a broad range of AI
problems without having to build all the supporting tools from
scratch. It is implemented in Common Lisp and uses CLOS and Allegro
Common Windows (i.e., in Allegro CL 4.1). It is available by anonymous
ftp from
pobox.cscs.ch:/pub/ai/ [148.187.10.13]
Written by Mike Rosner and Dean Allemang {dean,mike}@idsia.ch.
AI_ATTIC is an anonymous ftp collection of classic AI programs and
other information maintained by the University of Texas at Austin. It
includes Parry, Adventure, Shrdlu, Doctor, Eliza, Animals, Trek, Zork,
Babbler, Jive, and some AI-related programming languages. This
archive is available by anonymous ftp from
ftp.cc.utexas.edu:/pub/AI_ATTIC/ [128.83.186.13]
(AKA bongo.cc.utexas.edu). For more information, contact
[email protected].
Analogical Reasoning:
SME is the Structure-Mapping Engine, as described in Falkenhainer,
Forbus, and Gentner's 1987 AIJ article. Available from
multivac.ils.nwu.edu:/pub/SME For further information, contact Brian
Falkenhainer <[email protected]> or Ken Forbus
<[email protected]>.
Benchmarks:
Gabriel Lisp Benchmarks are available by anonymous ftp as
ai.toronto.edu:/pub/gabriel-lisp-benchmarks.tar.Z.
The benchmarks are described in the book "Performance Evaluation of
Lisp Systems", by Richard Gabriel.
Lucid CL contains a set of benchmarks in its goodies/ directory,
including Bob Boyer's logic programming benchmark, a benchmark to
create and browse through an AI-like database of units, a CLOS speed
test, a compilation speed test, TAKR (the 100 function version of TAK
that tries to defeat cache memory effects), CTAK (A version of the
TAKeuchi function that uses the CATCH/THROW facility), STAK (A version
of the TAKeuchi function with special variables instead of parameter
passing), DERIV and DDERIV (Symbolic derivative benchmarks written by
Vaughn Pratt), DESTRU (a destructive operation benchmark), DIV2 (a
benchmark which divides by 2 using lists of n ()'s), the FFT benchmark
written by Harry Barrow, FPRINT (a benchmark to print to a file),
FRPOLY (a Franz Lisp benchmark by Fateman based on polynomial
arithmentic), Forest Baskett's PUZZLE benchmark (originally written in
Pascal), the TPRINT benchmark to read and print to the terminal, a
benchmark that creates and traverses a tree structure, and TRIANG
(board game benchmark). Some of the benchmarks may work only in Lucid.
Blackboard Architectures:
The UMass GBB system (V1.2) is available by anonymous ftp from
ftp.cs.umass.edu:/gbb. The commercial GBB product is not.
Work on the UMass GBB project (and funding) ended over 2 years ago.
Many researchers using it have opted for the commercial
release. The UMass research system remains available, but the
two should not be confused as the commercial system is
substantially improved and extended. The commercial system is
available from Blackboard Technology Group, 401 Main Street, Amherst,
Massachusetts 01002, telephone 800-KSS-8990 or 413-256-8990, fax
413-256-3179.
For a tutorial on how to build a blackboard system, see the paper
P. R. Kersten and Avi C. Kak, "A Tutorial on LISP Object-Oriented
Programming for Blackboard Computation (Solving the Radar Tracking
Problem)", International Journal of Intelligent Systems 8:617-669, 1993
Although samples of the code are given in the paper, the full source
code is available in a separate technical report from the School of
Electrical Engineering at Purdue University. If you are interested in
getting a copy of the technical report, send mail to Avi Kak
<[email protected]>. (The circumstances under which the software was
developed prevent them from making the source code available by
anonymous FTP. However, the full source code is printed in the
technical report.)
Case-based Reasoning:
CL-Protos is a Common Lisp implementation of the case-based
reasoning system developed by E. Ray Bareiss and Bruce W.
Porter of the University of Texas/Austin AI Lab. It runs
on Sun3, TI Explorer, HP 9000, and Symbolics, and gobbles a
huge amount of memory. Common Lisp implementation by
Rita Duran, Dan Dvorak, Jim Kroger, Hilel Swerdlin, and Ben Tso.
For more information, bug reports, or comments, contact
either Dan Dvorak <[email protected]> or Ray Bareiss
<[email protected]> or Erik Eilerts <[email protected]>
Available by anonymous ftp from cs.utexas.edu:/pub/porter
The complete code for "Inside Case-Based Reasoning" by Riesbeck and
Schank, 1989, is available by anonymous ftp from
cs.umd.edu:/pub/schank/icbr/
This includes code for an instructional version of CHEF by Kristian
Hammond and MICRO-xxx. Contact Bill Andersen <[email protected]>
for more information.
CLOS Software:
See question [5-6].
Constraint Programming and Non-determinism:
SCREAMER:
Screamer is an extension of Common Lisp that adds support for
nondeterministic programming. Screamer consists of two levels. The
basic nondeterministic level adds support for backtracking and
undoable side effects. On top of this nondeterministic substrate,
Screamer provides a comprehensive constraint programming language in
which one can formulate and solve mixed systems of numeric and
symbolic constraints. Together, these two levels augment Common Lisp
with practically all of the functionality of both Prolog and
constraint logic programming languages such as CHiP and CLP(R).
Furthermore, Screamer is fully integrated with Common Lisp. Screamer
programs can coexist and interoperate with other extensions to Common
Lisp such as CLOS, CLIM and Iterate.
In several ways Screamer is more efficient than other implementations
of backtracking languages. First, Screamer code is transformed into
Common Lisp which can be compiled by the underlying Common Lisp
system. Many competing implementations of nondeterministic Lisp are
interpreters and thus are far less efficient than Screamer. Second,
the backtracking primitives require fairly low overhead in Screamer.
Finally, this overhead to support backtracking is only paid for those
portions of the program which use the backtracking primitives.
Deterministic portions of user programs pass through the Screamer to
Common Lisp transformation unchanged. Since in practise, only small
portions of typical programs utilize the backtracking primitives,
Screamer can produce more efficient code than compilers for languages
in which backtracking is more pervasive.
Screamer is fairly portable across most Common Lisp implementations.
It currently runs under Genera 8.1.1 and 8.3 on both Symbolics 36xx
and Ivory machines, under Lucid 4.0.2 and 4.1 on Sun SPARC machines,
under MCL 2.0 and 2.0p2 on Apple Macintosh machines, and under Poplog
Common Lisp on Sun SPARC machines. It should run under any
implementation of Common Lisp which is compliant with CLtL2 and with
minor revision could be made to run under implementations compliant
with CLtL1 or dpANS.
Screamer is available by anonymous FTP from
ftp.ai.mit.edu:/pub/screamer.tar.Z
Contact Jeffrey Mark Siskind <[email protected]> for further
information. Screamer is also available from the Common Lisp Repository.
The Screamer Tool Repository, a collection of user-contributed
Screamer code, is available by anonymous ftp from
ftp.cis.upenn.edu:/pub/screamer-tools/
or by WWW from
http://www.cis.upenn.edu/~screamer-tools/home.html
Please direct all inquires about the repository to
[email protected].
Defeasible Reasoning:
An implementation of J. Paris and A. Vencovska's model of belief is
available by anonymous ftp from
ftp.cs.cmu.edu:/user/ai/areas/reasonng/defeasbl/belief/
Paris and Vencovska's paper (Artificial Intelligence, 64(2), December
1993) provides a mathematical model of an agent's belief in an event
by identifying it with his ability to imagine the event within the
context of his previous experience. This approach leads to beliefs
having properties different from those normally ascribed to it. The
implementation was written by Ian Pratt <[email protected]> and Jens
Doerpmund <[email protected]> and runs in Common Lisp.
Eliza and Similar Programs:
See Peter Norvig's book and AI_ATTIC (question [6-1] above).
The doctor.el is an implementation of Eliza for
GNU-Emacs emacs-lisp. Invoke it with "Meta-X doctor"
muLISP-87 (a MSDOS Lisp sold by Soft Warehouse) includes
a Lisp implementation of Eliza.
Implementations of ELIZA for other languages are mentioned in the AI FAQ.
The original Parry (in MLISP for a PDP-10) is available in
labrea.stanford.edu:/pub/parry.tar.Z.
Other programs, such as RACTER, are listed in part 4 of the AI FAQ.
Expert Systems:
FOCL is an expert system shell and machine learning program written in
Common Lisp. The machine learning program extends Quinlan's FOIL
program by containing a compatible explanation-based learning
component. FOCL learns Horn Clause programs from examples and
(optionally) background knowledge. The expert system includes a
backward-chaining rule interpreter and a graphical interface to the
rule and fact base. For details on FOCL, see: Pazzani, M. and Kibler,
D., "The role of prior knowledge in inductive learning", Machine
Learning 9:54-97, 1992. It is available by anonymous ftp from
ics.uci.edu:/pub/machine-learning-programs/
as the files README.FOCL-1-2-3, FOCL-1-2-3.cpt.hqx (a binhexed,
compacted Macintosh application), FOCL-1-2-3.tar.Z (Common Lisp
source code), and FOCL-1-2-3-manual.hqx (binhexed manual). If you
use a copy of FOCL, or have any comments or questions, send mail to
[email protected].
BABYLON is a development environment for expert systems. It
includes frames, constraints, a prolog-like logic formalism, and a
description language for diagnostic applications. It is implemented in
Common Lisp and has been ported to a wide range of hardware platforms.
Available by anonymous ftp from
ftp.gmd.de:/gmd/ai-research/Software/Babylon/ [129.26.8.84]
as a BinHexed stuffit archive, on the Web via the URL
http://www.gmd.de/
on the Apple CD-ROM, or with the book "The AI Workbench BABYLON",
which contains *full source code* of BABYLON and the stand-alone
version for the Mac. The book describes the use of BABYLON in detail.
OPS5 is a public domain Common Lisp implementation of the OPS5
production system interpreter written by Charles Forgy. It is
available from the CMU AI Repository in
ftp.cs.cmu.edu:/user/ai/areas/expert/ops5/
and includes the original port by George Wood and Jim Kowalski
(ops5orig.tar.gz), and a later port by Mark Kantrowitz (ops5.tar.gz).
The latter has been tested under Allegro, Lucid, CMU CL, Ibuki CL and
MCL.
Frame Languages:
FrameWork is a portable generic frame system available from the CMU
AI Repository, in
ftp.cs.cmu.edu:/user/ai/areas/kr/systems/frames/framewrk/
THEO (learning frame system) is available free from CMU, after
signing a license agreement. Send mail to [email protected].
FrameKit is available free from CMU, after signing a
license agreement. Send mail to [email protected]
KR. Send mail to [email protected] for more info.
PARKA. Frames for the CM. Contact [email protected].
PARMENIDES (Frulekit) is available free, after signing
a license agreement. Send mail to [email protected]
FROBS is available free by anonymous ftp from
cs.utah.edu:/pub/frobs.tar.Z
Contact Robert Kessler <[email protected]> for more info.
PFC is a simple frame system written by Tim Finin
available free by anonymous ftp from linc.cis.upenn.edu.
YAK is a hybrid knowledge-representation system of the
KL-ONE family. Includes an optional graphical interface
depending on the Lisp. Available free after signing a license
agreement. Contact Enrico Franconi <[email protected]>.
Genetic Algorithms:
GECO (Genetic Evolution through Combination of Objects) is a
genetic algorithm shell written by George Williams,
<[email protected]>. It is available by anonymous ftp
from cambridge.apple.com:/pub/mcl2/contrib/ as the following
files:
GECO-v1.0.cpt.hqx binhex'd Compact Pro archive
GECO-v1.0.tar.Z compressed tar file for Unix machines (no MCL
fonts)
GECO.abstract a brief description
It runs in MCL 2.0, but should be portable among CLtL2 compliant
Common Lisps.
GAL is a genetic algorithm suite written by Bill Spears of NRL. The
MCL2.0 port was done by Howard Oakley <[email protected]> and
is available from cambridge.apple.com:/pub/MCL2/contrib as
GAL.sea.hqx. Improvements and adaptations should be sent to Bill
Spears, but questions on the MCL port should be directed to Howard Oakley.
Other genetic algorithms code is available
ftp.aic.nrl.navy.mil:/pub/galist
including Genesis (source-code/ga-source/genesis.tar.Z) and the archives
of the GA-List mailing list. A survey of free and commercial
genetic algorithms implementations is available in
information/ga-software-survey.txt.
Knowledge Representation:
KNOWBEL is an implementation of Telos (a sorted/temporal logic
system) by Bryan M. Kramer, <[email protected]>. It is
available by anonymous ftp from ai.toronto.edu:/pub/kr/ as the
files knowbel.tar.Z and manual.txt.tar.Z
Runs in Allegro CL on Sparcstations and Silicon Graphics 4d
and in MCL on Apple Macintoshes.
SNePS (Semantic Network Processing System) is the implementation of a
fully intensional theory of propositional knowledge representation and
reasoning. SNePS includes a module for creating and accessing
propositional semantic networks, path-based inference, node-based
inference based on SWM (a relevance logic with quantification) that
uses natural deduction and can deal with recursive rules, forward,
backward and bi-directional inference, nonstandard logical connectives
and quantifiers, an assumption based TMS for belief revision, a
morphological analyzer and a generalized ATN (GATN) parser for parsing
and generating natural language, SNePSLOG, a predicate-logic-style
interface to SNePS, XGinseng, an X-based graphics interface for
displaying, creating and editing SNePS networks, SNACTor, a
preliminary version of the SNePS Acting component, and SNIP 2.2, a new
implementation of the SNePS Inference Package that uses rule shadowing
and knowledge migration to speed up inference. SNeRE (the SNePS
Rational Engine), which is part of Deepak Kumar's dissertation about
the integration of inference and acting, will replace the current
implementation of SNACTor. SNePS is written in Common Lisp, and has
been tested in Allegro CL 4.1, Lucid CL 4.0, TI Common Lisp, CLISP
May-93, and CMU CL 17b. It should also run in Symbolics CL, AKCL 1.600
and higher, VAX Common Lisp, and MCL. The XGinseng interface is built
on top of Garnet. SNePS 2.1 is free according to the GNU General
Public License version 2. The SNePS distribution is available by
anonymous ftp from
ftp.cs.buffalo.edu:/pub/sneps/ [128.205.32.9]
as the file rel-x-yyy.tar.Z, where 'x-yyy' is the version. The other
files in the directory are included in the distribution; they are
duplicated to let you get them without unpacking the full distribution
if you just want the bibliography or manual. If you use SNePS, please
send a short message to [email protected] and
[email protected]. Please also let them know whether you'd like to
be added to the SNUG (SNePS Users Group) mailing list.
COLAB (COmpilation LABoratory) is a hybrid knowledge representation
system emphasizing the horizontal and vertical compilation of
knowledge bases. It is comprised of cooperating subsystems -- CONTAX,
FORWARD, RELFUN and TAXON -- which deal with different knowledge
representation and reasoning formalisms. Each subsystem can also be
used as stand-alone system. CONTAX deals with constraint nets and
constraint-propagation techniques. Relational knowledge in the form of
Horn rules is processed by forward (FORWARD) and backward (RELFUN)
chaining. Taxonomic knowledge is represented by intensional concept
definitions which are automatically arranged in a subsumption
hierarchy (TAXON). The COLAB software was developed at DFKI and the
University of Kaiserslautern and runs in Common Lisp. (The subsystems
have been tested in AKCL and Lucid CL, and possibly also Allegro CL
and Symbolics CL.) All the subsystems are available free of charge for
research purposes.
o RELFUN is a logic-programming language with call-by-value (eager),
non-deterministic, non-ground functions, and higher-order operations.
It accepts freely interchangeable LISP-style and PROLOG-style syntaxes.
For sources to RELFUN and copies of relevant papers, contact
Dr. Harold Boley, DFKI, Postfach 2080, W-6750 Kaiserslautern, Germany,
call +49-631-205-3459, fax +49-631-205-3210, or send email to
[email protected].
o TAXON is a terminological knowledge representation system extended by
concrete domains. For sources to TAXON and copies of relevant papers,
contact Philipp Hanschke, DFKI, Postfach 2080, W-6750 Kaiserslautern,
Germany, call +49-631-205-3460, fax +49-631-205-3210, or send email to
[email protected].
o CONTAX is a constraint system for weighted constraints over
hierarchically structured finite domains. CONTAX uses CLOS in addition
to Common Lisp. For sources to CONTAX and copies of relevant papers,
contact Manfred Meyer, DFKI, Postfach 2080, W-6750 Kaiserslautern,
Germany, call +49-631-205-3468, fax +49-631-205-3210, or send email to
[email protected].
o FORWARD is a logic programming language with bottom-up and top-down
evaluation of Horn clauses. For sources to FORWARD and copies of
relevant papers, contact Knut Hinkelmann, DFKI, Postfach 2080, W-6750
Kaiserslautern, Germany, call +49-631-205-3467, fax +49-631-205-3210,
or send email to [email protected].
URANUS is a logic-based knowledge representation language. Uranus is
an extension of Prolog written in Common Lisp and using the syntax of
Lisp. Uranus extends Prolog with a multiple world mechanism for
knowledge representation and term descriptions to provide
functional programming within the framework of logic programming.
It is available free by anonymous ftp from
etlport.etl.go.jp:/pub/uranus/ftp/ [192.31.197.99]
for research purposes only. For more information contact the author,
Hideyuki Nakashima <[email protected]>.
Languages and Alternate Syntaxes:
Generalized Lisp (or Glisp for short) is a coordinated set of high
level syntaxes for Common Lisp. Initially GLisp consists of three
dialects: Mlisp, Plisp and ordinary Lisp, together with an extensible
framework for adding others. Mlisp (Meta-Lisp) is an Algol-like
syntax for people who don't like writing parentheses. For example,
one can write print("abc", stream) instead of (print "abc" stream).
Plisp (Pattern Lisp) is a pattern matching rewrite-rule language.
Plisp is a compiler-compiler; its rules are optimized for writing
language translators. All dialects may be freely intermixed in a
file. The translators for all dialects are written in Plisp, as is
the Glisp translator framework itself. Support routines for the
translators are written in Mlisp and/or Lisp. All dialects are
translated to Common Lisp and execute in the standard Common Lisp
environment. Glisp is available by anonymous ftp from apple.com or
ftp.apple.com:/dts/mac/lisp/glisp.tar.Z
GLISP runs in MCL and has to be modified for other Common Lisp
implementations.
CGOL is algol-like language that is translated into Lisp before
execution. It was developed originally by Vaughn Pratt. A Common Lisp
implementation of CGOL is available by anonymous ftp from
peoplesparc.berkeley.edu:/pub/cgol.1.tar.Z [128.32.131.14]
(The number "1" may increase if newer versions are posted.) It was
written by a UC Berkeley graduate student, Tom Phelps, as a term
project, so there may still be some rough edges. There is a lot of
documentation in the distribution, including the "original" CGOL memo
(pratt.memo). For more information, contact Richard Fateman
<[email protected]>.
StarLisp Simulator. The StarLisp Simulator simulates *Lisp, one of
the programming langauges used to program the Connection Machine.
StarLisp runs under Symbolics, Lucid, Allegro, and Franz, and is
available by anonymous ftp from
think.com:/cm/starlisp/starsim-f19-sharfile
The "CM5 *Lisp Tutorial" is available by anonymous ftp from
arp.anu.edu.au:/ARP/papers/starlisp/ [150.203.20.2]
in Andrew "ez" and postscript formats. Write to Zdzislaw Meglicki
<[email protected]> for more information about the tutorial.
InterLisp->Common-Lisp Translator -- ftp.ai.sri.com:/pub/pkarp/lisp/ilisp/
Other InterLisp to Common Lisp translators may be found in the LispUsers
archive listed above.
The Yale Haskell system runs in CMU Common Lisp, Lucid CL, and AKCL.
It is available by anonymous ftp from
Chalmers animal.cs.chalmers.se:/pub/haskell/yale/ [129.16.225.66]
Glasgow ftp.dcs.glasgow.ac.uk:/pub/haskell/yale/ [130.209.240.50]
Yale nebula.cs.yale.edu:/pub/haskell/yale/ [128.36.13.1]
as the files
haskell-beta-2-source.tar.Z -- full sources
haskell-beta-2-sparc.tar.Z -- sparc executable
Lisp Tools:
See the Common Lisp Repository in [6-2].
The Automatic Memoization Facility adds a practical memoization
facility to Common Lisp. Automatic memoization is a technique by which
an existing function can be transformed into one that "remembers"
previous arguments and their associated results, yielding large
performance gains for certain types of applications. This facility
extends the ideas from Norvig's book into what is needed for a
practical tool for us in large programs. It adds facilities for
bookkeeping and timing, and lets you evaluate of the timing advantages
of memoization, and save hash tables to disk for automatic reuse in
later sessions. The code is available by anonymous ftp from
archive.cs.umbc.edu:/pub/Memoization [130.85.100.53]. Contact Marty Hall
<[email protected]> for more information. The code includes an
overview of memoization and its applications.
PLisp - A Common Lisp front end to Postscript. This translates many
Common Lisp functions to postscript as well as manage the environment
and many lispisms (&optional and &rest arguments, multiple values,
macros, ...). Available via anonymous ftp
nebula.cs.yale.edu:/pub/plisp/plisp.tar.Z [128.36.13.1]
Written by John Peterson <[email protected]>.
RegExp is an extension to Allegro Common Lisp which adds
regular expression string matching, using the foreign
function interface. Available by anonymous ftp from
ftp.ai.sri.com:/pub/pkarp/regexp/. Contact [email protected]
for more information.
ifi.informatik.uni-stuttgart.de:/pub/xit/cl-utilities/ contains
three small utilities:
completion.lisp A simple filename completion program.
cl-utilities.lisp Some macros for dealing with points,
regions, and some miscellaneous macros.
copy-objects.lisp Code for copying instances.
think.com:/think/lisp contains some useful lisp code (most of it
Symbolics dependent) including:
lisp-lint.lisp A set of compiler style checkers that
warn when a function call does not
conform to Common Lisp.
MEASURES is a system to handle engineering numbers and measures in
Common Lisp. It runs in Allegro CL, LispWorks, MCL, and Symbolics CL.
Written by Roman Cunis. Some documentation can be found in the file
measures.doc and examples in measures-example.lisp. It is available
from the Common Lisp Repository
ftp.cs.cmu.edu:/user/ai/lang/lisp/lisp/syntax/
in the file measures-2.0.tar.gz. For further information, contact Ralf
Moeller, University of Hamburg, Bodenstedtstr 16, 2000 Hamburg 50,
Germany, call 40-4123-6134, fax 40-4123-6530, or send email to
[email protected].
DEFTABLE provides a macro that unifies the interface to Common
Lisp's table-like data structures (e.g., association lists, property
lists, and hash tables). Written by Peter Norvig
<[email protected]>. It is available by anonymous ftp from
ftp.ai.mit.edu:/pub/lptrs/deftable.lisp [128.52.32.6] and also the
Lisp Utilities Repository. An article describing deftable was
published in ACM Lisp Pointers 5(4):32-38, December 1992.
SEQUEL (SEQUEnt processing Language) is designed both as a general
purpose AI language for generating type-secure and efficient Lisp
programs and as a very high level specification language for
implementing logics on the computer. Designed at the University of
Leeds, SEQUEL compiles sequent-calculus specifications of arbitrary
logics to working proof assistants. The sequent calculus
specifications are compiled into Horn clauses and from Horn clauses
into virtual machine instructions of an abstract machine SLAM (SequeL
Abstract Machine) which then translates these instructions into
efficient Lisp code using WAM-style compilation techniques. Although
a functional programming language, SEQUEL includes facilities for
backtracking usually associated with logic programming, and supports a
pattern-matching method of building functions based on Prolog
notation. The Lisp code generated from SEQUEL functions is completely
portable and runs in most Common Lisp implementations. It is
comparable in efficiency with hand-written code. SEQUEL also supports
optional static type-checking in the manner of SML and similar
languages. With type-checking enabled, all inputs and loaded files
are type-checked and the resulting Lisp programs are type-secure. The
SEQUEL compiler uses the information gleaned from type-checking to add
compiler directives within the generated Lisp functions to produce
optimized Lisp programs. SEQUEL includes a UNIX-style top level with
its own trace package and type-checking debugger. SEQUEL is also of
interest to automated reasoning researchers. It provides a very
powerful means of generating proof assistants and theorem provers that
have a very fast performance using WAM-derived compilation techniques.
The theorem provers are automatically verified. It includes a facility
for Datalog and an efficient occurs-check Horn-clause-to-Lisp
compiler, a mouse driven graphical interface for all proof assistants
and theorem provers built under SEQUEL (currently available only under
Lucid). Several demonstration theorem provers for different logics,
including FOL, Clarke's logic of space, partial evaluation, set
theory, and constructive type theory are available. SEQUEL runs under
Kyoto CL, Lucid CL, and CMU Common Lisp. SEQUEL is available free for
non-commercial purposes by anonymous ftp from
agora.leeds.ac.uk:/scs/logic/ [129.11.144.130]
and includes LaTeX documentation in the distribution. For more
information, contact Mark Tarver <[email protected]> or
<[email protected]>.
ILU (Xerox PARC Inter-Language Unification) is a system for promoting
language interoperability via interfaces between units of program
structure called "modules". ILU currently supports Common Lisp, ANSI
C, C++, and Modula-3. The Common Lisp support provides CLOS `network
objects' that communicate via RPC between Lisp processes, as well
between Lisp and other languages. ILU is available by anonymous ftp
from
parcftp.parc.xerox.com:/pub/ilu/1.6.4/ilu-1.6.4.tar.gz
Write to Bill Janssen <[email protected]> for more information.
Machine Learning:
ID3: A Lisp implementation of ID3 and other machine learning
algorithms are available by anonymous ftp from the machine learning
group at the University of Texas as cs.utexas.edu:/pub/mooney
COBWEB/3 is a concept formation system available free after
signing a license agreement. Contact [email protected]
for more information.
RWM (Refinement With Macros) is a Common Lisp program for learning
problem solving strategies. RWM takes a high level description of a
problem as input and successively refines it into a sequence of
"easier" subproblems, which collectively constitute a strategy for
solving the given problem. RWM also learns macro moves which are
useful for efficiently solving the problem. A short documentation and
some example problems/strategies are included. To get a copy of this
description, send mail to the Bilkent University Archieve Server
[email protected] with "send RWM.tar.Z" in the body of the
message. For further information, contact H. Altay Guvenir
<[email protected]>.
Mathematics:
MockMma -- peoplesparc.berkeley.edu:/pub/mma.tar.Z [128.32.131.14]
A Mathematica-style parser written in Common Lisp. Written by Richard
Fateman; [email protected]. Runs in any valid Common Lisp.
Tested in Allegro, KCL and Lucid.
rascal.ics.utexas.edu:/pub/ 128.83.138.20
Maxima for Common Lisp (License required from National
Energy Software Center at Argonne.) Ported by Bill Schelter.
QUAIL (Quantitative Analysis in Lisp) extends Common Lisp to better
support quantitative analysis. It includes an object-oriented
quantitative analysis programming environment based on CLOS. Quail
was developed by the Statistical Computing Laboratory of the
Department of Statistics and Actuarial Science of the University of
Waterloo. It includes a variety of mathematical and statistical
capabilities, such as symbolic and numerical differentiation,
numerical integration, probability calculations (e.g., pseudo-random
number generation), and statistical response models. The
object-oriented graphics display facilities include building blocks
for arbitrary graphics, a collection of stock statistical graphics,
function plotting, 3d-rotating function and surface plots, and
graphical browsers. Quail currently runs in MCL, but a Franz and CLX
based version is forthcoming. It is available by anonymous ftp from
setosa.uwaterloo.ca:/pub/Quail/ [129.97.141.101]
You must read the file README-I-MEAN-IT and return a signed copy of
the license agreement ($10 annual license fee) before using the
software. For further information, contact Dr. R. W. Oldford,
<[email protected]> or <[email protected]>.
Medical Reasoning:
TMYCIN -- sumex-aim.stanford.edu:/tmycin The TMYCIN rule based system.
Music:
Common Music is a music composition language written in Common Lisp
and CLOS that outputs music (directly or through scorefiles) to a
variety of synthesis packages, such as the Music Kit, Common Lisp
Music, MIDI, and CSound. Common Music runs under MCL 2.0, Allegro CL
3.1.2 (NeXT), AKCL 1.615 (NeXT), Allegro CL 4.1 beta (SGI Iris), and
AKCL 6.15 (Sun4). It is available by anonymous ftp from
ccrma-ftp.stanford.edu:/pub/Lisp/cm.tar.Z [36.49.0.93]
ftp.zkm.de:/pub/cm.tar.Z [192.101.28.17]
To be added to the mailing list, send mail to
[email protected]. For further information, contact
Rick Taube, <[email protected]> or <[email protected]>.
[Note: In the Common Music sources, there is a generic portable Lisp
Listener style interpreter that supports command dispatching in
addition to Lisp evaluation. It is the file ./utils/tl.lisp.]
Common Lisp Music (CLM) is a software synthesis and signal
processing package (CL-MUSIC) and a package that makes it relatively
easy to take advantage of the Motorola DSP 56000 (CL-MUSIC-56). It is
available by anonymous ftp from
ccrma-ftp.stanford.edu:/pub/Lisp/clm.tar.Z [36.49.0.93]
Basic documentation is in clm.wn (or clm.rtf) and
ins.lisp. CLM runs on NeXT under Allegro CL or KCL and on SGI Indigo
under Allegro CL. The non-56000 version should run on any machine with
C and Common Lisp. Send bug reports or suggestions to
Bil Schottstaedt <[email protected]>.
Common Music Notation (CMN) is a western music notation package based on
Common Lisp, CLOS (pcl), PostScript, and the Adobe Sonata font. It is
available by anonymous ftp from
ccrma-ftp.stanford.edu:/pub/Lisp/cmn.tar.Z [36.49.0.93]
To be added to the mailing list (same list as for Common Music),
send mail to [email protected]. Please send bug
reports and suggestions to Bil Schottstaedt <[email protected]>.
Natural Language Processing:
The Xerox part-of-speech tagger is available by anonymous ftp from
parcftp.xerox.com:/pub/tagger/tagger-1-0.tar.Z. It is implemented in
Common Lisp and has been tested in Allegro CL 4.1, CMU CL 17e, and
Macintosh CL 2.0p2. For more information, contact the authors, Jan Pedersen
<[email protected]> and Doug Cutting <[email protected]>.
Natural Language Generation:
FUF is a natural language generation system based on Functional
Unification Grammars implemented in Common Lisp. It includes a
unifier, a large grammar of English (surge), a user manual and many
examples. FUF is available by anonymous ftp from
cs.columbia.edu:/pub/fuf/
black.bgu.ac.il:/pub/fuf/
as the files fuf5.2.tar.Z and surge.tar.Z. For further information,
contact the author, Michael Elhadad <[email protected]>.
[A WAM-based C compiler for FUF is in the works.]
Neural Networks:
ANSIL -- nervous.cis.ohio-state.edu:/pub/lispusers/ansil/
"Advanced Network Simulator in Lisp"
email: [email protected]
Object-Oriented Programming:
PCL -- parcftp.xerox.com:/pcl/ [13.1.64.94]
Portable Common Loops (PCL) is a portable implementation of
the Common Lisp Object System (CLOS). A miniature CLOS
implementation called Closette is available pcl/mop/closette.lisp.
CLOS-on-KEE -- zaphod.lanl.gov:/pub/
A subset of CLOS that is implemented on top of KEE. Contact
egdorf%[email protected] (Skip Egdorf) for more info.
MCS (Meta Class System) -- ftp.gmd.de:/lang/lisp/mcs/ [129.26.8.84]
Portable object-oriented extension to Common Lisp. Integrates the
functionality of CLOS (the Common Lisp Object System), and TELOS, (the
object system of LeLisp Version 16 and EuLisp). MCS provides a metaobject
protocol which the user can specialize. Runs in any valid Common Lisp.
Contact: Harry Bretthauer and Juergen Kopp, German National Research
Center for Computer Science (GMD), AI Research Division,
P.O. Box 1316, D-5205 Sankt Augustin 1, FRG, email: [email protected]
CommonORBIT (also called CORBIT) is an object-oriented extension of
Common Lisp. It uses a prototype (classless) model of OOP, is easy to
use and yet has many sophisticated features found also in KL-ONE type
languages. CommonORBIT is a Common Lisp reimplementation of ORBIT,
which was originally conceived by Luc Steels around 1981-1983.
Because of its delegation-based rather than class-based inheritance,
CommonORBIT offers extreme flexibility to define and change
practically anything at run-time. Because of the generic functions,
it fits well into regular Lisp code. It can co-exist with CLOS but
remains completely separate. The source code of CommonORBIT is in the
public domain and available by anonymous ftp from the Lisp
Utilities Repository,
ftp.cs.cmu.edu:/user/ai/lang/lisp/
in the oop/non-clos/corbit/ subdirectory as the file corbit.tar.gz.
Documentation is available as the files corbit.msword.hqx, corbit.ps
or corbit.text. A stripped-down version of CORBIT, known as BOOPS
(Beginner's Object-Oriented Programming System), is also available
from the repository as boops.tar.Z. For further information,
contact the author, Koenraad de Smedt <[email protected]>.
Parser Generators:
Mark Johnson <[email protected]> has written a LALR parser generator
for Common Lisp. It is fairly small (about 500 lines of code) and
can be found in the Common Lisp Repository above.
IPG (Incremental Parser Generator) is available by email from
Jan Rekers <[email protected]>. It is an appendix to his thesis. It is
written in LeLisp, but should be portable to other Lisp dialects.
Zebu 2.8.5 is a parser generator for Common Lisp by Joachim H. Laubsch
<[email protected]>. It is an extention written in Common
Lisp of the Scheme version. It generates a LALR(1) parsing table. To
parse a string with a grammar, only this table and a driver need to be
loaded. The present version of Zebu contains the ability to define
several grammars and parsers simultaneously, a declarative framework
for specifying the semantics, as well as efficiency related
improvements. The current version compiles a grammar with 300
productions (including dumping of the tables to disk) in approx 2
minutes and 30 seconds on a HP 9000/370. This implimentation has been
tested in Lucid CL, Allegro CL, and MCL 2.0b. The current version
can also produce a generator in addition to a parser. A copy may be
found on cambridge.apple.com:/pub/mcl2/contrib/zebu-2.2.tar.Z.
Probabilistic Reasoning and Statistics:
BELIEF is a Common Lisp implementation of the Dempster and Kong fusion
and propagation algorithm for Graphical Belief Function Models and the
Lauritzen and Spiegelhalter algorithm for Graphical Probabilistic
Models. It includes code for manipulating graphical belief models such
as Bayes Nets and Relevance Diagrams (a subset of Influence Diagrams)
using both belief functions and probabilities as basic representations
of uncertainty. It is available by anonymous ftp from
ftp.stat.washington.edu [128.95.17.34]
and by email from the author, Russell Almond <[email protected]>.
Contact the author at [email protected] for information about a
commercial version GRAPHICAL-BELIEF currently in the prototype stages.
XLISP-STAT is an extensible statistics package which runs in XLISP.
It has recently been ported to Common Lisp, and is available as
umnstat.stat.umn.edu:/pub/xlispstat/CL/CLS1.0A1.tar.Z [128.101.51.1]
The CL port does not yet include the lisp-stat dynamic graphics
package, only the numerics. The XLisp version is available from
the above site and several mirror sites, such as mac.archive.umich.edu,
and runs on the Apple Macintosh, Unix systems running X11
(Vax, PMAX, Sun3, Encore Multimax, and Cray XMP), Sun workstations
running SunView, and the Commodore Amiga. An experimental version
for DOS computers running Microsoft Windows 3.0 is also available.
Documentation is available online, in the tutorial introduction
pub/xlispstat/xlispstat.doc.tar.Z and also in the book
Luke Tierney, "Lisp-Stat: An Object Oriented Environment for Statistical
Computing and Dynamic Graphics", Wiley, 1990, 397 pages.
ISBN 0-471-50916-7.
For more information, write to Lisp-Stat Information, School of
Statistics, 270 Vincent Hall, University of Minnesota, Minneapolis, MN
55455, or send e-mail to [email protected].
CLASP (Common Lisp Analytical Statistics Package) provides the basic
functionality of a statistics package. It is implemented on top of
CLOS and CLIM on a variety of platforms, and uses BBN's SciGraph
package for plotting. The CLIM interface includes a "notebook" that is
both a "desktop" for icons and a Lisp interactor pane. The Common
Lisp Instrumentation Package (CLIP) is available along with CLASP.
CLIP is designed to allow AI system developers andevaluators a
portable way to define and manage "alligator clips" for instrumenting
their programs. CLIP produces data about program behavior in CLASP
format, as well as other commonly used data formats. It currently has
facilities to support experiment design, such as scenario scripting
and factorial combination of independent variables, and can collect
data in summary form (at the end of each trial) or based upon the
occurrence of specific events (both periodic and non-periodic). CLASP
is available by anonymous ftp from
ftp.cs.umass.edu:/pub/eksl/clasp/
and CLIP is in the directory
ftp.cs.umass.edu:/pub/eksl/clip/
A tutorial on CLASP can be found in
ftp.cs.umass.edu:/pub/eksl/clasp-tutorial/
Bugs should be reported to [email protected]. For more
information, contact Dave Hart <[email protected]>.
IDEAL is a LISP system developed for building and evaluating influence
diagrams and Bayesian networks. It is accompanied with a graphical
user interface (CLIM-based) for constructing, editing, and solving
belief networks and influence diagrams. For more information, write
to [email protected].
Planning:
NONLIN -- cs.umd.edu:/pub/nonlin (128.8.128.8)
Common Lisp implementation of the NONLIN planning system originally
designed and implemented by Austin Tate. Bugs can be reported to
[email protected]. User's group is [email protected].
The authors request that anybody ftping the code send a message to
[email protected], letting them know you have a copy
and also letting them know if you wish to subscribe to the users group.
More information can also be obtained from Jim Hendler, [email protected].
ABTWEAK is a complete hierarchical, non-linear planner that extends
David Chapman's (MIT 1986) TWEAK planner as described by
Yang (Waterloo) and Tenenberg (Rochester) in 1989. This implementation
includes a complete search strategy suited to abstraction hierarchies
known as LEFT-WEDGE (Woods 1991). This planner and related work
predates that of SNLP. ABTWEAK is available by anonymous ftp from
logos.uwaterloo.ca:/pub/abtweak/Abtweak.tar.Z
For more information, send mail to Qiang Yang <[email protected]>.
Also, source, all related papers, and manuals are available via WWW
at the home page of Steve Woods <[email protected]>,
on URL http://logos.uwaterloo.ca/students/sgwoods/sgwoods.html, or via the
Logic Programming and Artificial Intelligence Group (LPAIG) page
on URL http://logos.uwaterloo.ca/.
RHETORICAL is a planning and knowledge tool available by
anonymous ftp from ftp.cs.rochester.edu:/pub/packages/knowledge-tools
in the files rhet-19-40.tar.Z and cl-lib-3-11.tar.Z. The files
tempos-3-6.tar.Z and timelogic-5-0.tar.Z add James Allen's
interval logic to Rhet. It runs on Symbolics Genera and
Allegro Common Lisp. Written by Brad Miller <[email protected]>.
PRODIGY is an integrated planning and learning system,
available free after signing a license agreement. Contact
[email protected] for more information.
SOAR is an integrated intelligent agent architecture currently
being developed at Carnegie Mellon University, the University of
Michigan, and the Information Sciences Institute of the University of
Southern California. SOAR, and its companion systems, CParaOPS5 and
TAQL, have been placed in the public domain. The system may be
retrieved by anonymous ftp to ftp.cs.cmu.edu (or any other CMU CS
machine) in the directory /afs/cs.cmu.edu/project/soar/5.2/2/public/.
[Note: You must cd to this directory in one atomic operation, as
superior directories may be protected during an anonymous ftp.] For
more information, send email to [email protected] or write to
The Soar Group, School of Computer Science, Carnegie Mellon
University, Pittsburgh, PA 15213. Finally, though the software is in
the public domain, the manual remains under copyright. To obtain one
(at no charge) send a request (including your physical mail address)
to [email protected] or to the physical address above.
A simple route planning agent implemented in Soar6 is available by
anonymous ftp from
earth.med.ohio-state.edu:/pub/IEEE-Soar-code/route-planning.soar6.
This is the complete code for the agent described in the IEEE Expert
article: Smith, J. W. and Johnson, T. R., "A stratified approach to
specifying, designing, and building knowledge systems", IEEE Expert,
8(3):15-25, 1993.
SNLP is a domain independent systematic nonlinear planner,
available by anonymous ftp from cs.washington.edu:/pub/snlp.tar.Z
Contact [email protected] for more information.
IDM is a Common Lisp implementation of both a classical and extended
version of the STRIPS planner. It is available by anonymous ftp from
sauquoit.gsfc.nasa.gov (128.183.101.29). Questions, comments and bug
reports may be sent to [email protected].
Planning Testbeds:
TILEWORLD is a planning testbed/simulator developed at SRI
International by Martha Pollack, Michael Frank and Marc
Ringuette. TILEWORLD originally ran under Lucid CL, but was
later extended and ported to Allegro CL by Badr H. Al-Badr
and Steve Hanks. The new tileworld is available by anonymous
ftp from cs.washington.edu as the file new-tileworld.tar.Z
It includes an X interface. Contact [email protected] for more
information.
TRUCKWORLD is a simulated world intended to provide a
testbed for AI planning programs, where the planning agent
is a truck with arms that roams around the simulated world. It is
available by anonymous ftp from
cs.washington.edu:/pub/ai/truckworld.tar.Z
It includes an X interface. Contact Steve Hanks <[email protected]>
for more information. Send mail to
[email protected]
to be added to the mailing list.
ARS MAGNA is a simulated world intended for use as a testbed for
planning and mapping programs. The simulated agent is a robot in an
indoors environment. High-level sensing and action are provided,
realistically modelled on current vision and robotics research. It is
written in Nisp, a macro package running on top of Common Lisp. It is
available by anonymous ftp from
dept.cs.yale.edu:/pub/nisp/
as file ars-magna.tar.Z. It includes an X display. Contact Sean Engelson
<[email protected]> for more information.
Qualitative Reasoning:
QSIM is a qualitative reasoning system implemented in Common
Lisp. It is available by anonymous ftp from cs.utexas.edu:/pub/qsim
Contact Ben Kuipers <[email protected]> for more information.
QPE is the Qualitative Process Engine, an envisioner for QP theory.
QPE is publically available from multivac.ils.nwu.edu:/pub/QPE
Maintained by Ken Forbus <[email protected]>.
Theorem Proving:
MVL (Multi-Valued Logic) is a theorem proving system written in Common
Lisp. MVL is a bilattice-based reasoning system. By changing the
bilattice, you can use MVL to do truth maintenance, nonmonotonic
reasoning, first-order reasoning, and a variety of other reasoning
strategies. MVL is available by anonymous ftp from
t.uoregon.edu:/mvl/mvl.tar.Z [128.223.56.46]
as mvl.tar.Z. A user's manual may be found in the file manual.tex. For
more information, contact Matthew L. Ginsberg, <[email protected]>
or <[email protected]>. Matthew asks that you send him an email
message if you retrieve the system by anonymous ftp.
Boyer-Moore
ftp.cli.com:/pub/nqthm/nqthm.tar.Z Contact: [email protected]
rascal.ics.utexas.edu:/pub/ 128.83.138.20
nqthm/ Boyer and Moore's theorem prover.
Also available from ftp.cli.com:/pub/nqthm.
proof-checker/ Matt Kaufmann's proof checking
enhancements to nqthm.
The mailing list [email protected] is for users of the
Boyer-Moore theorem-prover, NQTHM.
DTP is a general first-order theorem prover incorporating intelligent
backtracking and subgoal caching, as well as a trace facility that can
display proof spaces graphically. Implemented in CLtL2 Common Lisp, it runs
in Franz Allegro, Lucid, and Macintosh (MCL) Common Lisp. DTP is available
on the Web at
http://logic.stanford.edu/dtp/
or by anonymous ftp from
meta.stanford.edu:/pub/dtp/ [36.8.0.54]
Contact Don Geddis <[email protected]> for more information.
RRL (Rewrite Rule Laboratory) -- herky.cs.uiowa.edu:/public/rrl
[128.255.28.100]
FRAPPS (Framework for Resolution-based Automated Proof Procedures) is
a portable resolution theorem-prover written in Common Lisp. It is
available via anonymous ftp from a.cs.uiuc.edu:/pub/frapps [128.174.252.1].
If you take a copy of FRAPPS, please send a short note to Prof.
Alan M. Frisch <[email protected]>.
Truth Maintenance:
The truth maintenance system and problem solver implementations
described in the book "Building Problem Solvers" by Ken Forbus and
Johan de Kleer are available by anonymous ftp from
parcftp.xerox.com:/pub/bps/. Includes a constraint propagation
system similar to Steele's Constraints system, among other things.
For more information send mail to Johan de Kleer <[email protected]>.
Virtual Reality:
VEOS (Virtual Environment Operating Shell) is an extendible environment
for prototyping distributed applications for Unix. The programmer's
interface uses XLISP 2.1. Although intended for distributed
Virtual Reality applications at The Human Interface Technology Lab
in Seattle, it should be appropriate for other applications. VEOS
uses heavyweight sequential processes, corresponding roughly to
unix processes. VEOS runs on DEC/5000, Sun4, and Silicon Graphics
VGX and Indigo. VEOS is available by anonymous ftp from
milton.u.washington.edu:/public/veos/ [128.95.136.1]
as veos.tar.Z. If you use the software, the authors ask that you send
them mail to [email protected].
Vision:
OBVIUS -- white.stanford.edu:/obvius/ [36.121.0.16]
whitechapel.media.mit.edu:/obvius/ [18.85.0.125]
Object-Based Vision and Image Understanding System (OBVIUS), is a Common
Lisp image processing package. Provides a library of image processing
routines (e.g., convolutions, fourier transforms, statistical
computations, etc.) on gray or binary images and image-sequences (no
color support yet), an X windows display interface, postscript printer
output, etc. It uses a homebrew interface to X11 (i.e., it does not use
clx or clue). However, they eventually hope to port Obvius to a clx/clue
platform. Written by David Heeger <[email protected]> and Eero
Simoncelli <[email protected]>. Runs in Lucid-4.0. Includes
LaTeX documentation and User's Guide.
Miscellaneous:
ftp.csrl.aoyama.ac.jp:/YY/ YY window toolkit sources
ftp.csrl.aoyama.ac.jp:/lispsrc/ Common Lisp programs, including MIT's FRL.
----------------------------------------------------------------
Subject: [6-6] Formatting code in LaTeX (WEB and other literate
programming tools)
SLaTeX is a R4RS-compliant Scheme program that allows you to write
program code "as is" in your LaTeX or TeX source. It is particularly
geared to the programming languages Scheme and Common Lisp, and has
been tested in Chez Scheme, Common Lisp, MIT C Scheme, Elk, Scheme->C,
SCM and UMB Scheme on Unix; and MIT C Scheme and SCM on MSDOS. The
formatting of the code includes assigning appropriate fonts to the
various tokens in the code (keywords, variables, constants, data), at
the same time retaining the proper indentation when going to the
non-monospace (non-typewriter) provided by TeX. SLaTeX comes with two
databases that recognize the standard keywords/variables/constants of
Scheme and Common Lisp respectively. These can be modified by the
user using easy TeX commands. In addition, the user can inform SLaTeX
to typeset arbitrary identifiers as specially suited TeX expressions
(i.e., beyond just fonting them). The code-typesetting program SLaTeX
is available by anonymous ftp from
cs.rice.edu:/public/dorai/slatex23.tar.gz
Send bug reports to [email protected].
SchemeWEB provides simple support for literate programming in Lisp.
SchemeWEB version 2.0 is a Unix filter that allows you to generate
both Lisp and LaTeX code from one source file. The generated LaTeX
code formats Lisp programs in typewriter font obeying the spacing in
the source file. Comments can include arbitrary LaTeX commands.
SchemeWEB was originally developed for the Scheme dialect of Lisp, but
it can easily be used with most other dialects. Version 2.0 is
available in the Scheme Repository as
cs.indiana.edu:/pub/scheme-repository/new/schemeweb.sh
or in the Comprehensive TeX Archive Network (CTAN) in the directory
ftp.shsu.edu:/tex-archive/web/schemeweb
LiSP2TeX is a system that allows easy insertions of Scheme, or Lisp,
code towards TeX files. The originality of LiSP2TeX is that it
extracts Scheme definitions from the files where they appear and wraps
them appropriately within TeX macros for insertion into the
documentation file. LiSP2TeX decorrelates writing documentation from
programming: it is therefore possible to separately develop programs
and documentations and to merge them at the end to produce up to date
final documents. LiSP2TeX also has some pretty-printing capabilities
to produce denotations full of greek letters. It is available by
anonymous ftp from ftp.inria.fr:/INRIA/Projects/icsla/.
See also ftp.cs.cmu.edu:/user/ai/lang/lisp/code/tools/user_man/.
The Literate Programming FAQ lists a number of alternatives, both
language-independent and Lisp-specific. The Literate Programming FAQ
is posted once a quarter to the comp.literate.programming newsgroup
and is available by anonymous ftp from rtfm.mit.edu. A copy may also be
requested by sending an email message to [email protected]
sendme litprog.faq
in the body of the message.
----------------------------------------------------------------
Subject: [6-7] Where can I get an implementation of Prolog in Lisp?
Implementations of Prolog in Lisp:
The Frolic package from the University of Utah is written in Common Lisp
and available by anonymous ftp from cs.utah.edu:/pub/frolic.tar.Z
LM-PROLOG by Ken Kahn and Mats Carlsson is written in ZetaLisp and not
easily portable to Common Lisp. It is available by anonymous ftp from
sics.se:/archive/lm-prolog.tar.Z.
Peter Norvig's book "Paradigms of AI Programming" includes Common Lisp
implementations of a prolog interpreter and compiler. The software is
available by anonymous ftp from unix.sri.com:/pub/norvig/ and on disk in
Macintosh or DOS format from the publisher, Morgan Kaufmann. For more
information, contact: Morgan Kaufmann, Dept. P1, 2929 Campus Drive, Suite
260, San Mateo CA 94403, (800) 745-7323; FAX: (415) 578-0672
Harlequin's LispWorks comes with Common Prolog -- a fast
Edinburgh-compatible Prolog integrated with Common Lisp. Write to:
Harlequin Limited, Barrington Hall, Barrington, Cambridge, CB2 5RG, call
0223 872522 (or 44223 872522 outside UK), telex 818440 harlqn g, fax 0223
872519, or send email to [email protected] (or [email protected] for US people).
eLP (Ergo Lambda Prolog) is an interpreter written by Conal Elliott,
Frank Pfenning and Dale Miller in Common Lisp and implements the core
of lambda Prolog (higher-order hereditary Harrop formulas). It is
embedded in a larger development environment called ESS (the Ergo
Support System). eLP implements all core language feature and offers
a module system, I/O, some facilities for tracing, error handling,
arithmetic, recursive top-levels, on-line documentation and a number
of extended examples, including many programs from Amy Felty's and
John Hannan's thesis. It should run in Allegro Common Lisp, Lucid
Common Lisp, Kyoto Common Lisp, CMU Common Lisp and Ibuki Common Lisp.
The eLP implementation of lambda Prolog is no longer developed or
maintained, but it is still available via anonymous ftp from
ftp.cs.cmu.edu:/afs/cs.cmu.edu/project/ergo/export/ess/. The file
ergolisp.tar.Z contains the Ergo project's extensions to Common Lisp,
including some facilities for attributes and dealing with abstract
syntax trees. The file sb.tar.Z contains the Ergo
Parser/Unparser/Formatter generator and ab.tar.Z contains the Ergo
Attribute Grammar facility. The file elp.tar.Z contains the Ergo
implementation of lambda Prolog. To customize grammars you need the
sb.tar.Z file. When you retrieve the system, please print, fill out,
and send in a copy of the non-restrictive license you will find in the
file LICENSE. To subscribe to the [email protected] mailing list, send
mail to [email protected]. Bugs should be sent to
[email protected].
The book "On Lisp" by Paul Graham includes an implementation of
Prolog in Common Lisp. The code is available by anonymous ftp from
endor.harvard.edu:/pub/onlisp
and also in the CMU AI Repository as
ftp.cs.cmu.edu:/user/ai/lang/lisp/bookcode/graham/
See the Scheme FAQ for information on implementations of Prolog in Scheme.
----------------------------------------------------------------
Subject: [6-8] World-Wide Web (WWW) Resources
The World Wide Web (WWW) is a hypermedia document that spans the
Internet. It uses the http (HyperText Transfer Protocol) for the
light-weight exchange of files over the Internet. NCSA Mosaic is a
World Wide Web browser developed at the National Center for
Supercomputing Applications (NCSA).
Mosaic's popularity derives, in part, from its ability to communicate
using more traditional Internet protocols like FTP, Gopher, WAIS, and
NNTP, in addition to http. Mosaic can display text, hypertext links,
and inlined graphics directly. When Mosaic encounters a file type it
can't handle internally, such as Postscript documents, mpeg movies,
sound files, and JPEG images, it uses an external viewer (or player)
like Ghostscript to handle the file. Mosaic also includes facilities
for exploring the Internet. In other words, Mosaic is an multimedia
interface to the Internet.
The hypertext documents viewed with Mosaic are written in HTML
(HyperText Markup Language), which is a subset of SGML (Standard
Generalized Markup Language). All that is needed is just a few more
improvements, such as the ability to format tables and mathematics,
and a WYSIWYG editor, for HTML to greatly facilitate electronic
journals and other publications.
NCSA Mosaic for the X Window System is available by anonymous ftp from
ftp.ncsa.uiuc.edu:/Mosaic/
as source code and binaries for Sun, SGI, IBM RS/6000, DEC Alpha OSF/1, DEC
Ultrix, and HP-UX. Questions about NCSA Mosaic should be directed to
[email protected] (X-Windows version), [email protected]
(Macintosh), and [email protected] (Microsoft Windows).
A simple HTML version of the Lisp FAQ (this FAQ) is available as
http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/lisp/top.html
Association of Lisp Users:
http://www.cs.rochester.edu/u/miller/alu.html
[Contains links to a lot of Lisp resources, including a history of
Lisp, bibliographies of Lisp books, the Lisp Repository at CMU, and
even some Lisp humor. Very nicely done.]
Contact: Brad Miller <[email protected]>
----------------------------------------------------------------
;;; *EOF*
|
Закладки на сайте Проследить за страницей |
Created 1996-2024 by Maxim Chirkov Добавить, Поддержать, Вебмастеру |