The user may issue commands via either the keyboard or the popup context menu. All commands apply to the currently selected node. Moving the selection handles (focus) can be done either by pointing the mouse or using the directional keys.
Shown here are two different tree stages in the process
of exploring a (again using the example
from chapter 3). The tree on the left is only partially expanded.
Note that the order of expansion is not restricted to Prolog's
depth first search order. The attribute of each node denotes its
value as follows:
- green: 'true' or ancestry resolved node.
- blue (bold): evident node.
- bright red: blocked or failed node. That is, a node whose term does not have any matching clause or (in the case of an expression) is invalid or evaluates to FALSE.
- dark red: repeat node (one that matches an ancestor node).
Important: unlike Query mode, a node's value in Explore mode always pertains to the tree it is a part of. Supported and conflicted values are not calculated, as these rely on information not present in a single tree.
In addition, the elevation of the node denotes its 'state' as follows:
- raised: node is unexpanded, but can be expanded. (E.g., b and e in the left tree above.)
- sunken: node is a choice point, i.e., node has been expanded but there are more matching clauses that are unused. (E.g., c in the left tree above)
- flat: node is either 'true' or ancestry resolved (e.g., ~a), unexpandable, or all matching clauses have been used to expand the node (e.g., a).
The next example shows five different stages in exploring
d. From left to right: 1) Tree for
d is expanded. The result is a closed
clause tree and d is shown as evident
(blue). a is also at the root of
a closed clause tree so it is also evident. In addition,
d's sunken look shows it has other
matching clause(s); 2) Node d is
'redone' using clause d <- e;
3) Node e is expanded, but the expansion
stops since there is no matching clause for c;
4) Node e is redone with a different
clause; 5) Further expansion results in a repeat node (node d).
(In actuality, the user will see only one animated tree rather
than five separate ones. This is simply an attempt to capture
a dynamic display on a static medium. In the interest of brevity,
many steps were omitted.)
VL provides additional control over expanding and redoing nodes through watch windows. The user can open a watch window for each node by clicking on it. The watch window shows the current instantiation of the node and its current value - evident, true, ancestry resolved, blocked, repeat, or na (none of these). It also shows all of the node's matching clauses and indicates which have been used and in which order. The number in parentheses next to each clause is simply its index number in the clause database. Clicking on an unused clause will expand (or redo) a node using that clause. Clicking on a used clause will restore the node to the state before it was expanded using that clause.
The figure on top shows the watch window for node an( X, Y) (the familiar ancestor/2 relation) before expansion. Suppose in this case the user is not interested in the trivial case where the ancestor is the parent. By clicking on the second clause, the user can expand an( X, Y) using an( X, Z) :- pa( X, Y), an( Y, Z). The result is shown in the bottom figure.
In the last example below, the figure on the left shows node e has been expanded twice, exhausting all its matching clauses. The list [68,64] after Clauses shows the order of usage from latest to earliest; i.e., clause 64 was used first, followed by clause 68. The figure on the right shows what happens after the user has clicked on clause 64. Since clause 64 was used first, the node is restored to the state before it was ever expanded. In short, the watch window provides a mechanism for a) choosing which matching clause to expand a node with; and b) restoring a node to a point prior to a clause selection.
Lastly, VL provides the Step command, a mean to quickly generating all possible clause trees for a given term. Step generates all clause trees, whether they are closed or not. Essentially, Step produces an exhaustive trace for a given goal, showing all 'failures.' The same can be achieved using Explore, albeit much more slowly.
The other windows of the tool are mainly accessories and are not essential to the discussion. They are covered in the user guide.