Algernon is an inference engine that supports both forward and backward chaining rules. It automatically activates forward chaining rules when new data is stored in the knowledge base. It automatically activates backward chaining rules when the knowledge base is queried. If a forward chaining rule contains a step that queries the knowledge base, Algernon will automatically switch to backward chaining mode in order to satisfy the query using any applicable backward chaining rules.
Algernon guarantees that rules will not be activated more than once for each identical assertion or query. The first time a query is made, backward chaining rules will be used to infer the answer. If later an identical query is processed, the result will be looked up in the knowledge base rather than wasting time re-executing rules to infer knowledge that is already in the knowledge base. Algernon correctly handles special cases such as new rules being added between queries, and some situations where frames are deleted after a query is made. However, it does not have full support for non-monotonic reasoning.
For efficiency, rules are assigned to classes or relations. They will only execute when an instance of the corresponding class or relation is modified in the KB. A rule can contain commands that perform KB retrievals, KB assertions, KB class, instance and slot creation commands, and other Algernon operators that print output, retrieve the current date, call external Java or LISP routines, etc.
Rules can be stored in external files or in a knowledge base.
Algernon assumes that it is operating on a frame-based knowledge base. It contains a Protégé backend that directly stores and retrieves information from one or more Protege KBs. Algernon will soon provide a simple in-memory frame-based KB in order to provide a second method of storing KBs.
In addition, with a little work nearly any data source can be made to resemble a read-only frame-based KB. For example, a backend that queries Google has been constructed with very little effort.
New backends must implement the
interface described in the Algernon api.
Algernon is useful in any system that needs to process information stored in a frame-based knowledge base. Algernon is implemented in Java and has a full API that allows access to its functionality. It also has a Protege tab plugin that allows all operations to be performed from within the Protege GUI. An Algernon server can also be activated to perform KB operations under the direction of a remote client.
Algernon is fully implemented in Java and consequently can run on a variety of machines. It uses the Java-based Jatha LISP library for manipulating dynamically-typed data. It's primary backend is the Protégé KBMS. Otherwise it is currently not dependent on any other third-party libraries.
Algernon is based on the Algernon Abstract Machine (AAM) developed in the late 1990s at the University of Texas at Austin. The AAM supports forward and backward rule chaining and supports extension opcodes to perform ancillary operations such as printing and other types of user interaction.
We do not have any official performance benchmarks, but currently the speed appears to be limited only by the performance of the KBMS backend.