To demonstrate how the system works automatically to minimize processing for a given semantic input and rule set, consider what happens when, first, the rules are changed, and, second, when the input is changed.
PROGRESSIVE AVAILABLE AND AGENTS EQUAL
If we change the example just considered so that the progressive form is now
available
, the index status will appear as
follows after the initial rule application for islands:
following initial island rule applications:
RELATION_20: 1 1
CLAUSE_28: 0 1 1
%RECONCILE_1: 0 2
%JESUS_20: 2
%CREATURE-SET_6: 2
%GOD_15: 2
CLAUSE_31: 0 0 2
%DEATH_1: 1 1 1
%JESUS_21: 2
%CROSS_1: 1 1
Compare this to the same point in the previous example (where the progressive
form was not available). There are two differences. There is an extra rule
in DEATH-1, corresponding to the extra progressive form now available. Because
this surface form is available, RELATION-20 is no longer an island. Rule 0 in
RELATION-20 depends on the progressive form being available in DEATH-1. Since
it was not available in the previous example, the rule was automatically
failed before the modified recursive descent algorithm started. Here, on the
other hand, the form is available, so it is not excluded. Since both rules 0
and 1 (the nominalizing form) are possible for this example, the modified recursive
descent algorithm considers both of them and decides that rule 0 (the progressive) is better
because it leads to a higher total score. The best answer is shown below:
best-answer:
RELATION_20: 2 0
CLAUSE_28: 0 2 0
%RECONCILE_1: 0 2
%JESUS_20: 2
%CREATURE-SET_6: 2
%GOD_15: 2
CLAUSE_31: 0 0 2
%DEATH_1: 2 0 0
%JESUS_21: 2
%CROSS_1: 2 0
++JESUS +RECONCILE ++ALL-CREATURES *TO* ++GOD
*BY*
+DYING *ON* ++THE-CROSS
This example, therefore, shows how the system defaults to a basic recursive descent operation when no optimizations are possible. The point is, this basic mode of operation is minimized to the highest extent possible by the system's analysis and exploitation of the rule set's interdependencies.
PROGRESSIVE AVAILABLE BUT AGENTS *NOT* EQUAL
In this example, the progressive form will be available again, but the
semantic input is changed. Reviewing the original example, the second DET rule
in rule 0 of RELATION-20 stipulated that the agents of the head and rest propositions
needed to be the same. In the first example, they were. If the agent in the
head proposition is changed from Jesus to God, the benefit of ``opportunistic'' information
gathering can be easily seen. The following is the index state after initial
rule application for the islands takes place:
following initial island rule applications:
RELATION_20: 2
CLAUSE_28: 0 1 1
%RECONCILE_1: 0 2
%GOD_14: 0 2
%CREATURE-SET_6: 2
%GOD_15: 1 1
CLAUSE_31: 0 0 2
%DEATH_1: 0 1 1
%JESUS_21: 2
%CROSS_1: 1 1
Again, compare this to the original example. DEATH-1 has an extra rule again
because the progressive form is available. GOD-14 occurs in place of JESUS-20
in the agent position of the first (head) proposition. Notice that both GOD-14
and GOD-15 have two rules now, while GOD-15 had only one rule in the initial
example. This occurs because of the co-reference link between the two GOD's in
the proposition, and will eventually result in the reflexive pronoun that can be seen
in the output below. What we are focusing on now, however, is RELATION-20 and
its interaction with DEATH-1. In this example, RELATION-20 has only one possible
rule showing. This is because the DET rules are all checked at the time of
rule instantiation. If a DET rule fails (such as the agents being equal, in this
case), the rule is not even added to the index. This example highlights the
benefits of this ability. Some planners would still consider
a rule like this valid, would instantiate it, traverse the tree, and find the
contradiction only upon reaching the node DEATH-1.
Notice also that the first rule in DEATH-1 is failed. This rule corresponds to the progressive option. Because the head and rest's agents were not equal, rule 0 in RELATION-20 was not included. This rule is the only place where a ``progressive'' constraint could be imposed on DEATH-1. Since DEATH-1 has a DEP rule requiring such a constraint, and the constraint is unrealizable, the rule is automatically failed. This is similar to (although in reverse) to the situation in the first example where the first rule in RELATION-20 was detected as having an impossible DEP rule precondition because there was no progressive surface form in DEATH-1.
The best answer for this example is given below with its pseudo-surface form:
best-answer:
RELATION_20: 2
CLAUSE_28: 0 2 0
%RECONCILE_1: 0 2
%GOD_14: 0 2
%CREATURE-SET_6: 2
%GOD_15: 2 0
CLAUSE_31: 0 0 2
%DEATH_1: 0 2 0
%JESUS_21: 2
%CROSS_1: 2 0
++GOD +RECONCILE ++ALL-CREATURES *TO* +HIMSELF
*BY*
++JESUS +DEATH *ON* ++THE-CROSS