JTP is an object-oriented modular reasoning system developed by Gleb Frank in Knowledge Systems Laboratory of Computer Science Department in Stanford University. JTP is based on a very simple and general reasoning architecture. The modular character of the architecture makes it easy to extend the system by adding new reasoning modules (reasoners), or by customizing or rearranging existing ones.
The system is implemented in Java. The reason for this choice is that Java is ideally suited for easy integration of object-oriented systems, which facilitates both extending JTP's functionality and embedding JTP in other systems. The abundance of supplementary software available in Java also helps.
In JTP Architecture, a reasoning system consists of modules called reasoners. According to their functionality, reasoners can be classified into two types, backward-chaining and forward chaining. Backward-chaining reasoners process queries and return proofs for the answers they provide. Forward-chaining reasoners process assertions substantiated by proofs, and draw conclusions.
There are several important subclasses of reasoners. In particular, dispatchers route goals and assertions to appropriate reasoners, search control reasoners monitor the search depth, etc.
The principal data structure that reasoners return in response to queries and assertion is a reasoning step, an object representing a proof for some sentence. Reasoning steps are often organized into a hierarchical proof tree.
A more detailed description of the architecture elements follows.
This is the principal functional component of the architecture. A backward-chaining reasoner is an object that can accept goals and find proofs for the answers it returns. Correspondingly, the reasoner interface includes two methods. Both methods take a single argument - the goal.
There are no formal limitations on what can be a goal for a backward-chaining reasoner, as long as it understands it. In current JTP implementation, goals typically correspond to first-order logic sentences expressed in the form of data structures defined in jtp.fol package.
The methods defined on the Reasoner interface are:
Example. Many reasoners only process literals with certain predicates and arity. These reasoners will use those criteria to determine acceptability, for example a reasoner dealing with equality could accept goals that are:
Example. A reasoner that performs unification of the goal with facts in a
knowledge base can return the following enumeration for the goal (parent joe ?x):
(parent joe fred) with variable assignment
?x=fred,(parent joe mary) with variable assignment
?x=mary.Dispatchers are a special type of reasoners that do not perform any reasoning themselves, but route goals to other reasoners. The task of a dispatcher is to choose among its child reasoners those that should handle a particular goal.
In addition to methods defined on the reasoner class, dispatchers have the following operations:
The simplest possible dispatcher is one that just sends every goal to all its children sequentially. A more advanced example routes goals depending on their relation symbol, arity and polarity (e.g., an equality reasoner might only accept goals of the form (= ?x ?y), i.e. with relation symbol =, arity 2 and positive polarity.)
subGoal1, subGoal2, .... subGoalN
---------------------------------
Goal
Example. A typical Modus ponens reasoning step can look like this:
(<= (foo ?x) (bar ?x)), (bar A)
-------------------------------
(foo A)
Compound reasoning steps can have sub-steps; each sub-steps proves a particular sub-goal of this reasoning step. Therefore, together with all the requisite sub-steps, the reasoning step constitutes full proof for its goal. On the other hand, if a reasoning step is missing some of the sub-steps, such partial reasoning step is only a conditional proof, given the yet unproved subgoals.
JTP was designed for easy programmatic access. The human interaction side is developed a lot less. The following are a few of possible usage models.
Example of configuring and using JTP to tell and ask simple first-order logic literals.
Example of configuring and using JTP to tell and ask more complex first-order logic sentences.
subscribe listname your-email-address(optional)
|
home |
people |
software and network services |
projects |
contact |
technical reports |
links
All Rights Reserved. 
|
Last modified: Thursday, 08-Jul-2004 15:55:00 PDT