Note: This tutorial assumes you know how to run the system.
 

1. Start up NL-Soar (the Wordnet version) as usual.
2. Make sure the semantics processing is turned off as follows: nosem
3. Enter the following sentence: the zebra chased hyenas across a field.
4. Now run the system. Study the system trace and note the following:

• Words enter into the system one-by-one in left-to-right order across the sentence.
• At first the system has time to wait between words.
• Lexical access is performed for each word.
• A learn-language operator is initiated for each word. Each such operator involves learning what to do and returning a u-constructor operator, which is used to attach two pieces of syntactic structure together.

 
1. For example, after the system has accessed the word zebra, the following processing takes place:

     50:       O: O30 (learn-language)
    51:       ==>S: S36 (operator no-change)
    52:          O: O37 (install-initial-state)
    53:          O: O34 (u-constructor538)
    54:          ==>S: S50 (operator no-change)
    55:             ==>S: S51 (state no-change)
    56:                O: O40 generate-operator(link(zebra.n--spec-->the.det)
    57:                ==>S: S52 (operator no-change)
    58:                   O: C94 (check number-agreement)
    59:                   O: C92 (check assigner-follows)
    60:                   O: C90 (check aux-verb)
    61:                   O: C96 (check spec)
    62:                   O: C88 (check not-duplicate-relation)
    63:                   O: O41 (constraint-success)
    64:             O: C87 link(zebra.n--spec-->the.det)
    65:             ==>S: S53 (state no-change)
    66:                O: O43 (exhausted)
    67:          O: O44 (return-operator)
Firing chunk6727

    68:       O: O34 (u-constructor538)
Firing chunk6710
Firing chunk6714
Firing chunk6715
Firing chunk6716
Firing chunk6717
Firing chunk6718
Firing chunk6721
Firing chunk6723
Firing chunk6719
Firing chunk6720
Firing chunk6722
Retracting chunk6727
Retracting chunk6727

    69:       ==>S: S54 (operator no-change)
Firing chunk6692

    70:          O: O46 (completed)
Firing chunk6732

    71:       O: W24 (wait)

1. Note the following about this trace:
1. The learn-language operator is initiated in decision cycle 50; the system will therefore learn what to do with this word.
2. The system subgoals and initializes a new substate for learning this operator. This is done so that any temporary results can be safely discarded without affecting other ongoing processing.
3. A new u-constructor, called u-constructor538, is initialized.
4. As part of learning what u-constructor538 should do, the system subgoals and proposes a generate-operator operator. Generate-operator operators propose what types of connections might be made between previous and ongoing syntactic structures. For example, the system proposes that one possible scenario is to attach the determiner "the" into the specifier position of the NP over the node containing the word "zebra". A link operator can be used to link these two pieces together.
5. The system then fires a sequence of "check" operators. These operators each check to make sure that the attachment of the proposed pieces of syntactic structure is appropriate. Check operators perform such functions as:
1. enforcing number agreement when necessary in English (e.g. the boy, the boys, *a boys, *that dogs, *dogs barks, etc.)
2. checking word-order restrictions (e.g. objects follow their verbs and their prepositions, subjects precede verbs, etc.)
3. checking to make sure that the phrasal positions (e.g. specifier and complement) are appropriately filled
4. checking to make sure that neither of the pieces has already been previously assigned to some other configuration.
6. Once the system determines that all constraints have been satisfied, the link operator is executed in the next-hightest state, completing the cycle initiated by the generate-operator operator.
7. Once the link operator has completed and no other syntactic processing is possible, the system returns the operator learned (the new u-constructor538) to the original state where it was initiated.
8. The new operator (u-constructor538) fires in the top state; several chunks fire. These reflect the learning that was done while the operator was learned.
9. When u-constructor538 completes, the system is done integrating the newest word "zebra" into the syntactic representation, and it waits for more input by firing several wait operators starting at decision cycle 71.

 
10. Some other observations about u-constructors:
1. Sometimes u-constructors "bundle together" or combine several link operators that can fire successfully in sequence.
2. The system will try some operators which end up not being appropriate; they fail, and the system notes their failure. Then the system will try other operators until there are none left.