### -*- Mode: SDE -*-
###############################################################################
###
### File              : travel.soar
### Original author(s): Peter Hastings <peter@shrike.eecs.umich.edu>
### Organization      : University of Michigan AI Lab
### Created on        : 20 Mar 1996, 12:11:41
### Update Count      : 32
### Last Modified By  : Soar <soar@parrot.eecs.umich.edu>
### Last Modified On  : 21 Mar 1997, 14:07:37
### Soar Version      : 7
###
### Description : A simple example program to suggest travel methods.
###  In this version, I am taking out the productions which get input
###  from the user, and I'm converting to counting money instead of
###  asking the user for it.
###  960520: In this version, I'm implementing a simple lookahead.
###############################################################################

indifferent-selection -random

###############################################################################
### First set up the problem on the top-state
### Start out with a particular distance to travel, and money in the
### wallet.  If you want to change the behavior of the program, change
### and reload this production.  It can also take ^tens and ^twenties.

sp {set-up-problem
    (state <s> ^superstate nil)
    -->
    (<s> ^required-distance 7
	 ^money <m>)
    (<m> ^ones 5
	 ^fives 1)}


###############################################################################
### Propose the walk operator
### This operator is proposed if the required distance is less than 1 (mile?)

sp {propose-walk-operator
    (state <s> ^superstate nil
	       ^required-distance < 1)
    -->
    (<s> ^operator <o>)
    (<o> ^name walk)}

###############################################################################
### Propose the take-the-bus operator
### This operator is proposed if the required distance is between than
### 1 and 10.

sp {propose-bus-operator
    (state <s> ^superstate nil
	       ^required-distance {> 1 <= 10})
    -->
    (<s> ^operator <o>)
    (<o> ^name take-the-bus)}

###############################################################################
### Propose the take-a-taxi operator
### This operator is proposed if the required distance is between than
### 5 and 15.

sp {propose-taxi-operator
    (state <s> ^superstate nil
	       ^required-distance {> 5 <= 15})
    -->
    (<s> ^operator <o>)
    (<o> ^name take-a-taxi)}

###############################################################################
### Propose the take-the-train operator
### This operator is proposed if the required distance is between than
### 15 and 200.

sp {propose-train-operator
    (state <s> ^superstate nil
	       ^required-distance {> 15 <= 200})
    -->
    (<s> ^operator <o>)
    (<o> ^name take-the-train)}

###############################################################################
### Propose the airplane operator
### This operator is proposed if the required distance is greater than 200.

sp {propose-airplane-operator
    (state <s> ^superstate nil
	       ^required-distance > 200)
    -->
    (<s> ^operator <o>)
    (<o> ^name airplane)}


###############################################################################
###############################################################################
### Halt the program
### For this simple program, all we want is for an operator to be
### selected at the topstate.  So when there is a selected operator,
### this production halts Soar.  Normally this would be a bad
### condition for halting Soar because the program would be taking its
### first action in problem solving at the top level at this point.

sp {halt-the-program
    (state <s> ^superstate nil
	       ^operator <o>)
    (<o> ^name <name>)
    -->
    (write (crlf) |The proposed method of travel is | <name>)
    (halt)}

###############################################################################
###  Name the compare-operators problem space.
###  This production fires when Soar has encountered an operator tie
###  impasse, and it creates a problem space for the subgoal, and
###  names it compare-operators.

sp {name-compare-operators-ps
    (state <s> ^impasse tie
	       ^attribute operator)
    -->
    (<s> ^problem-space <p>)
    (<p> ^name compare-operators)}


###############################################################################
### Propose initializing the money sum
### Upon arriving in the compare-operators problem space, the goal is
### to count the money on hand, so that one of the operators can be
### selected.  To start this process, we must have a money-sum of 0.  
### This production proposes an operator to initialize the money-sum.

sp {propose*init-money
    (state <s> ^problem-space.name compare-operators
	       -^money-sum)
    -->
    (<s> ^operator <o>)
    (<o> ^name init-money)}


###############################################################################
### Apply the init-money operator
### If init-money is the current operator, set the money-sum to 0.

sp {apply*init-money
   (state <s> ^problem-space.name compare-operators
	      ^operator.name init-money)
   -->
   (<s> ^money-sum 0)}

###############################################################################
### Terminate the init-money operator
### If the money-sum is 0, then terminate the init-money operator.

sp {terminate*init-money
   (state <s> ^problem-space.name compare-operators
	      ^operator <o>
	      ^money-sum 0)
   (<o> ^name init-money)
   -->
   (<s> ^operator <o> @)}

###############################################################################
### Propose the add-ones operator
### If there is a money-sum, and the added-ones flag is not on the
### state, and if there is a number of ones on the superstate, then
### propose the add-ones operator with the new-sum, and the old sum.
###
### Note: this set of operators uses flags to assure that the
### operators are not repeated once they have been done.  The new-sum
### and old-sum arguments to the operator allow it to know when
### operator has been completed, and can be terminated.

sp {propose*add-ones
   (state <s> ^problem-space.name compare-operators
	      ^money-sum <n>
	      -^added-ones
	      ^superstate.money.ones <ones>)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name add-ones
	^new-sum (+ <n> <ones>)
	^old-sum <n>)}

###############################################################################
### Apply the add-ones operator
### If the current operator is add-ones, then give an acceptable
### preference for the new-sum value, and give a reject preference for
### the old-sum value, and put the added-ones flag on the state.

sp {add-ones*apply
   (state <s> ^operator <o>)
   (<o> ^name add-ones
	^new-sum <new>
	^old-sum <old>)
   --> 
   (<s> ^money-sum <new> <old> -
	^added-ones *yes*)}

###############################################################################
### Terminate the add-ones operator
### If the money-sum is the same as new-sum, then terminate the
### add-ones operator.

sp {add-ones*terminate
   (state <s> ^operator <o>
	      ^money-sum <new>)
   (<o> ^name add-ones
	^new-sum <new>)
-->
   (<s> ^operator <o> @)}


###############################################################################
### Propose the add-fives operator
### Essentially the same as add-ones, except that the number of fives
### is multiplied by 5 to make the new-sum.

sp {propose*add-fives
   (state <s> ^problem-space.name compare-operators
	      ^money-sum <n>
	      -^added-fives
	      ^superstate.money.fives <fives>)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name add-fives
	^new-sum (+ <n> (* <fives> 5))
	^old-sum <n>)}

###############################################################################
### Apply the add-fives operator

sp {add-fives*apply
   (state <s> ^operator <o>
	      ^superstate.money.fives <fives>)
   (<o> ^name add-fives
	^new-sum <new>
	^old-sum <old>)
   --> 
   (<s> ^money-sum <new> <old> -
	^added-fives *yes*)}

###############################################################################
### Terminate the add-fives operator

sp {add-fives*terminate
   (state <s> ^operator <o>
	      ^money-sum <new>)
   (<o> ^name add-fives
	^new-sum <new>)
-->
   (<s> ^operator <o> @)}


###############################################################################
### Propose the add-tens operator

sp {propose*add-tens
   (state <s> ^problem-space.name compare-operators
	      ^money-sum <n>
	      -^added-tens
	      ^superstate.money.tens <tens>)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name add-tens
	^new-sum (+ <n> (* <tens> 10))
	^old-sum <n>)}

###############################################################################
### Apply the add-tens operator

sp {add-tens*apply
   (state <s> ^operator <o>
	      ^superstate.money.tens <tens>)
   (<o> ^name add-tens
	^new-sum <new>
	^old-sum <old>)
   --> 
   (<s> ^money-sum <new> <old> -
	^added-tens *yes*)}

###############################################################################
### Terminate the add-tens operator

sp {add-tens*terminate
   (state <s> ^operator <o>
	      ^money-sum <new>)
   (<o> ^name add-tens
	^new-sum <new>)
-->
   (<s> ^operator <o> @)}


###############################################################################
### Propose the add-twenties operator.

sp {propose*add-twenties
   (state <s> ^problem-space.name compare-operators
	      ^money-sum <n>
	      -^added-twenties
	      ^superstate.money.twenties <twenties>)
   -->
   (<s> ^operator <o> + =)
   (<o> ^name add-twenties
	^new-sum (+ <n> (* <twenties> 20))
	^old-sum <n>)}

###############################################################################
### Apply the add-twenties operator

sp {add-twenties*apply
   (state <s> ^operator <o>
	      ^superstate.money.twenties <twenties>)
   (<o> ^name add-twenties
	^new-sum <new>
	^old-sum <old>)
   --> 
   (<s> ^money-sum <new> <old> -
	^added-twenties *yes*)}

###############################################################################
###  Terminate the add-twenties operator

sp {add-twenties*terminate
   (state <s> ^operator <o>
	      ^money-sum <new>)
   (<o> ^name add-twenties
	^new-sum <new>)
-->
   (<s> ^operator <o> @)}


###############################################################################
###############################################################################
### Production to propose the finished-counting operator
### When there is a money-sum on the state of the compare-operators
### problem space, propose the finished-counting operator.  Give it a
### worst preference so that it is not selected until all other
### operators (init-money, add-ones, etc) are completed.

sp {propose*finished-counting
   (state <s> ^problem-space.name compare-operators
	      ^money-sum <n>)
   -->
   (<s> ^operator <o> + <)
   (<o> ^name finished-counting)}

###############################################################################
### Production to apply the operator
### If finished-counting is the current operator, then put the
### finished-counting flag on the state.

sp {finished-counting*apply
   (state <s> ^operator.name finished-counting)
   --> 
   (<s> ^finished-counting *yes*)}

###############################################################################
### Production to terminate the finished-counting operator

sp {finished-counting*terminate
   (state <s> ^operator <o>
	      ^finished-counting *yes*)
   (<o> ^name finished-counting)
   -->
   (<s> ^operator <o> @)}



###############################################################################
###############################################################################
### Propose evaluate-operator for each tied operator
### If the money-sum is computed, and we are in the compare-operators
### problem space with tied operator <o>, then propose an operator to
### evaluate <o>.  Make it indifferent so that Soar can randomly
### choose between possibilities for the lookahead search.

sp {propose*evaluate-operator
   (state <s> ^problem-space.name compare-operators
	      ^finished-counting *yes*
	      ^item <o>)
   -->
   (<s> ^operator <eval> + =)
   (<eval> ^name evaluate-operator
	   ^operator <o>)}

###############################################################################
### Terminate evaluate-operator
### If the current evaluate-operator has an evaluation (*success* or
### *failure*), then terminate that operator.

sp {terminate*evaluate-operator
   (state <s> ^problem-space.name compare-operators
	      ^operator <o>)
   (<o> ^name evaluate-operator
	^evaluation <eval>)
   -->
   (<s> ^operator <o> @)}


###############################################################################
### Name the evaluate problem space
### If there is an operator no-change impasse, and the superstate's
### problem space is compare-operators, then name this the evaluate
### problem space.

sp {name*evaluate*ps
   (state <s> ^superstate <ss>
	      ^impasse no-change
	      ^attribute operator)
   (<ss> ^problem-space.name compare-operators)
   -->
   (<s> ^problem-space <p>)
   (<p> ^name evaluate)}


###############################################################################
### Copy the money sum to the evaluate space
### If the current space is evaluate and the superstate has a
### money-sum, copy it to the current state.

sp {copy*money-sum
   (state <s> ^problem-space.name evaluate
	      ^superstate.money-sum <money>)
   -->
   (<s> ^money-sum <money>)}


###############################################################################
### Copy the required distance to the evaluate space
### If the current space is evaluate and the superstate has a
### required-distance, copy it to the current state.


sp {copy*required-distance
   (state <s> ^problem-space.name evaluate
	      ^superstate.superstate.required-distance <dist>)
   -->
   (<s> ^required-distance <dist>)}


###############################################################################
###  Propose the lookahead operator 
### If the superstate's operator is to evaluate operator <eval-op>,
### and if no travel has been completed in this state, then propose
### <eval-op> as the operator in the current state.

sp {propose-evaluate-operator
    (state <s> ^problem-space.name evaluate
	       ^superstate.operator <superop>
	       -^bus-taken
	       -^taxi-taken)
    (<superop> ^name evaluate-operator
	       ^operator <eval-op>)
    (<eval-op> ^name <opname>)
    -->
    (<s> ^operator <o>)
    (<o> ^name <opname>)}


###############################################################################
### Productions to apply and terminate the take-the-bus and
### take-a-taxi operators
###############################################################################
### Apply take-the-bus
### If the current operator is take-the-bus, and the bus hasn't
### already been taken, and the distance required is <dist> and the
### money on hand is <m>, then change the money-sum to be <m> - <dist>
### (i.e. 1 dollar per km).

sp {apply*take-the-bus
   (state <s> ^operator <o>
	      ^required-distance <dist>
	      ^money-sum <m>
	      -^bus-taken)
   (<o> ^name take-the-bus)
   -->
   (<s> ^money-sum (- <m> <dist>) <m> -
	^bus-taken *yes*)}


###############################################################################
### Terminate take-the-bus
### If the current operator is take-the-bus, and the bus has been
### taken, then terminate.

sp {terminate*take-the-bus
   (state <s> ^operator <o>
	      ^bus-taken *yes*)
   (<o> ^name take-the-bus)
   -->
   (<s> ^operator <o> @)}


###############################################################################
### Apply take-a-taxi
### If the current operator is take-a-taxi, and a taxi hasn't
### already been taken, and the distance required is <dist> and the
### money on hand is <m>, then change the money-sum to be <m> - <dist>*3
### (i.e. 3 dollars per km).

sp {apply*take-a-taxi
   (state <s> ^operator <o>
	      ^required-distance <dist>
	      ^money-sum <m>
	      -^taxi-taken)
   (<o> ^name take-a-taxi)
   -->
   (<s> ^money-sum (- <m> (* <dist> 3)) <m> -
	^taxi-taken *yes*)}



###############################################################################
### Terminate take-a-taxi
### If the current operator is take-a-taxi, and a taxi has been
### taken, then terminate.

sp {terminate*take-a-taxi
   (state <s> ^operator <o>
	      ^taxi-taken *yes*)
   (<o> ^name take-a-taxi)
   -->
   (<s> ^operator <o> @)}


###############################################################################
### Productions to perform the evaluation
###############################################################################
### Propose do-evaluation
### If the current problem space is evaluate, then propose the
### do-evaluation operator and give it a worst preference.

sp {propose*do-evaluation
   (state <s> ^problem-space.name evaluate)
   -->
   (<s> ^operator <o> + <)
   (<o> ^name do-evaluation)}


###############################################################################
### Apply do-evaluation for failure
### If the amount of money on hand is less than zero (after paying for
### the travel), return a *failure* evaluation on the superstate's
### operator (the evaluate-operator operator for the current mode of
### travel). 

sp {apply*do-evaluation*failure
   (state <s> ^problem-space.name evaluate
	      ^operator.name do-evaluation
	      ^money-sum < 0
	      ^superstate.operator <superop>)
   -->
   (<superop> ^evaluation *failure*)}


###############################################################################
### Apply do-evaluation for success
### If the amount of money on hand is greater than or equal to zero
### (after paying for the travel), return a *success* evaluation on
### the superstate's operator (the evaluate-operator operator for the
### current mode of travel). 

sp {apply*do-evaluation*success
   (state <s> ^problem-space.name evaluate
	      ^operator.name do-evaluation
	      ^money-sum >= 0
	      ^superstate.operator <superop>)
   -->
   (<superop> ^evaluation *success*)}



###############################################################################
### Productions to translate success or failure into desirability
### preferences on the topstate's operators.
###############################################################################
### Return a best preference for success
### If the current evaluate-operator has a success flag, and if the
### corresponding operator on the superstate is <superop>, then give
### <superop> a best preference on the superstate.

sp {return*best-preference
   (state <s> ^problem-space.name compare-operators
	      ^operator <o>
	      ^superstate <ss>)
   (<o> ^name evaluate-operator
	^operator <superop>
	^evaluation *success*)
   (<ss> ^operator <superop> +)
   -->
   (<ss> ^operator <superop> >)}


###############################################################################
### Return a worst preference for failure
### If the current evaluate-operator has a failure flag, and if the
### corresponding operator on the superstate is <superop>, then give
### <superop> a worst preference on the superstate.

sp {return*worst-preference
   (state <s> ^problem-space.name compare-operators
	      ^operator <o>
	      ^superstate <ss>)
   (<o> ^name evaluate-operator
	^operator <superop>
	^evaluation *failure*)
   (<ss> ^operator <superop> +)
   -->
   (<ss> ^operator <superop> <)}