How Soar works

Next: ACT*
Up: No Title
Previous: Problem spaces in natural-language understanding
Back: to main list of student notes

# How Soar works

For an overview, see The approach through symbols by Newell, Young and Polk, in The simulation of human intelligence edited by Broadbent (PSY AD:B 078).

Soar starts off by being given a goal which determines the current context it's in. It then has to choose a problem space, an initial state, and an operator. Once it does this, it can apply the operator.

Example. We have some rooms and passages:

```    !
A---B---D-
!
C
!```
where A, B, C, D are rooms. A is a dead-end, the others have both entrances and exits. The problem-solver (robot) starts in A and has to get to D. The states in this problem space are the robot's positions. The operators are ``left'', ``forward``, ``right'', ``back''. I'll call the problem space ``maze''.

So Soar starts off with the goal ``get to D'', and I'll assume it's chosen (or been told) to start at A and to operate in the maze problem space. It now has to choose one of the four operators, and then apply it.

Like a classical PS, Soar has an LTM of rules and an STM or working memory. Hopefully, the LTM will contain some knowledge about which operators to use. Depending on how much Soar has learn, this could be strong knowledge (leading to a definite choice of ``forward'' in this case) or weak knowledge (just the names of the possible operators).

As I said, Soar first has to choose one of the operators. It does this by going through two phases. In the first, elaborate, it runs the rules in LTM repeatedly (just like a classical PS) until no more fire. These rules can do many things, but should eventually propose one or more operators with a preference attached to each. In the second phase, it enters a decision stage, and tries to resolve the preferences. There's a built-in algorithm to do that, and if it can't proceed (comes to an impasse), it automatically creates a subgoal to handle the job.

Let's assume Soar only knows the weakest possible knowledge: that all these operators ``left'', ``forward``, ``right'', ``back'' are possible. This is encoded by associating a preference with each operator in the rules in LTM:

```Operator = left (Preference = accept) if
ProblemSpace = maze.
Operator = forward (Preference = accept) if
ProblemSpace = maze.
Operator = right (Preference = accept) if
ProblemSpace = maze.
Operator = back (Preference = accept) if
ProblemSpace = maze.```
In the elaborate phase, Soar runs these rules and ends up with four operators, each having preference ``accept''. It then enters the decision stage. The preference-resolution algorithm reaches an impasse, because all the operators have the same preference. There's a good account of this on pp 173-176 of Winston 3rd edition, but note that he doesn't describe the rest of Soar.

Because Soar has reached an impasse, the automatic subgoaling mechanism takes over. This creates a subgoal resolve tie. This sets up a new context for Soar to work in, and it has to now choose an initial state, a problem space, and an operator.

Let's assume that as well as the ``maze'' problem space, we have another problem space which is all about selecting operators in other problem spaces. This could have its own operators such as ``make random choice'', ``evaluate by speed'', ``evaluate by distance to goal'', etc. Soar first chooses this as its problem space for the new context. It then chooses its initial state. This is the set of four operators proposed above. It then must pick an operator. Let's assume it chooses ``evaluate by distance to goal''. Each of these choices is made by entering an elaboration phase and then a decision phase. In each case, the decision phase might hit an impasse, requiring descent into yet another problem space.

Now Soar knows the initial state, problem space, and operator for the new context. It now enters another elaboration phase to apply ``evaluate by distance to goal''. Assume this yields ``forward''. The context above is now complete (it has an operator), so Soar can drop back into it and apply ``forward''.

As part of the automatic-subgoaling, a chunking mechanism now takes effect and creates a new rule to go into LTM. This ``remembers'' the context and state in which ``forward'' was being chosen, and states that under the same conditions, ``forward'' should be selected again.

Next: ACT*
Up: No Title
Previous: Problem spaces in natural-language understanding
Back: to main list of student notes

Jocelyn Ireson-Paine
Wed Feb 14 23:45:33 GMT 1996