PowerLoom® Documentation
PowerLoom Manual
The PowerLoom manual is still somewhat incomplete, but there should be
enough information to get you started on building PowerLoom knowledge
bases and using its various APIs.
The manual is available in the following formats:
For other formats such as the Emacs info format look in the
sources/logic/doc directory of the PowerLoom release.
Annotated Examples
Below is a set of annotated examples that demonstrate various features
of PowerLoom. These examples are simply HTML-formatted versions of
the output of various demos that can be run from PowerLoom's demo menu
(type (demo) at PowerLoom's command prompt to see the
list of available demos).
All examples are run interactively in the PowerLoom listener (a simple
read/eval/print command interpreter) which uses |= as its
prompt. User input is shown in bold face. The
result of a command evaluation is shown in plain font immediately
following the command input. Note, that not all commands produce
results in which case the result space is empty.
The following examples are quite old and have not yet been updated
to follow the latest PowerLoom conventions. In particular, some of the
annotations refer to an old system state and are no longer correct.
However, they all do work and use correct PowerLoom 3.0 syntax and
are still useful as introductory material.
Tutorial
Overview and tutorial slides are available in PDF format. The overview
slides provide an introduction to logic-based knowledge representation
and PowerLoom, followed by an introduction to PowerLoom and an annotated
example. The slides conclude with a description of some of the advanced
features, including explanation, whynot explanation, units and
dimensions, and timepoint reasoning.
A variant of the overview and tutorial slides that Thomas Russ has used for guest lectures
is also available in PDF
format. This variant has more material tailored to using PowerLoom
from Java, but does not include the information about units, timepoints
or whynot explanation.
The the talk to go along with those slides is available as a Webcast.
PowerLoom and KIF
PowerLoom uses a variant of KIF to express
definitional and assertional content. The sentential component of
this variant is closest in flavor to that of KIF
3.0 . The main difference is that variables in quantified
sentences and terms can be typed. PowerLoom does not have sequence
variables, but it allows the definition of functions and relations
with a variable number of arguments. PowerLoom does not support
quotation via quote, instead, it supports the
representation of sentences that take other sentences as arguments.
Note that KIF is one of the supported syntaxes of the upcoming Common Logic standard.
PowerLoom's definitional language such as its deffunction,
defrelation, etc. commands is somewhat more different from its
counterpart in KIF 3.0. It has similarities with parts of
Ontolingua and is described in more detail in the manual. Future
versions of PowerLoom might have translation frontends to support
knowledge bases and ontologies written in vanilla ANSI KIF, KIF-3.0 or
Ontolingua.
The various KIF Manuals
are useful to familiarize yourself with the basic concepts underlying
KIF, but it is important to keep in mind that they only provide an
approximate picture of legal PowerLoom syntax.
System Requirements and Installation Instructions
PowerLoom is very portable and has been tested on a variety of
hardware and OS platforms. It is available in Common-Lisp, C++ and Java
and has been run successfully under Linux, Sun Solaris, Windows-2000,
MacOS 9 & X. The Lisp and Java versions are available on most OS
platforms, the C++ version has so far only been tested on Unix
platforms that support g++.
See the PowerLoom manual for more detailed system requirements and
installation instructions.
Release Notes
Release notes summarize user-visible
changes for each PowerLoom release and can be found here. More detailed code-level change
documentation can be found in the files
.../sources/powerloom/ChangeLog and
.../sources/stella/ChangeLog that are shipped with each
release.
Code Documentaton
For Java programmers, we also provide documentation of the Java
classes and methods that implement PowerLoom in javadoc format.
Caution: for historic reasons that have to do with
STELLA-to-Java translation, most of those classes and methods are
declared as "public", even though they are not part of the official
PowerLoom or STELLA API. PowerLoom users should only use the public
functions and types defined and used by the PLI interface, since all
other functions might change without notice. In general it is a good
idea to encapsulate calls to PowerLoom API functions to insulate
yourself from necessary changes, even though we try to keep that API
as stable as possible.
These javadoc manuals are available:
- PowerLoom 4.0.2
- PowerLoom 3.2.0
- PowerLoom 3.0.2 beta
Known Bugs
Nobody is perfect. Despite the fact that PowerLoom has been maturing for a
long time and used extensively by us and others, there are still quite a few
known and probably many more unknown bugs and missing features in the system.
Some of them are more serious (or embarassing) than others. Look at the test
suite files in the sources/logic/demos directory for annotations
on which tests are currently failing. Here are a few of the bugs on the top
of our list to fix:
- Negated function proposition assertions such as
(not (= (age fred) 10))
are currently not found by the system.
-
Queries on function propositions with literals such as integers or
strings as their output argument are failing (e.g., (retrieve all (=
(age ?x) 10)).
- Rules with existentials in their consequent can currently only be run in
forward direction. As a work-around one can skolemize them by manually
introducing skolem functions. We are working on having the system do this
automatically.
PowerLoom is a registered trademark of the University of Southern California.
Last modified:
Mar 1, 2016