The Lisa Project



Welcome to the Lisa project, a platform for the development of Lisp-based Intelligent Software Agents. Lisa is a production-rule system implemented in the Common Lisp Object System (CLOS), and is heavily influenced by CLIPS and the Java Expert System Shell (JESS). At its core is a reasoning engine based on an object-oriented implementation of the Rete algorithm, a very efficient mechanism for solving the difficult many-to-many matching problem ("Rete: A Fast Algorithm for the Many Pattern/Many Object Pattern Match Problem", Charles L. Forgy, Artificial Intelligence 19(1982), 17-37.) Intrinsic to Lisa is the ability to reason over CLOS objects without imposing special class hierarchy requirements; thus it should be possible to easily augment existing CLOS applications with reasoning capabilities. As Lisa is an extension to Common Lisp, the full power of the Lisp environment is always available. Lisa-enabled applications should run on any ANSI-compliant Common Lisp platform.

Project Goals

The Lisa project is driven by a number of important goals:

Unrestricted availability : The principal motivation for beginning Lisa was the apparent dearth of lightweight, current, freely-available toolkits for constructing Lisp-based intelligent systems. There are a number of very fine commercial and restricted-use products out there (see the links below), but these systems do not necessarily address the needs of developers attempting to introduce Lisp into their organizations. This is exactly the position I found myself in prior to Lisa. I was leading an applied research project that needed an expert system shell, and if I'd had a modern implementation freely available for Lisp I might have been able to successfully entrench Lisp within the organization. So, I wrote Lisa.

Portability : Vendor neutrality is a significant project goal, not because I disapprove of commercial software but to ensure Lisa is available on as many platforms as I can manage.. As previously mentioned, Lisa is implemented in ANSI Common Lisp; currently, all development is being done on Windows 2000 using Xanalys' LispWorks. Every effort will be made to avoid the use of implementation-specific functionality; in the cases where a non-ANSI feature must be used (e.g. multiprocessing support), Lisa will attempt to support the major Lisp implementations either through conditional evaluation or the use of a common library such as CLOCC.

Familiarity : Lisa's production-rule system has its roots in CLIPS and JESS, making it readily familiar to developers who've worked with either of these systems. Indeed, the CLIPS and JESS languages both have their roots in Lisp.

Flexibility : As previously mentioned, Lisa reasons over CLOS objects without requiring changes to an application's class hierarchy. In addition, the full power of Common Lisp is available for use within productions; there is no dichotomy between Lisa's programming language and her implementation.

Simplicity: Along with portability, the project is striving for simplicity and elegance at the functional, architecture and source code levels. This doesn't mean Lisa should have limited usefulness; rather, it should be possible for new developers to easily understand the code layout and behavior. Unless performance absolutely demands otherwise, clarity of design and implementation will take precedence.

Project People

David E. Young: Presently a knowledge engineer at a small startup in RTP, North Carolina.

Project Status

Release 3.2 is the latest official release. The major addition after version 2.1 is support for Certainty Factors (CF), as described in Peter Norvig's Paradigms of Artificial Intelligence Programming. There's also a simplified install facility based on ASDF, and some major performance improvements.

The first production release for Lisa 2.0, a major rewrite of the system, was available as of 9 December, 2002. The Rete algorithm was re-implemented from scratch; new conditional elements were added; contexts were introduced; and a production rule debugger made available. There were also other features not listed here.

Lisa had its first production release (Version 1.0) on 31 August, 2001 and is considered "stable" software; it should now be possible to develop reasonably sophisticated knowledge bases for "real systems". Lisa has successfully run adaptations of the "monkey and bananas" (MAB) planning problem on all four target Lisp platforms, and full reasoning capabilities are available for CLOS objects in a multi-threaded environment. Release 1.1 offers support for dynamic rule definition, the ability to create new rules from existing rules at runtime; version 1.2 includes a new query facility that allows interactive and programmatic retrieval of CLOS instances from a knowledge base. For the most current information on the project, including mailing lists, latest news and available downloads, see the official project page. If you prefer, you may contact the project staff directly (see Project People).

Supported Platforms

Lisa is known to run on LispWorks, ACL, CLISP, CMUCL (19a), SBCL and OpenMCL. I also know of an individual that has managed to get Lisa running on Armed Bear Common Lisp, a testimony to the quality of that member of the Common Lisp family.

Documentation

Currently, documentation for Lisa is a work-in-progress. However, there is a beta-quality version of the Lisa Reference Guide that should help you get started. Also, you may see the source code for Lisa's two versions of the MAB, mab.lisp and mab-clos.lisp (a "CLOS-ified" version of the default MAB implementation).

License

Lisa is currently released under the GNU Lesser General Public License (LGPL), primarily because it seemed more versatile than the GPL. However, some sources indicate that the LGPL might inhibit commercial uses of Lisp applications like Lisa. I've no idea if this is the case as I'm not a legal expert. So, if you're interested in using Lisa commercially and decide the LGPL gets in the way, feel free to contact me to discuss some other type of license arrangement.

News

8 September, 2007: Release 3.0. This is a major release that offers support for certainty factors, big performance improvements, and some important bug fixes.

21 February, 2006: Release 2.4. This is a minor release that makes Lisa compatible with CLISP 2.38.

5 April, 2005: Release 2.3. This version fixes a serious bug in Lisa’s join network; thanks to Andy Sloane for the patch. There’s also a patch from Fred Gilham that enables auto-notify support for CMUCL.

4 April, 2005: Release 2.1 is out of beta and is the latest stable release.

17 September, 2004: Release 2.1 beta is available, with support for Certainty Factors. Also, Lisa now unofficially once again supports CMUCL. I've had reports that the PCL bugs were fixed as of 19a, and that Lisa is able to run the MAB on that platform.

9 June, 2004: Lisa now uses ASDF as its default system definition facility. The build and load procedure has also been simplified to help new folks get up and running quickly. I also have plans to write a tutorial that will be more useful than the reference guide. Also, note that Lisa officially no longer supports CMUCL. There's apparently a bug in PCL that prevents Lisa from running (or perhaps compiling; I forget). This situation has existed for awhile now, but I'm just getting around to announcing it.

6 June, 2004: Release 2.0.7. Yet another bug-fix release that corrects a problem reported by Aneil Mallavarapu. Lisa was having difficulty keeping the agenda straight when rules were created after facts had been asserted into working memory.

5 March, 2004: Release 2.0.6. This is a bug-fix release that addresses problems with a) Lisa's duplicate fact detection mechanism; and b) the LOGICAL conditional element. Patches for both issues were submitted by Aneil Mallavarapu.

1 November, 2003: Release 2.0.5, a bug-fix release that corrects problems with Lisa’s taxonomic reasoning system. Patches submitted courtesy of Aneil Mallavarapu.

19 December, 2002: Release 2.0.3, a bug-fix release addressing a problem with queries.

10 December, 2002: Release 2.0.1, a bug-fix release for 2.0.

9 December, 2002: The first production release for 2.0 is available. Details are in the release notes.

25 November, 2002: Beta 3 is available. Again, some major enhancements, including Contexts, a new conditional element and duplicate fact detection. Details are in the release notes.

18 November, 2002: Beta 2 is available. Lots of changes and enhancements in this version, including completion of Lisa's truth maintenance system. See the release notes for details.

6 November, 2002: The first beta release for Lisa 2.0, 2.0b1. This version introduces a form of truth maintenance via the LOGICAL conditional element. Details are in the reference guide in the distribution.

4 November, 2002: Alpha release 5 for Lisa 2.0 is now available. This version introduces the OR conditional element, along with some improvements to the debugger. Details are in the reference guide in the distribution.

28 October, 2002: Alpha release 4 for Lisa 2.0 is now available. New to this version is the Lisa debugger, a simple, interactive production rule monitoring/inspection facility. The Reference Guide in the distribution has a chapter explaining how to use it.

Additional items of interest can be found here.

Related Links

This section contains a small collection of topics related to Lisa and its development environment. It will be updated periodically as the need arises. NB: If your favorite Lisp/Environment/Tool was omitted here it was done without prejudice; I simply haven't had time to test Lisa with every mainstream Lisp implementation, or investigate every knowledge representation system, or... you get the idea.













Lisp Development Environments and Libraries Emacs: No comment necessary.

ILisp: A nice, comprehensive Emacs Lisp package that integrates a number of Lisp implementations.

CLOCC: The Common Lisp Open Code Collection.







Commercial and Restricted-Use Knowledge Systems Freely-Available Knowledge Systems Loom, PowerLoom: Semantic networks, ontologies.

KnowledgeWorks: Production-rule system for LispWorks.

JESS: The Java Expert System Shell.

JRules: ILog's production-rule system for Java.

Eclipse, Authorete: The Haley Enterprise's production rule suite. CLIPS: A classic expert system tool.

Screamer: Nondeterministic programming for Lisp.

JLisa: A powerful framework for building business rules accessible to Java.









Credits

The background image for this web site was lifted, with permission, from the Loom project home page.