OpenCogPrime:PredicateSchematization

Predicate Schematization

In this section we treat the process called predicate schematization, by which declarative knowledge about how to carry out actions may be translated into Combo trees embodying specific procedures for carrying out actions. This process is straightforward and automatic in some cases, but in other cases requires significant contextually-savvy inference.

To proceed with predicate schematization, we need the notion of an "executable predicate".

Some predicates are executable in the sense that they correspond to executable schemata, others are not. There are executable atomic predicates (represented by individual PredicateNodes), and executable compound predicates (which are link structures). In general, a predicate may be turned into a schema if it is an atomic executable predicate, or if it is a compound link structure that consists entirely of executable atomic predicates (e.g. pick_up, walk_to, can_do, etc.) and temporal links (e.g. ANDSimultaneous, PredictiveImplication, etc.)

Records of predicate execution may then be made using ExecutionLinks, e.g.

ExecutionLink pick_up ( me, ball_7)

is a record of the fact that the schema corresponding to the pick_up predicate was executed on the arguments (me, ball_7).

It is also useful to introduce some special (executable) predicates related to schema execution:

• can_do, which represents the system's perceived ability to do something
• do, which denotes the system actually doing something; this is used to mark actions as opposed to perceptions
• just_done, which is true of a schema if the schema has very recently been executed.

The general procedure used in figuring out what predicates to schematize, in order to create a procedure achieving a certain goal, is: Start from the goal and work backwards, following PredictiveImplications and EventualPredictiveImplications and treating can_do's as transparent, stopping when you find something that can currently be done, or else when the process dwindles due to lack of links or lack of sufficiently certain links.

In this process, an ordered list of perceptions and actions will be created. The Atoms in this perception/action-series (PA-series) are linked together via temporal-logical links.

The subtlety of this process, in general, will occur because there may be many different paths to follow. One has the familiar combinatorial explosion of backward-chaining inference, and it may be hard to find the best PA-series among all the mess. Experience-guided pruning is needed here just as with backward-chaining inference.

Specific rules for translating temporal links into executable schemata, used in this process, are as follows. All these rule-statements assume that B is in the selected PA-series. All node variables not preceded by do or can_do are assumed to be perceptions. The ==> symbol denotes the transformation from predicates to executable schemata.

EventualPredictiveImplicationLink (do A) B

==>

Repeat (do A) Until B

EventualPredictiveImplicationLink (do A) (can_do B)

==>

Repeat
    do A
    do B
Until
    Evaluation just_done B

// the understanding being that the agent may try to do B and fail,
// and then try again the next time around the loop

PredictiveImplicationLink (do A) (can_do B) <time-lag T>

==>

do A
wait T
do B

SimultaneousImplicationLink A (can_do B)

==>

if A then do B

SimultaneousImplicationLink (do A) (can_do B)

==>

do A
do B

PredictiveImplicationLink A (can_do B)

==>

if A then do B

SequentialAndLink A1 … An

==>

A1
...
An

SequentialAndLink A1 … An <time_lag T>

==>

A1
Wait T
A2
Wait T
...
Wait T
An

SimultaneousAndLink A1 … An

==>

A1
...
An

Note how all instances of can_do are stripped out upon conversion from predicate to schema, and replaced with instances of do.

A Concrete Example

For a specific example of this process, consider the knowledge that: "If I walk to the teacher while whistling, and then give the teacher the ball, I'll get rewarded."

This might be represented by the predicates

// walk to the teacher while whistling

A_1 :=
ANDSimultaneous
    do Walk_to
        ExOutLink locate teacher
    EvaluationLink do whistle

// If I walk to the teacher while whistling, eventually I will be next to the teacher

EventualPredictiveImplication
    A_1
    Evaluation next_to teacher

// While next to the teacher, I can give the teacher the ball

SimultaneousImplication
    EvaluationLink next_to teacher
    can_do
        EvaluationLink give (teacher, ball)

// If I give the teacher the ball, I will get rewarded

PredictiveImplication
    just_done
        EvaluationLink done give (teacher, ball)
    Evaluation reward

Via goal-driven predicate schematization, these predicates would become the schemata

// walk toward the teacher while whistling

Repeat:
    do WalkTo
        ExOut locate teacher
    do Whistle
Until:
    Evaluation give(teacher, ball)          

// if next to the teacher, give the teacher the ball

If:
    Evaluation next_to teacher
Then
    do give(teacher, ball)

Carrying out these two schemata will lead to the desired behavior of walking toward the teacher while whistling, and then giving the teacher the ball when next to the teacher.

Note that, in this example:

• The walk_to, whistle, locate and give used in the example schemata are procedures corresponding to the executable predicates walk_to, whistle, locate and give used in the example predicates
• Next_to is evaluated rather than executed because (unlike the other atomic predicates in the overall predicate being made executable) it has no "do" or "can_do" next to it

(This process was implemented in the Novamente Cognition Engine in 2005, by Ari Heljakka, with details slightly different than those described here, but the essence of the process is the same. This work was reported in a couple papers focused on making NCE play Fetch, one of which is in the proceedings of the 2006 AGI workshop).