• Home
• com.soartech
• jsoar-performance-testing
• 5.0.1
• source code
• selection-optimal-original.soar

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

APT.all-test.default.selection-optimal-original.soar Maven / Gradle / Ivy

## -*- Mode: sde -*-
##
############################# -*- Mode: Soar -*- #############################
## 
## File            : default/selection.soar
## Author          : John Laird
## Created on      : Mon Feb 27 16:15:34 1989  
## Last Modified On: 26 October, 2003
## 
## Contents:     Default productions for selection problem space for Soar 8.5
##
######################################################################
### Change made for Soar 8.5
###
### Significant Changes made to Convert to Soar 8.2
###    1. evaluate-object -> evaluate-operator
###    2. Removed other types of evaulate-
###    3. Change from problem-space.name selection -> name selection
###    4. Simplified so only handles vanillia evaluate-operator
###    5. Don't copy down problem space, just copy down name and
###       assume problem space will be regenerated in subgoal based on name
###    6. Added some documentation
###    

###

###    State structure:
###    (state  ^evaluation 
###               ^not-all-operators-evaulated true
###               ^operator-selection not-indifferent
###               ^found-value true)
###    ( ^numeric-value  novalue
###         ^symbolic-value novalue/success/failure
###         ^value true
###         ^operator (identifier of operator being evaluated)
###         ^desired 
###
###
###    ( ^name evaluate-operator
###         ^operator 
###         ^evaluation   ;# same as on state
###         ^superproblem-space
###         ^superstate 



### Use selection for all choice multiple, impasses 

sp {selection*elaborate*name*selection
   :default
   (state  ^choices multiple)
   -->
   ( ^name selection)}      



###
###      7.3.1 The evaluate-operator operator
###

### Create evaluate operator in selection problem space.

sp {selection*propose*evaluate-operator
   :default
   (state  ^name selection
              ^item )
 -{(state  ^evaluation )
   ( ^superoperator 
        ^value true)}
   -->
   ( ^operator  +)
   ( ^name evaluate-operator 
        ^superoperator )}


### Make them indifferent if not ^operator-selection not-indifferent.

sp {selection*select*evaluate-operator*indifferent
   :default
   (state  ^name selection
            - ^operator-selection not-indifferent
              ^operator  +)
   ( ^name evaluate-operator)
   -->
   ( ^operator  =)}

### Create evaluation once the eval operator is selected.
 
sp {selection*apply*state*evaluation
   :default
   (state  ^name selection
              ^operator )
   ( ^name evaluate-operator
        ^superoperator )
   -->
   ( ^evaluation ) 
   ( ^superoperator )}

sp {selection*elaborate*evaluate-operator*evaluation
   :default
   (state  ^name selection
              ^operator 
      ^evaluation )
   ( ^name evaluate-operator
        ^superoperator )
   ( ^superoperator )
   -->
   ( ^evaluation )}

sp {selection*elaborate*evaluate-operator*superproblem-space
   :default
   (state  ^name selection
              ^operator 
              ^superstate.problem-space )
   ( ^name evaluate-operator)
   -->
   ( ^superproblem-space )}

sp {selection*elaborate*evaluate-operator*superstate
   :default
   (state  ^name selection
              ^operator 
              ^superstate )
   ( ^name evaluate-operator)
   -->
   ( ^superstate )}


###
###      7.3.1.1 Evaluation Objects
###

sp {selection*elaborate*evaluation*value
   :default
   (state  ^evaluation )
   ( ^ << numeric-value symbolic-value >>)
   -->
   ( ^value true)}

sp {selection*elaborate*evaluation*desired
   :default
   (state  ^superstate.desired 
              ^evaluation )
   -->
   ( ^desired )}



###
###      7.3.1.2 Applying the evaluate-operator operator
###
###   Domain specific code may directly implement an evaluation, or an operator no-change may occur
### to do the job, see the next section.




###
###      7.3.2   The evaluation subgoal
###

###
### These productions which fire once an evaluation subgoal has been created
### have also been generalized.


sp {evaluate-operator*elaborate*state*desired
   :default
   (state  ^impasse no-change
              ^attribute operator 
              ^superstate.operator )
   ( -^default-desired-copy yes
          ^name evaluate-operator
          ^evaluation.desired )
   -->
   ( ^desired )}

sp {evaluate-operator*elaborate*state*name
   :default
   (state  ^impasse no-change
              ^attribute operator
              ^superstate.operator )
   ( ^name evaluate-operator
         ^superstate.name )
   -->
   ( ^name )}

## install a copy of the state, when ^default-state-copying and there
## is an operator tie.

sp {evaluate-operator*elaborate*state*duplicate-of
   :default
   (state  ^superstate 
              ^default-state-copy yes)
   (state  ^operator )
   ( ^name evaluate-operator
         ^superstate ) 
   -->
   ( ^duplicate-of* )}

### Copy down operator

sp {evaluate-operator*elaborate*state*look-ahead-operator*copy
   :default
   (state  ^problem-space.name  
          ^default-operator-copy yes 
              ^superstate.operator )
   ( ^name evaluate-operator 
         ^superoperator  
         ^superproblem-space.name )
   -->
   ( ^look-ahead-operator )
   ( ^duplicate-of* )}   


## Create pointer for uniform access even in no copy

### Added test for superproblem-space.  This restricts these productions
### to only fire in a lookahead.  Previously, these productions made it
### impossible to use evaluation problem spaces other than lookahead.

sp {evaluate-operator*elaborate*state*look-ahead-operator*no-copy
   :default
   (state  ^problem-space.name 
 
          ^default-operator-copy no 
              ^superstate.operator )
   ( ^name evaluate-operator 
         ^superoperator  
         ^superproblem-space.name 
)
   -->
   ( ^look-ahead-operator )}   

### install copy of operator in lookahead context.

sp {evaluate-operator*propose*look-ahead
   :default
   (state  ^look-ahead-operator 
             -^tried-tied-operator )
   -->
   ( ^operator  +)}

sp {evaluate-operator*propose*look-ahead*reject-all-others
   :default
   (state  ^look-ahead-operator  
              ^operator { <>   } +)
  -( ^tried-tied-operator )
   -->
   ( ^operator  -)}

### Detect that the operator has been tried.

sp {evaluate-operator*elaborate*state*tried-tied-operator
   :default
   (state  ^operator  
              ^look-ahead-operator )
   -->
   ( ^tried-tied-operator )}




### Give symbol-value failure when no operators are proposed in subgoals

sp {evaluate-operator*elaborate*evaluation*failure*no-operators
   :default
   (state  ^operator 
                     ^evaluation )
   ( ^name evaluate-operator
         ^evaluation )
   (state  ^superstate 
                   ^quiescence t)
   (state  ^superstate 
                     ^attribute state
                     ^impasse no-change
                     ^quiescence t)
   (state  ^superstate 
                    ^attribute state
                    ^impasse no-change
                    ^quiescence t)
   -->
   ( ^symbolic-value failure)}

sp {evaluate-operator*elaborate*evaluation*failure*constraint-failure
   :default
   (state  ^operator )
   ( ^evaluation )
   ( ^name evaluate-operator
         ^evaluation )
   (state  ^superstate )
   (state  ^superstate 
                          ^attribute operator
                          ^impasse constraint-failure)
   -->
   ( ^symbolic-value failure)}

sp {evaluate-operator*elaborate*symbolic-evaluation*from-subgoal
   :default
   (state  ^operator 
          ^evaluation )
   ( ^name evaluate-operator
         ^evaluation 
         ^evaluation.desired )
   (state  ^superstate 
          ^ { << required-success success partial-success 
               indifferent partial-failure failure prohibit-failure
               draw lose win >>  } )
   -->
   ( ^symbolic-value )}


sp {evaluate-operator*elaborate*numeric-evaluation*from-subgoal
   :default
   (state  ^operator 
          ^evaluation )
   ( ^name evaluate-operator
         ^evaluation 
         ^evaluation.desired )
   (state  ^superstate 
          ^desired 
          ^numeric-value )
   -->
   ( ^numeric-value )}


##                                Added to handle duplicated desireds
sp {evaluate-operator*elaborate*evaluation*from-subgoal*duplicate-desired
   :default
   (state  ^superstate 
              ^ { << required-success success partial-success 
                     indifferent partial-failure failure prohibit-failure
                     draw lose win >>  } )
   (state  ^operator 
               ^evaluation )
   ( ^name evaluate-operator
         ^evaluation 
         ^evaluation.desired )
   ( ^duplicate-of* )
   -->
   ( ^symbolic-value )}



###
###      7.3.2.1. State Copying
###

## Switch to look at current problem space, not super
## If no signals on problem space, the default is to copy both state and operator

sp {evaluate-operator*elaborate*default-for-default-state-copy-is-yes 
   :default
   (state  ^superstate.operator.name evaluate-operator
          ^problem-space 
)
  -(
 ^default-state-copy no)
   -->
   ( ^default-state-copy yes)}

sp {evaluate-operator*elaborate*default-state-copy-from-problem-space 
   :default
   (state  ^superstate.operator.name evaluate-operator
          ^problem-space.default-state-copy )
   -->
   ( ^default-state-copy )}

### Default is that all-attributes-at-level are copied

sp {evaluate-operator*elaborate*state*default-copy-is-all-attributes-at-level-one 
   :default
   (state  ^impasse no-change
              ^attribute operator
              ^superstate.operator.name evaluate-operator
          ^problem-space 
)
   (
 -^all-attributes-at-level two
        -^one-level-attributes
        -^two-level-attributes
        -^dont-copy
        -^dont-copy-anything)
   -->
   ( ^all-attributes-at-level one)}

sp {evaluate-operator*elaborate*state*default-copy-is-all-attributes-at-level-one*no-problem-space
   :default
   (state  ^impasse no-change
         -^problem-space
              ^attribute operator
              ^superstate.operator )
   ( ^name evaluate-operator 
        -^superproblem-space 
)
   -->
   ( ^all-attributes-at-level one)}

### We want ^all-attributes-at-level one to be on the goal, but if someone
### puts it on the space along with the other copying flags, we should allow
### that.  So, copy it from the space to the goal.

sp {evaluate-operator*elaborate*state*copy-all-attributes-at-level-one-from-problem-space 
   :default
   (state  ^problem-space.all-attributes-at-level one
              ^default-state-copy yes)
   -->
   ( ^all-attributes-at-level one)}

### Set up identifier mapping table for state duplication. 

sp {evaluate-operator*elaborate*state*create-duplicates-table 
   :default
   (state  ^impasse no-change
              ^attribute operator
          ^default-state-copy yes
              ^superstate.operator.name evaluate-operator)
   -->
   ( ^duplicates* )}

### Copy one-level-attributes.

sp {evaluate-operator*elaborate*state*add-one-level-attributes 
   :default
   (state  ^problem-space.one-level-attributes 
              ^duplicate-of*. 
              ^default-state-copy yes)  
   -->
   ( ^ )}

## Copy all attributes, when ^all-attributes-at-level one.

sp {evaluate-operator*elaborate*state*add-all-attributes-at-level-one 
   :default
   (state  ^problem-space 
 
              ^default-state-copy yes
              ^all-attributes-at-level one
              ^duplicate-of* )
   (
 -^dont-copy-anything 
        -^dont-copy )
   ( ^{ <> duplicate-of* <> tried-tied-operator <> problem-space 
            <> impasse <> attribute <> choices <> quiescence 
            <> operator <> superstate <> type <> name <> look-ahead-operator 
             } )
   -->
   ( ^ )}

### If we copied a one-level-attribute, and it later turned
### out that its value happened to be something that was pointed to by a
### two-level-attribute, change its value to be the copied object.

sp {evaluate-operator*elaborate*state*change-one-level-attribute-to-duplicate 
   :default
   (state  ^problem-space.one-level-attributes 
              ^duplicates*. 
              ^default-state-copy yes
              ^duplicate-of*. )
   -->
   ( ^  - 
        ^ )}

### Fixes, when all-attributess-at-level one.

sp {evaluate-operator*elaborate*state*change-all-attributes-at-level-one-to-duplicate
   :default
   (state  -^problem-space.dont-copy 
              ^default-state-copy yes
              ^all-attributes-at-level one
              ^duplicates*. 
              ^duplicate-of*.{ <> tried-tied-operator  } )
   -->
   ( ^  - 
        ^ )}

### Create new ids for two-level-attributes.

sp {evaluate-operator*elaborate*state*duplicate-id-for-attribute 
   :default
   (state  ^problem-space.two-level-attributes 
              ^duplicates* 
              ^default-state-copy yes
              ^duplicate-of*. )
   -->
   ( ^ )}

### Create new ids for all attributes, when ^all-attributes-at-level two.

sp {evaluate-operator*elaborate*state*duplicate-id-for-all-attributes 
   :default
   (state  ^problem-space 

              ^duplicates* 
              ^default-state-copy yes
              ^duplicate-of* )
   (
 -^dont-copy-anything
        -^dont-copy 
         ^all-attributes-at-level two
        -^one-level-attributes )
   ( ^{ <> duplicate-of* <> tried-tied-operator <> problem-space 
            <> impasse <> attribute <> choices <> quiescence
            <> operator <> superstate 
             } )
   -->
   ( ^ )}

### Create a copy of the old object on the new link.  First copy
### augmentations that don't point to objects that have been
### duplicated. 

#set warnings off
warnings --off
sp {evaluate-operator*elaborate*add-attribute-to-duplicate 
   :default
   (state  ^duplicates*  
             -^problem-space.dont-copy 
              ^default-state-copy yes)
   ( ^ 
      - ^)
   ( ^ { <> tried-tied-operator  } )
   -->
   ( ^ )}
#set warnings on
warnings --on

### Next copy augmentations that point to duplicated objects:

#set warnings off
warnings --off
sp {evaluate-operator*elaborate*add-duplicated-attribute-to-duplicate 
   :default
   (state  ^duplicates* 
              ^default-state-copy yes)
   ( ^ 
        ^ )
   ( ^ { <> tried-tied-operator  } )
   -->
   ( ^ )}
# commented out by voigtjr
warnings --on

### Added ^two-level-attributes .  Previously, it
### would copy any attribute that happened to point to the same value as
### one of the two-level-attributes.

sp {evaluate-operator*elaborate*state*add-duplicate-to-state 
   :default
   (state  ^problem-space.two-level-attributes 
              ^duplicates*. 
              ^default-state-copy yes
              ^duplicate-of*. )
   -->
   ( ^ )}


### moves the new links to the state when ^all-atts two.

sp {evaluate-operator*elaborate*state*add-duplicates-for-all-attributes 
   :default
   (state  ^problem-space 

              ^duplicates*. 
              ^default-state-copy yes
              ^duplicate-of*.{ <> tried-tied-operator  } )
   (
 ^all-attributes-at-level two
      - ^dont-copy-anything
      - ^dont-copy 
      - ^one-level-attributes )
   -->
   ( ^ )}

## -------------------------------
## Desired copying:
## -------------------------------

## Copy attributes to the duplicate desired state.  We
## do this after the state is installed so that the duplicates table
## will already have been filled in.  We just copy all attributes over
## from the original operator, except that attributes that pointed to 
## objects that have been duplicated (on the state) are modified to point
## to the duplicate objects.

sp {evaluate-operator*elaborate*state*eval*desired 
   :default
   (state  ^superstate )
   (state  ^operator )
   ( ^name evaluate-operator
         ^evaluation.desired 
         ^default-desired-copy yes)
   -->
   ( ^desired )
   ( ^duplicate-of* )}   


## Copy attributes whose values haven't been duplicated.

### SBH/mvp 9-2-94
### Also, added the condition that the desired be attached to
### an evaluation superoperator.  This is because if we use the same 
### desired in a lower lookahead context, this production re-firing 
### can cause stupid chunks. 

sp {duplicate-desired*copy-old-value
   :default
   (state  ^superstate.operator 
          ^problem-space 

              ^duplicates* 
              ^desired )
   ( ^name evaluate-operator
         ^evaluation.desired )
   ( ^duplicate-of* )
   ( ^{ <> duplicate-of*  } )
 - (
 ^dont-copy )
 - ( ^)
   -->
   ( ^ )}

## Copy attributes whose values have been duplicated.

sp {duplicate-desired*replace-old-value
   :default
   (state  ^duplicates*. 
          ^problem-space 

              ^desired )
   ( ^duplicate-of* )
   ( ^ { <> duplicate-of*  } )
   (
 - ^dont-copy )
   -->
   ( ^ )}


###      7.3.2.3 Operator copying   
###
### Copy attributes to the duplicate operator.  We
### do this after the state is installed so that the duplicates table
### will already have been filled in.  We just copy all attributes over
### from the original operator, except that attributes that pointed to 
### objects that have been duplicated (on the state) are modified to point
### to the duplicate objects.


sp {evaluate-operator*elaborate*operator*default-operator-copy-is-yes 
   :default
   (state  ^superstate.operator.name evaluate-operator
          ^problem-space 
)
  -(
 ^default-operator-copy no)
   -->
   ( ^default-operator-copy yes)}


sp {evaluate-operator*elaborate*operator*copy-default-operator-copy-from-problem-space 
   :default
   (state  ^superstate.operator.name evaluate-operator 
          ^problem-space.default-operator-copy )
   -->
   ( ^default-operator-copy )}

### Set up identifier mapping table for operator

sp {evaluate-operator*elaborate*state*create-duplicates-table-for-operator-only 
   :default
   (state  ^impasse no-change
              ^attribute operator
          ^default-operator-copy yes 
        - ^default-state-copy yes)
   -->
   ( ^duplicates* )}

### Copy attributes whose values haven't been duplicated.
###

sp {evaluate-operator*elaborate*operator*add-attribute-to-duplicate-operator 
   :default
   (state  ^duplicates* 
          ^problem-space 

              ^look-ahead-operator )
   ( ^duplicate-of* )
   ( ^ { <> duplicate-of*  } )
  (
 - ^ dont-copy )
   ( - ^)
   -->
   ( ^ )}

### Copy attributes whose values have been duplicated.

sp {evaluate-operator*elaborate*operator*add-duplicated-attribute-to-duplicate-operator 
   :default
   (state  ^duplicates* 
          ^problem-space 

              ^look-ahead-operator )
   ( ^duplicate-of* )
   ( ^ { <> duplicate-of*  } )
  (
 - ^ dont-copy )
   ( ^ )
   -->
   ( ^ )}



###
###     7.3.3   Computing evaluations
###
###
###     7.3.3.1 Computing numeric evaluations
###
### This is domain specific, so there are no default productions for this.

###
###     7.3.3.2 Comparing numeric evaluations
###

### If two operators have equal evaluations they are indifferent.

sp {selection*compare*equal-evaluation-indifferent 
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation   { <>   })
   ( ^desired )
   ( ^superoperator 
         ^numeric-value 
         ^desired )
   ( ^superoperator 
         ^numeric-value 
         ^desired )
 - ( ^equal not-indifferent)
   -->
   ( ^operator  = )}   


###
### Generate operator preferences based on their evaluations and info 
### as to whether higher or lower evaluations are better.

sp {selection*compare*higher-evaluation-better 
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation 
              ^evaluation { <>   })
   (state  ^problem-space 
               ^desired )
   ( ^superoperator 
         ^numeric-value 
         ^desired )
   ( ^superoperator 
         ^numeric-value < 
         ^desired )
   ( ^better higher)
   -->
   ( ^operator  < )}

sp {selection*compare*prefer-lower-evaluation 
   :default
   (state  ^name selection
              ^superstate 
              ^evaluation 
              ^evaluation { <>   })
   (state  ^problem-space 
               ^desired )
   ( ^superoperator 
         ^numeric-value 
         ^desired )
   ( ^superoperator 
         ^numeric-value > 
         ^desired )
   ( ^better lower)
   -->
   ( ^operator  < )}  


###
###      7.3.3.3 Computing symbolic evaluations
###
### Create pick-best-numeric-evaluation operator in selection problem space.

# Propose after evaluations are done

sp {selection*compare*success-evaluation-better-than-partial-success*new
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation  { <>   })  
-{( ^operator  +)
    ( ^name evaluate-operator)}

   (state  ^desired )
   ( ^superoperator  
         ^symbolic-value partial-success 
         ^success-depth 
         ^desired )
   ( ^superoperator { <>   } 
         ^symbolic-value partial-success 
         ^success-depth > 
         ^desired )
   -->
   ( ^operator  > )}  

sp {selection*compare*success-evaluation-equal-than-partial-success*new
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation  { <>   })
  -{( ^operator  +)
    ( ^name evaluate-operator)}
   (state  ^desired )
   ( ^superoperator  
         ^symbolic-value partial-success 
         ^success-depth 
         ^desired )
   ( ^superoperator { <>   } 
         ^symbolic-value partial-success 
         ^success-depth 
         ^desired )
   -->
   ( ^operator  = )}




###
###      7.3.3.3 Computing symbolic evaluations
###


sp {selection*compare*same-symbolic-evaluations-are-indifferent*NEW
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation   { <>   })
   (state  ^desired )
   ( ^superoperator  
         ^symbolic-value { <> partial-success  }
         ^desired )
   ( ^superoperator  
         ^symbolic-value { <> partial-success  }
         ^desired )
   -->
   ( ^operator  = )}  

sp {selection*compare*success-evaluation-better-than-partial-success
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation  { <>   })
   (state  ^desired )
   ( ^superoperator  
         ^symbolic-value success 
         ^desired )
   ( ^superoperator { <>   } 
         ^symbolic-value partial-success 
         ^desired )
   -->
   ( ^operator  > )}  

sp {selection*compare*partial-success-evaluation-better-than-failure*new
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation  { <>   })
   (state  ^desired )
   ( ^superoperator  
         ^symbolic-value partial-success 
         ^desired )
   ( ^superoperator { <>   } 
         ^symbolic-value << failure partial-failure >>
         ^desired )
   -->
   ( ^operator  > )}  

sp {selection*compare*partial-failure-evaluation-better-than-failure
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation   { <>   })
   (state  ^desired )
   ( ^superoperator  
         ^symbolic-value partial-failure 
         ^desired )
   ( ^superoperator { <>   } 
         ^symbolic-value failure 
         ^desired )
   -->
   ( ^operator  > )}  

sp {selection*select*required-success-evaluation-becomes-required-preference
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation )
   (state  ^desired )
   ( ^symbolic-value required-success
         ^desired  
         ^superoperator )
   -->
   ( ^operator  !)}

sp {selection*select*success-evaluation-becomes-best-preference
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation )
   (state  ^desired )
   ( ^symbolic-value success 
         ^desired  
         ^superoperator )
   -->
   ( ^operator  >)}

sp {selection*select*indifferent-evaluation-becomes-indifferent-preference
   :default
   (state  ^name selection
              ^superstate 
              ^evaluation )
   (state  ^desired )
   ( ^symbolic-value indifferent
         ^desired  
         ^superoperator )
   -->
   ( ^operator  =)}

sp {selection*select*partial-failure-evaluation-becomes-worst-preference
   :default
   (state  ^name selection
              ^superstate 
              ^evaluation )
   (state  ^desired )
   ( ^symbolic-value partial-failure
         ^desired 
         ^superoperator )
   -->
   ( ^operator  <)}

sp {selection*select*failure-evaluation-becomes-reject-preference
   :default
   (state  ^name selection
              ^superstate 
              ^evaluation )
   (state  ^desired )
   ( ^symbolic-value << lose failure >>
         ^desired 
         ^superoperator )
   -->
   ( ^operator  -)}

sp {selection*select*prohibit-failure-evaluation-becomes-prohibit-preference
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation )
   (state  ^desired )
   ( ^symbolic-value prohibit-failure
         ^desired 
         ^superoperator )
   -->
   ( ^operator  ~)}




###
###      7.3.3.4 Default evaluations
###

###         A. pass-back-success
## if an operator leads to success and it is being
## tried out in a subgoal to evaluate another operator -
## give that second operator a success evaluation also


###
###      7.3.3.5 Novalue evaluations
###

### Signal that there are still objects to evaluate.

sp {selection*elaborate*state*all-objects-evaluated
   :default
   (state  ^name selection
              ^operator  +)
- {( ^name evaluate-operator
        ^evaluation.value true)}
   -->
   ( ^not-all-operators-evaluated true)}

### Signal that a value other than novalue has been assigned.

sp {selection*elaborate*state*found-value-true
   :default
   (state  ^name selection
              ^evaluation )
   ( ^ << numeric-value symbolic-value >> <> novalue)
   -->
   ( ^found-value true)}

### If all operators have been evaluated, and all have value novalue, and
### there is a operator being evaluated in a higher context, assign that
### operator novalue.

sp {selection*elaborate*evaluate-operator*all-operators-novalue
   :default
   (state  ^superstate.superstate 
              ^operator 
             -^not-all-operators-evaluated
             -^found-value
              ^quiescence t
              ^choices multiple)
   (state  ^name selection
                ^operator )
   ( ^name evaluate-operator
          ^evaluation )
   -->
   ( ^numeric-value novalue)}

### Make novalue worse than any other value.

sp {selection*compare*novalue-evaluation-always-worse
   :default
   (state  ^name selection 
              ^superstate 
              ^evaluation 
              ^evaluation { <>   })
   (state  ^desired )
   ( ^superoperator 
         ^numeric-value novalue
         ^desired )
   ( ^superoperator 
         ^numeric-value <> novalue
         ^desired )
   -->
   ( ^operator  > )} 



###
###        7.3.4   Halting Soar with success or failure
###

###         A. top-goal*halt*state*success
### Handle state augmentations dealing with goal termination for the top-level goal.

sp {top-goal*halt*success
   :default
   (state  ^name 
              ^desired 
              ^superstate nil
              ^<< required-success success >> )
   -->
   (write (crlf)     | achieved |)
   (halt)}

###         B. top-goal*halt*state*failure

sp {top-goal*halt*failure
   :default
   (state  ^superstate nil
              ^desired 
              ^name 
              ^ << prohibit-failure failure >> )
   -->
   (write (crlf)    | failed|)
   (halt)}

###
###      7.5     Execution monitoring
###

### If the state is marked with ^success , the goal succeeds.

sp {monitor*goal*success
   :default
   (state  ^superstate nil
              -^verbose false)
   (state  ^top-state 
              ^name 
              ^desired 
              ^<< partial-success required-success success >> )
   -->
   (write (crlf) |  Goal |  | succeeded. |)}

### If the state is marked with ^failure , the goal fails.

sp {monitor*goal*failure
   :default
   (state  ^superstate nil
              -^verbose false)
   (state  ^top-state 
              ^name 
              ^desired 
              ^<< partial-failure failure prohibit-failure >> )
   -->
   (write (crlf) |  Goal |  | failed. |)}

### Print the evaluation of any operator that has a name (which doesn't
### get states).

sp {monitor*operator*evaluation
   :default
   (state  ^superstate nil
              -^verbose false)
   (state  ^top-state 
              ^operator )
   ( ^name evaluate-operator
        ^superoperator 
        ^evaluation. << numeric-value symbolic-value >> )
   ( ^name )
   -->
   (write (crlf) |  Evaluation of |  | (|  |) is | )}

############## Rules that force optimal solution

sp {evaluate-operator*elaborate*symbolic-depth*from-subgoal*new
   :default
   (state  ^operator 
          ^evaluation )
   ( ^name evaluate-operator
         ^evaluation 
         ^evaluation.desired )
   (state  ^superstate 
          ^success-depth )
   -->
   ( ^success-depth )}

sp {evaluation*operator*count-depth
   :default
   (state  ^operator  ^depth )
   -->
   ( ^depth  -
               (+ 1 ))}

sp {selection*compute*success-evaluation-best-partial-success*new
   :default
   (state  ^name selection            
              ^superstate.superstate.operator.evaluation 
              ^evaluation )
  -{( ^operator  +)
    ( ^name evaluate-operator)}
   ( ^superoperator  
         ^symbolic-value partial-success 
         ^success-depth 
         ^desired )
-{( ^evaluation )
  ( ^symbolic-value partial-success 
        ^success-depth < 
        ^desired )}
   -->
   ( ^success-depth (+ 1  )
        ^symbolic-value partial-success)} 
 
sp {selection*compute*failure-evaluation-exceed-cutoff*new
   :default
   (state  ^depth 
                   ^quiescence t
                   ^desired 
                   ^superstate )
   ( ^evaluation.success-depth <= )
   -->
   ( ^partial-failure )}

sp {selection*pass-back-success*depth*new    
   :default
   (state  ^superstate.superstate.operator 
              ^evaluation.symbolic-value << required-success success >>
              ^success-depth )
   ( ^name evaluate-operator 
          ^evaluation  
          ^superoperator.name)
   -->
   ( ^symbolic-value partial-success
         ^success-depth (+ 1 ))}