PSCM functions
--------------

 
  1. Goals:
          
        * Proposing, comparing and selecting a goal.  Whenever progress
          cannot be made on the current goal, a subgoal can be created, so
          that the lack of progress can itself be considered a problem to be
          solved.  In Soar, goals arise only from impasses in carrying out
          the other problem space functions.  Because of the nature of
          impasses, a goal can have only a single subgoal.  A subgoal can
          itself have a subgoal, but there is never any need to compare or
          select goals.
          
        * Refining the information available about the current goal.
           A
          goal arises in the context of some other problem solving, such as
          trying to select or apply an operator.  New structures that are
          refinements of the current situation can be added to the goal.  The
          refinements might be combinations of existing information or
          recollections of prior knowledge that relates to the cause of the
          impasse.  For example, if the goal is to apply an operator that
          creates a structure with block A on top of block B, it should be
          possible to add information that A does not have another block on
          top of it (i.e., that block A is clear).
          
        * Terminating a goal.  The system must recognize when a problem
          space's current state achieves the current goal.  In Soar, goals
          are created because of impasses in performing PSCM functions.  When
          these impasses are resolved, the subgoal will be automatically
          terminated.  Therefore, goals based on different types of impasses
          will be terminated in different ways.  For example, if an impasse
          arises because an operator cannot be directly applied, the goal's
          termination will correspond to the successful application of the
          operator.  If an impasse arises because there is insufficient
          knowledge to distinguish between a set of operators, the goal's
          termination will correspond to the selection of an operator.
          Therefore, a test for goal achievement or failure is not an
          independent PSCM function, but instead is embodied in the PSCM
          function that gave rise to the subgoal.
     
     
  2. Problem Spaces:
          
        * Proposing, comparing, and selecting a problem space
          for the goal.
           Many different problem spaces may be appropriate for
          a given goal.  Knowledge can be used to propose different problem
          spaces, compare them, and select the one most appropriate for the
          current goal.  If a problem space is selected and found to be
          inadequate, it must be possible to select another problem space.
          Only a single problem space may be used for a goal at one time.
          
        * Refining the information available about the current problem space.
           Once
          a problem space is proposed or selected, it may be specialized to
          the current goal.  A problem space may also have refinements that
          are explicit descriptions of important invariants that hold in the
          states or operators of the problem space.  For example, a general
          problem space for manipulating blocks may be specialized if all
          blocks are cubes of the same size.  Once it is specialized, the
          problem space may be augmented with additional information, such as
          that it doesn't matter which way a block is oriented when it is
          stacked.
     
     
  3. States:
          
        * Proposing, comparing and selecting an initial state.
          
          The initial state of a problem is the starting situation from which
          progress will begin.  It will usually be based on the sensory
          information available from the environment, the local problem
          solving context (the goal and problem space), and permanent
          knowledge relevant in the context.  Different initial states are
          possible depending on what knowledge is relevant to the problem, as
          well as which representations are most appropriate for the states.
          Only a single initial state can be selected.
          
        * Refining the information available about the current state.
           
          Once a state is selected, additional knowledge may exist to augment
          its description with the refinements of the current situation. For
          example, if the current state contains information that block A is
          of height 2 and block B is of height 4, the state could be
          augmented with knowledge that block B is twice the height of block
          A.
     
     
  4. Operators:
          
        * Proposing, comparing and selecting an operator.  One of the most
          important decisions in problem solving is selecting which operator
          to apply next.  This includes proposing the available operators,
          comparing them, and selecting the best one, given the available
          knowledge.  As part of proposing an operator, it may be necessary
          to *instantiate* the operator with data from the current state.  A
          single operator can be instantiated with different components of
          the state, leading to the proposal of multiple specific operators.
          For example, a generic operator to move a block may be instantiated
          with each block in the environment, leading to many different
          specific operators from which to choose.  Only a single operator
          can be selected at any time.  As will be explained later, this does
          not constrain Soar to carry out one external action at a time, as a
          single operator can involve many actions.
          
        * Refining the information available about the current operator.
          Once an operator has been selected, it may be further instantiated
          with specific information from the state.  For example, once an
          operator is selected to move a block, the operator might be
          augmented with a description of the block's exact location and
          destination.  This information may have been unnecessary for
          determining which operator to select.
          
        * Applying an operator to a state.  A selected operator generates a
          new state by making persistent modifications to the current state.
          Some of these changes may result in motor command that will
          indirectly change the state through perception.
          
          One component of applying an operator is detecting that the
          operator is terminated.  In most cases, detecting that an operator
          is finished is independent of how the operator was actually
          applied.  For an operator that changes only an internal state,
          termination can be signaled as soon as the change is made.
          However, if the operator involves changes that are problematic, a
          separate test may be required to signal termination.  For example,
          if a robot has an operator to pick up blocks, that operator would
          terminate only through the testing of feedback from the
          environment.

Missing from these descriptions of the PSCM are functions for input, output,
and learning.  In this formulation, input occurs asynchronously in the
current state of the problem space for interacting with the external
environment.  No PSCM function is required, it just happens.  Output occurs
as part of operator application in the current state of the problem space for
interacting with the external environment.  In this formulation, learning is
not a PSCM function, but instead a property of the underlying symbol-level
architecture.