#region parameters
numeric-indifferent-mode -s
indifferent-selection -g 
indifferent-selection -e 0
#endregion

#region Initialize ########################

# Initialize Ernest when the State has no name

sp {propose*initialize-Ernest
   (state <s> ^superstate nil
             -^name)
-->
   (<s> ^operator <o> +)
   (<o> ^name initialize-Ernest)
}
sp {apply*initialize-Ernest
   (state <s> ^operator <op>)
   (<op> ^name initialize-Ernest)
-->
   # State
   (<s>   ^name  Ernest
          ^token select
          ^ern   <ern>            # Ernest
          ^cnt   0                # Cycle counter
          )

          # Ernest's initialisation
          (<ern> ^thi   0          # Not thinking
                 ^ltm   <mltm>     # Long-term memory  (stores the schemas)
                 ^stm   <mstm>     # Short-term memory (stores the context)
                 ^wom   <mwom>)    # Working memory    (stores the activated schemas)
 
                 (<mltm> ^sch   <s2>)(<s2> ^do |senseForward| ^wei 100) # 2 Touch forward
                 (<mltm> ^sch   <s3>)(<s3> ^do |forward|      ^wei 100) # 3 Move forward
                 (<mltm> ^sch   <s4>)(<s4> ^do |turnRight|    ^wei 100) # 4 Turn right
                 (<mltm> ^sch   <s5>)(<s5> ^do |turnLeft|     ^wei 100) # 5 Turn left
                 (<mltm> ^sch   <s6>)(<s6> ^do |senseRight|   ^wei 100) # 6 Touch right
                 (<mltm> ^sch   <s7>)(<s7> ^do |senseLeft|    ^wei 100) # 7 Touch left
                 
                 (<mltm> ^act <as2S>) (<as2S> ^sch <s2> ^sta S ^val -1 ^tag | - Foward_wall| ^cnt 1)   # Touch forward S (obstacle)
                 (<mltm> ^act <as2F>) (<as2F> ^sch <s2> ^sta F ^val -1 ^tag | - Foward_clear| ^cnt 1)  # Touch forward F (empty)

                 (<mltm> ^act <as3F>) (<as3F> ^sch <s3> ^sta S ^val 10 ^tag | - Move_forward| ^cnt 1) # Moving forward S
                 (<mltm> ^act <as3S>) (<as3S> ^sch <s3> ^sta F ^val -10 ^tag | - Bump_wall| ^cnt 1)   # Moving forward F
                 (<mltm> ^act <as4S>) (<as4S> ^sch <s4> ^sta S ^val -1 ^tag | - Turn_right| ^cnt 1)   # Turn right S
                 (<mltm> ^act <as5F>) (<as5F> ^sch <s5> ^sta S ^val -1 ^tag | - Turn_left| ^cnt 1)    # Turn left S

                 (<mltm> ^act <as6S>) (<as6S> ^sch <s6> ^sta S ^val -1 ^tag | - Right_wall| ^cnt 1)   # Touch right S (obstacle)
                 (<mltm> ^act <as6F>) (<as6F> ^sch <s6> ^sta F ^val -1 ^tag | - Right_clear| ^cnt 1)  # Touch right F (empty)
                 (<mltm> ^act <as7S>) (<as7S> ^sch <s7> ^sta S ^val -1 ^tag | - Left_wall| ^cnt 1)   # Touch left S (obstacle)
                 (<mltm> ^act <as7F>) (<as7F> ^sch <s7> ^sta F ^val -1 ^tag | - Left_clear| ^cnt 1)  # Touch left F (empty)
                 } 

#endregion

#region Select ############################

# All schemas that have enough reinforcement 
# are proposed with a preference of 0

sp {Ernest*propose*select*schema
   (state <s> ^name      Ernest
              ^token     select
              ^ern       <ern>)
   (<ern>     ^ltm       <ltm>)
   (<ltm>     ^sch       <sch>)
   (<sch>     ^wei       > 4) # 4 (regularity threshold) 
-->
   (<s>       ^operator  <op> + =)
   (<op>      ^name      select
              ^int       <sch>)
}

# Allways support primitive schemas

sp {Ernest*propose*support*primary*schema
   (state <s> ^name      Ernest
              ^token     select
              ^ern       <ern>
              ^operator  <op> +)
   (<op>      ^name      select
              ^int       <int>)
   (<int>     ^do        <d>)
   -->
   (<op>      ^sup       sup)
}

# Every activated schema (whose context matches the current context)
# proposes its intention
# The weight of the proposition is equal to the weight of the matching schema
# multiplied by the value of the intention subschema

sp {Ernest*propose*activate*schema
   (state <s> ^name      Ernest
              ^token     select
              ^ern       <ern>
              ^operator  <op> +)
   (<op>      ^name      select
              ^int       <int>)
   (<ern>     ^stm       <stm>
             # ^ltm       <ltm>
              ^wom       <wom>) # activated schemas
   (<wom>     ^cur       <cur>) #
   (<cur>     ^act.sch   <sch>) #
   (<stm>     ^act       <act>)
#   (<ltm>     ^sch       <sch>)
   (<sch>     ^con       <act>
              ^int       <i1>
              ^wei       <wei>)
   (<act>     ^sch       <con>
              ^sta       <sta>)
   (<i1>      ^sch       <int>
              ^sta       <sta2>
              ^val       <val>)
-->
   (<s>       ^operator  <op> = (* <wei> <val>))
   (<op>      ^sup       sup)
   
#   (write |<match>Match | <sch> | = ( | <act> |=| <con> <sta>| , | <i1> |=| <int> <sta2> |(| <val> |) , |<wei> |) propose | <int> | (|  (* <wei> <val>) |)</match>|(crlf))
}

# Propagate the activation to the second level subschema
# The weight of the proposition is equal to the weight of the matching schema
# multiplied by the value of its intention
# only if their intention has not passed the regularity threshold 

sp {Ernest*propose*prefer*forward*schema
   (state <s> ^name      Ernest
              ^token     select
              ^ern       <ern>
              ^operator  <op> +)
   (<op>      ^name      select
              ^int       <sch>)
   (<ern>     #^stm       <stm>
              ^wom       <wom>)
   (<wom>     ^cur       <cur>)
   (<cur>     ^act.sch   <schp>)
#   (<stm>     ^act       <con>)
   (<schp>    ^con       <con>
              ^int       <int>
              ^wei       <wei>)
   (<int>     ^sch       <l3>
              ^sta       <l4>
              ^val       <val>)
   (<l3>      ^con.sch   <sch>
              ^wei       < 5)
   (<con> ^sch <l1> ^sta <l2>)
   -->
   (<s>       ^operator  <op> + = (* <wei> <val>))
   (<op>      ^sup       sup)
      
#   (write |<match>Match | <schp> | = ( | <con> |=| <l1> <l2>| , | <int> |=| <l3> <l4> |(| <val> |) , | <wei> |) propose | <sch> | (|  (* <wei> <val>) |)</match>|(crlf))
}

# The schemas that have support get a base activation of 100
# (only way I have found to prevent schemas that have no support from being selected)

sp {Ernest*propose*support
   (state <s> ^name      Ernest
              ^token     select
              ^ern       <ern>
              ^operator  <op> +)
   (<op>      ^name      select
              ^int       <int>
              ^sup       sup)
   -->
   (<s>      ^operator   <op> = 100)
}

# Select the succeeding act of the most weighted schema
# The act gets a token equal to con  (context = first par of the schema)
# Initialize a new situation. Set it equal to the current situation
# Move to enact

sp {Ernest*apply*select*schema
   (state <s> ^operator <op>
              ^ern      <ern>)
   (<op>      ^name     select
              ^int      <sch>)
   (<ern>     ^ltm      <ltm>)
#   (<ltm>     ^act      <act>)
#   (<act>     ^sch      <sch>
#              ^sta      S
#              ^val      <val>)
-->
   (<s>       ^token    select -
              ^token    predict ) # enact predict
   (<ern>     # ^ena      <act> # Selects the succeeding act for no prediction nor think
               ^sch      <sch> # 
              ^sit      <cur>
              ^temp     <tem>) # tremporary situation for convenience
#   (<act>     ^tok      con) #
   
#   (write |<selection>Select | <act> |=| <sch> |S</selection>|(crlf))
#   (write |<selection>Select | <sch> |</selection>|(crlf))
#   (write |<rational>| <sch> |</rational>|(crlf))
   }

#endregion

#region Predict ###########################

# Both acts (S and F) that match the selected schema are proposed

sp {Ernest*propose*token*predict
   (state <s> ^name     Ernest
              ^token    predict
              ^ern      <ern>)
   (<ern>     ^sch      <sch>
              ^ltm      <ltm>)
   (<ltm>     ^act      <act>)
   (<act>     ^sch      <sch>)
-->
   (<s>       ^operator <op> + =)
   (<op>      ^name     predict
              ^act      <act>)
}

# Every activated schema whose intention is selected
# proposes its predicted act
# The weight of the proposition is equal to the weight of the matching schema

sp {Ernest*propose*predict*schema
   (state <s> ^name      Ernest
              ^token     predict
              ^ern       <ern>
              ^operator  <op> +)
   (<op>      ^name      predict
              ^act       <act>)
   (<act>     ^sch       <sch>
              ^tag       <tag>
              ^sta       <sta>)
   (<ern>     ^wom       <wom>)
   (<wom>     ^cur       <cur>)
   (<cur>     ^act       <actp>)
   (<actp>    ^sch       <schp>)
   (<schp>    ^con       <con>
              ^int       <act>
              ^wei       <wei>)
   (<con> ^sch <l1> ^sta <l2>)
-->
   (<s>       ^operator  <op> = <wei>)
   
   (write |<match>Predict | <act> | = | <sch> <sta> | (|  <wei> |) based on | <actp> | = |<schp> |S = ( | <con> |=| <l1> <l2>| , | <act> |=| <sch> <sta> |) | <tag> |</match>|(crlf))
}

sp {Ernest*propose*predict*subschema
   (state <s> ^name      Ernest
              ^token     predict
              ^ern       <ern>
              ^operator  <op> +)
   (<op>      ^name      predict
              ^act       <act>)
   (<act>     ^sch       <sch>
              ^tag       <tag>
              ^sta       <sta>)
   (<ern>     ^wom       <wom>)
   (<wom>     ^cur       <cur>)
   (<cur>     ^act       <actp>)
   (<actp>    ^sch       <schp>)
   (<schp>    ^con       <con>
              ^int       <int>
              ^wei       <wei>)
   (<int>     ^sch       <l3>
              ^sta       <l4>)
   (<l3>      ^con       <act>)
   (<con> ^sch <l1> ^sta <l2>)
   -->
   (<s>       ^operator  <op> = <wei>)
      
   (write |<match>Predict | <act> | = | <sch> <sta> | (| <wei> |) based on | <actp> | = | <schp> |S = ( | <con> |=| <l1> <l2>| , | <int> |=| <l3> <l4> | , | <wei> |) | <tag> |</match>|(crlf))
}

# the selected act is proposed to be enacted
# the selected schema is cleared

sp {Ernest*apply*predict
   (state <s> ^operator <op>
              ^ern      <ern>
              ^token    predict)
   (<op>      ^name     predict
              ^act      <act>)
   (<act>     ^sch      <sch>
              ^sta      <sta>
              ^tag      <tag>)
-->
   (<s>       ^token    predict -
              ^token    enact ) # think
   (<ern>     ^ena      <act>
              ^sch      <sch> -)
   (<act>     ^tok      con)

   (write |<selection>Intend | <act> |=| <sch> <sta> | | <tag>|</selection>|(crlf))
   
}
#endregion

#region Think #############################

# TOKEN

sp {Ernest*propose*token*think
   (state <s> ^name     Ernest
              ^token    think)
-->
   (<s>       ^operator <op> + )
   (<op>      ^name     think)
}

sp {Ernest*apply*token*think
   (state <s> ^operator <op>)
   (<op>      ^name     think)
   (<s>       ^token    <tok>)
-->
   (<s>       ^token    <tok> -
              ^token    enact)   
}

# STARTS THINKING 
# If the selected act is supported by an activated schema
# then start dreaming
# save the curent situation

sp {Ernest*apply*start*thinking
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     think)
   (<ern>     ^ena      <ena>
              ^stm      <stm>
              ^wom      <wom>
              ^thi      0)
   (<ena>     ^sch      <sch>)
#   (<sch>     ^con      <con>
#              ^int      <con>)
#   (<con>     ^sch.con  <t2>)
#   (<wom>     ^cur.act.sch.int  <ena>)
   - (<ern>   ^dre      <t>) # to prevent from restarting dreaming because of activations in the dream
-->
   (<ern>     ^thi      1
              ^thi      0 - 
              ^dre      <dre>)
   (<dre>     ^stm      <stm>
              ^wom      <wom>
              ^ena      <ena>)
   
#   (write |<rational>Dreaming</rational>|(crlf))
}

# END THINKING
# Restore the situation to its value before starting thinking

sp {Ernest*apply*end*thinking
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     think)
   (<ern>     ^dre      <dre>
              ^thi      0
              ^stm      <stm>
              ^wom      <wom>
              ^ena      <ena>)
   (<ena>     ^tok      con)
   (<dre>     ^ena      <dreena>
              ^stm      <drestm>
              ^wom      <drewom>)
-->
   (<ern>     ^dre      <dre> -
              ^stm      <stm> -
              ^wom      <wom> -
              ^ena      <ena> -
              ^stm      <drestm>
              ^wom      <drewom>
              ^ena      <dreena>)
   (<ena>     ^tok      con -)  # activate the schema before thinking
   (<dreena>  ^tok      con)
   
#   (write |<rational>Do | <dreena> |</rational>|(crlf))
}

# THINK ENACTION
# During the enact phace 
# This operator has priority over the enact phase

sp {Ernest*propose*enact*dream
   (state <s>  ^name     Ernest
               ^ern      <ern>
               ^token    enact)
   (<ern>      ^ltm      <ltm>
               ^thi      > 0)
   (<ltm>      ^act      <act>)
   (<act>      ^sch      <sch>
               ^tok      con)
#   (<sch>      ^do       <do>) No need to go through all the details!!! The enacted schema is dreamed to succeed
-->
   (<s>        ^operator <op> + >)
   (<op>       ^name     dream
               ^act      <act>)
}

# The selected act succeeds 
# Whatever its expectation
# Decrements the thinking counter

sp {Ernest*apply*enact*dream
   (state <s>  ^name      Ernest
               ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      dream
               ^act       <act>)
   (<ern>      ^thi       <thi>)
   (<act>      ^tok       con
               ^tag       <tag>)
-->
   (<ern>      ^don       <act>
               ^thi       <thi> -
               ^thi       (- <thi> 1 ))
   (<act>      ^tok       con -
               ^tok       S)
      
   (write |<rational>| <tag> |</rational>|(crlf))
} 


#endregion

#region Initialise Recursive Subacts ######

# When an act's token is con
# and its schema's context has not yet a token 
# then its schema's context gets a token equal to con

sp {Ernest*propose*subschema*con
   (state <s>  ^name      Ernest
               ^ern       <ern>
               ^token     enact) #
   (<ern>      ^ltm       <ltm>)
   (<ltm>      ^act       <act>)
   (<act>      ^tok       con
               ^sch.con   <con>)
   - (<con>    ^tok       <t>)
-->
   (<s>        ^operator  <op> +)
   (<op>       ^name      subcon
               ^con       <con>)
}

sp {Ernest*apply*subschema*con
   (state <s>  ^name      Ernest
               ^operator  <op>)
   (<op>       ^name      subcon
               ^con       <con>)
-->
   (<con>      ^tok       con)
   
#   (write  |Context: | <con> | expects | <exp>(crlf))       
}

# When an act's token is int (intention =  second part of the schema)
# and its schema's intention has not yet a token 
# Then its schema's intention schema gets a token equal to con

sp {Ernest*propose*subschema*int
   (state <s>  ^name      Ernest
               ^ern       <ern>
               ^token     enact) 
   (<ern>      ^ltm       <ltm>)
   (<ltm>      ^act       <act>)
   (<act>      ^tok       int
               ^sch.int   <int>)
   - (<int>    ^tok       <t>)
-->
   (<s>        ^operator  <op> +)
   (<op>       ^name      subint
               ^int       <int>)
}

sp {Ernest*apply*subschema*int
   (state <s>  ^name      Ernest
               ^operator  <op>)
   (<op>       ^name      subint
               ^int       <int>)
-->
   (<int>      ^tok       con)
   
#   (write |Intention: | <int> | expects | <exp>(crlf))       
}

#endregion

#region Lowest State ######################

# If Ernest is not dreaming
# then send the action to the output

sp {Ernest*output*schema
   (state <s>  ^name     Ernest
               ^token     enact
               ^io.output-link <out>
               ^ern      <ern>)
   (<ern>      ^ltm      <ltm>
               ^thi      <= 0)
   (<ltm>      ^act      <act>)
   (<act>      ^sch      <sch>
               ^tok      con)
   (<sch>      ^do       <do>) 
   - (<ern>    ^dre      <t>)
     -->
   (<out>      ^|vacuum.types.action| <action>)
   (<action>   ^move     <do> )
   (write |<trace>| <do> |</trace>|(crlf))
}

#endregion

#region Environment #######################

# When a schema has a do and a token equal con
# and there is a response from the environment

sp {Substate*propose*vacuum
   (state <s>  ^name     Ernest
               ^ern.ltm  <ltm>
               ^token    enact
               ^io.input-link     <in>)
   (<in>       ^|vacuum.types.position| <position>)
   (<position> ^get      <get> )
   (<ltm>      ^act      <act>)
   (<act>      ^sch      <sch>
               ^tok      con)
   (<sch>      ^do       <do>)
-->
   (<s>        ^operator <op> +)
   (<op>       ^name     vacuum
               ^act      <act>
               ^get      <get>)
}

# Get the response from the environment
# The elementary act is retrieved
# If the response matches the act status
# Then the act tok is set to S 

sp {Substate*apply*vacuum*don
   (state <s>  ^name      Ernest
               ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      vacuum
               ^act       <act>
               ^get       <get>)
   (<ern>      ^ltm       <ltm>)
   (<act>      ^sta       <get>
               ^tok       con)
-->
   (<ern>      ^don       <act>)
   (<act>      ^tok       con -
               ^tok       S)
      
#   (write |<trace>Get act |<act>| = | <sch> <get> |</trace>|(crlf))
} 

# If the response does not matches the act status
# the act tok is set to F 
# The actually enacted act is memorized as don

sp {Substate*apply*vacuum*fai
   (state <s>  ^name      Ernest
               ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      vacuum
               ^act       <act>
               ^get       <get>)
   (<ern>      ^ltm       <ltm>)
   (<ltm>      ^act       <don>)
#   (<act>      ^sta       <exp> { <> <exp> <get> } Does not work I dont know why??
   (<act>      ^sta       <> <get> 
               ^sch       <sch>
               ^tok       con)
   (<don>      ^sta       <get>
               ^sch       <sch>
               - ^tok      )
   
-->
   (<ern>      ^don       <don>)
   (<act>      ^tok       con -
               ^tok       F)
      
#   (write |<trace>Get act |<act>| = | <sch> <get> |</trace>|(crlf))
} 

#endregion

#region Assess the substate ###############

# CONTEXT SUCCEED
# An act has a tok = con 
# and a schema's context with a tok = S 
# The act token is moved to int
# The schema's context is desactivated
# the don act is cleared

sp {Ernest*propose*current*context*succeed
   (state <s>  ^name      Ernest
               ^ern       <ern>)
   (<ern>      ^ltm       <ltm>)
   (<ltm>      ^act       <act>)
   (<act>      ^sch.con   <con>
               ^tok       con)
   (<con>      ^tok       S)
-->
   (<s>        ^operator  <op> +)
   (<op>       ^name      consuc
               ^act       <act>)
}
sp {Ernest*apply*current*context*succeed
   (state <s>  ^ern        <ern>
               ^operator   <op>)
   (<ern>      ^don        <don>)
   (<op>       ^name       consuc
               ^act        <act>)
   (<act>      ^tok        con
               ^sch.con    <con>)
   (<con>      ^sta        <exp>
               ^val        <val>
               ^tok        S
               ^sch        <l1>)
-->
   (<ern>      ^don        <don> -)
   (<act>      ^tok        con -
               ^tok        int)
   (<con>      ^tok        S -)
    
   (write |<gotten>| <con> |=| <l1> <exp> |(| <val> |) Correct</gotten>|(crlf))
}

# INTENTION SUCCEED 
# An act has a tok = int
# and a schema's intention with a tok = S
#  The schema's intention is desactivated
#  If the act had an expectation of S 
#   The act token is moved to don
#   It is memorized as don instead of the previous one

sp {Substate*propose*current*intention*succeed
   (state <s>  ^ern       <ern>)
   (<ern>      ^ltm       <ltm>)
   (<ltm>      ^act       <act>)
   (<act>      ^sch.int   <int>
               ^tok       int)
   (<int>      ^tok       S)
-->
   (<s>        ^operator  <op> +)
   (<op>       ^name      intsuc
               ^act       <act>)
}

#  The succeeding act was created when the schema was created
sp {Ernest*apply*current*intention*succeed*expected
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<ern>      ^ltm       <ltm>
               ^don       <don>)
   (<op>       ^name      intsuc
               ^act       <act>)
   (<act>      ^tok       int
               ^sch       <sch>
               ^sta       S)
   (<sch>      ^wei       <wei>
               ^int       <int>)
   (<int>      ^sch       <l1>
               ^sta       <exp>
               ^val       <val>
               ^tok       S)
-->
   (<ern>      ^don       <act>
               ^don       <don> -)
   (<act>      ^tok       int -
               ^tok       S)
   (<int>      ^tok       S -)
   (<sch>      ^wei       <wei> -
               ^wei       (+ <wei> .02 ))
   
   (write |<gotten>| <int> |=| <l1> <exp> |(| <val> |) Correct</gotten>|(crlf))
   }

#  If the act had an expectation of F
#   The act token is moved to F
#   the succeeding act is memorized as done instead of the previous one 

sp {Ernest*apply*current*intention*succeed*unexpected
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<ern>      ^ltm       <ltm>
               ^don       <don>)
   (<ltm>      ^act       <actF>)
   (<actF>     ^sch       <sch>
               ^sta       S)
   (<op>       ^name      intsuc
               ^act       <act>)
   (<act>      ^tok       int
               ^sch       <sch>
               ^sta       F)
   (<sch>      ^int       <int>
               ^wei       <wei>)
   (<int>      ^sch       <l1>
               ^sta       <exp>
               ^val       <val>
               ^tok       S)
-->
   (<ern>      ^don       <actF>
               ^don       <don> -)
   (<act>      ^tok       int -
               ^tok       F)
   (<int>      ^tok       S -)
   (<sch>      ^wei       <wei> -
               ^wei       (+ <wei> .02 ))
   
   (write |<gotten>| <int> |=| <l1> <exp> |(| <val> |) Incorrect</gotten>|(crlf))
   }

# CONTEXT FAIL 
# An act has a tok = con
# and a schema's context with a tok = F

sp {Ernest*propose*context*failed
   (state <s>  ^name      Ernest
               ^ern       <ern>)
   (<ern>      ^ltm       <ltm>)
   (<ltm>      ^act       <act>)
   (<act>      ^sch.con   <con>  
               ^tok       con)
   (<con>      ^tok       F)
-->
   (<s>        ^operator  <op> +)
   (<op>       ^name      confail
               ^act       <act>)
}

# if the act had a expectation of S
#  The act's token is moved to fai
#  Its schema's context is cleared
#  and the done act remains

sp {Ernest*apply*context*failed*unexpected
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      confail
               ^act       <act>)
   (<act>      ^sch.con   <con>
               ^tok       con
               ^sta       S)
   (<con>      ^tok       F
               ^val       <val>
               ^sta       <exp>
               ^sch       <l1>)
-->
   (<act>      ^tok       con -
               ^tok       F)
   (<con>      ^tok       F -)

   (write |<missed>| <con> | = | <l1> <exp> |(| <val> |) Incorrect</missed>|(crlf))
}

# If the act had an expectation of F
#  The act's token is moved to S
#  Its schema's context is cleared
#  and the done act remains
#  TODO or the done act should be the failing act

sp {Ernest*apply*context*failed*expected
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      confail
               ^act       <act>)
   (<act>      ^sch.con   <con>
               ^tok       con
               ^sta       F)
   (<con>      ^tok       F
               ^val       <val>
               ^sta       <exp>
               ^sch       <l1>)
-->
   (<act>      ^tok       con -
               ^tok       S)
   (<con>      ^tok       F -)

   (write |<missed>| <con> | = | <l1> <exp> |(| <val> |) Correct</missed>|(crlf))
}

# INTENTION FAIL 
# If there is an act with an token equal to int
# and its schema's intention is F
# Then create operator intfail

sp {Ernest*propose*intention*failed
   (state <s>  ^name      Ernest
               ^ern       <ern>)
   (<ern>      ^ltm       <ltm>)
   (<ltm>      ^act       <act>)
   (<act>      ^sch.int   <int>
               ^tok       int)
   (<int>      ^tok       F)
-->
   (<s>        ^operator  <op> +)
   (<op>       ^name      intfail
               ^act       <act>)
}

# If the act had an expectation of S
# The act's token is moved to fai
# Its schema's intention is cleared
# The don is cleared to be remplaced

sp {Ernest*apply*intention*failed*unexpected
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      intfail
               ^act       <act>)
   (<ern>      ^don       <don>
               ^ltm       <ltm>)
   (<act>      ^sch       <sch>
               ^sta       S)
   (<sch>      ^int       <int>)
   (<int>      ^sta       <exp>
               ^val       <val> 
               ^tok       F
               ^sch       <l1>)
-->
   (<act>      ^tok       int -
               ^tok       F)
   (<int>      ^tok       F -)
   (<ern>      ^don       <don> -)
   
   (write |<missed>| <int> | = | <l1> <exp> |(| <val> |) Incorrect</missed>|(crlf))
}
# If the act had an expectation of F
#  The act's token is moved to S
#  Its schema's intention is cleared
#  The don is cleared to be remplaced

sp {Ernest*apply*intention*failed*expected
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      intfail
               ^act       <act>)
   (<ern>      ^don       <don>
               ^ltm       <ltm>)
   (<act>      ^sch       <sch>
               ^sta       F)
   (<sch>      ^int       <int>)
   (<int>      ^sta       <exp>
               ^val       <val> 
               ^tok       F
               ^sch       <l1>)
-->
   (<act>      ^tok       int -
               ^tok       S)
   (<int>      ^tok       F -)
   (<ern>      ^don       <don> -)
   
   (write |<missed>| <int> | = | <l1> <exp> |(| <val> |) Missed</missed>|(crlf))
}


# Memorize the done schema
# its context is the context of the curent schema
# its intention is the last don act
# If it already exists

sp {Ernest*apply*intention*failed*done*exist
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      intfail
               ^act       <act>)
   (<act>      ^sch.con   <con>)
   (<ern>      ^ltm       <ltm>
               ^don       <int>)
   (<ltm>      ^act       <don>
               ^sch       <sch>)
   (<sch>      ^con       <con>
               ^int       <int>)
   (<don>      ^sch       <sch> 
               ^sta       S)
   -->
   (<ern>      ^don       <don>)

#   (write |<trace>| <don> |S (| <val> |) Unexpected</trace>|(crlf))
}

# If the done schema does not exist
# then create the done schema and the done act

sp {Ernest*apply*intention*failed*construct*done
   (state <s>  ^ern       <ern>
               ^operator  <op>)
   (<op>       ^name      intfail
               ^act       <act>)
   (<act>      ^sch.con   <con>)
   (<ern>      ^ltm       <ltm>
               ^don       <int>)
   (<con>      ^sch       <l1>
               ^sta       <l3>
               ^val       <val1>)
   (<int>      ^sch       <l2>
               ^sta       <l4>
               ^val       <val2>)
   - {(<ltm> ^sch <t>)(<t>  ^con <con> ^int <int>)}
-->
   (<ern>      ^don       <actS>)
   (<ltm>      ^act       <actS>
               ^act       <actF>
               ^sch       <sdon>)
   (<actS>     ^sch       <sdon>
               ^sta       S
               ^val       (+ <val1> <val2>))
   (<actF>     ^sch       <sdon>
               ^sta       F
               ^val       -5)
   (<sdon>     ^con       <con>
               ^int       <int>
               ^wei       1)

   (write |<construct>Construct | <actS> | = | <sdon> |S| (+ <val1> <val2>) | = ( | <con> | = | <l1> <l3>| , | <int> | = | <l2> <l4>| , 1 )</construct>|(crlf))
}

#endregion

#region Assess ############################

# TOKEN enact -> assess -> learn
# When the selected act has a tok = S or F

sp {Ernest*propose*token*assess
   (state <s> ^name     Ernest
              ^token    enact
              ^ern      <ern>)
   (<ern>     ^ena      <ena>)
   (<ena>     ^tok      << S F >>)
-->
   (<s>       ^operator <op> + )
   (<op>      ^name     assess
              ^ena      <ena>)
}

# Decrement the counter
# Clear the enacted act and the performed act
# The performed act is in the situation
# The performed act is a base for activation
sp {Ernest*apply*token*assess
   (state <s> ^cnt      <cnt>
              ^operator <op>
              ^token    <token>
              ^cnt      <cnt>
              ^ern      <ern>)
   (<op>      ^name     assess
              ^ena      <ena>)
   (<ern>     ^sit      <sit>
              ^don      <don>)
   (<ena>     ^tok      <tok>)
   (<don> ^sch <l1> ^sta <l2> ^tag <l3>)
    -->
   (<s>       ^token    <token> -
              ^token    learn
              ^cnt      <cnt> -
              ^cnt      (+ <cnt> 1))
   (<ern>     ^ena      <ena> -
              ^don      <don> -
              ^con      <don>)
   (<ena>     ^tok      <tok> -)    
   (<sit>     ^act      <don>)
   (write |<context>Situation done | <don> |=| <l1> <l2> | | <l3> |</context>|(crlf))
}

# If the performed act has an intention and it succeeded 
# then the intention is also in the situation
# (necessary for proposing same-level schema at the next cycle)
  
sp {Ernest*sit*don*sub
    (state <s> ^name     Ernest
               ^ern      <ern>
               ^operator <op>)
    (<op>      ^name     assess)
    (<ern>     ^sit      <sit>
               ^don      <don>)
    (<don>     ^sch      <sch> ^sta S)
    (<sch>     ^int      <int>)
    (<int>     ^sch      <l3> ^sta <l4> ^tag <l5>)
-->
    (<sit>     ^act      <int>)

    (write |<context>Situation done's intention | <int> |=| <l3> <l4> <l5>|</context>|(crlf))
}

# Succeeding act correctly enacted
# The performed act is observed
sp {Ernest*apply*token*assess*S*S
   (state <s> ^operator <op>
              ^ern      <ern>)
   (<op>      ^name     assess
              ^ena      <ena>)
   (<ena>     ^sta      S
              ^tok      S
              ^sch      <sch>
              ^tag      <tag>)
    -->
   (<ern>     ^obs      <ena>) 
   (write |<correct>Correct | <ena> |=| <sch> |S |<tag> |</correct>|(crlf))
}

# Succeeding act incorrectly enacted
# The observed act is the fail act
# The failing act is in the situation
# The failing act is a base for activation
sp {Ernest*apply*token*assess*S*F
   (state <s> ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     assess
              ^ena      <ena>)
   (<ern>     ^ltm      <ltm>
              ^don      <don>
              ^sit      <sit>)
   (<ltm>     ^act      <fai>)
   (<ena>     ^sta      S
              ^tok      F
              ^sch      <sch>)
   (<fai>     ^sch      <sch>
              ^sta      F 
              ^tag      <tag>)
   (<don>     ^sch <l1> ^sta <l2> ^tag <l3> )
-->
   (<ern>    # ^don      <fai>
             # ^fai      <fai> 
              ^suc      <don>
              ^obs      <fai>
              ^con      <fai>)
   (<sit>     ^act      <fai>) 
   (write |<incorrect>Incorrect | <don> |=| <l1> <l2> | | <l3> |</incorrect>|(crlf))
   (write |<context>Situation fail | <fai> |=| <sch> |F | <tag> |</context>|(crlf))
   (write |<rational>Oh!</rational>|(crlf))
}

# Failing act succeeded (incorrect enaction)
# The observed act is the succeeding act
sp {Ernest*apply*token*assess*F*S
   (state <s> ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     assess
              ^ena      <ena>)
   (<ern>     ^ltm      <ltm>
              ^don      <don>)
   (<ena>     ^sta      F
              ^tok      F
              ^sch      <sch>)
   (<don>     ^sch      <sch>
              ^sta      <sta> 
              ^tag      <tag>)
-->
   (<ern>     ^obs      <don>) 
   (write |<incorrect>Incorrect | <don> |=| <sch> <sta>| |<tag> |</incorrect>|(crlf))
   (write |<rational>Oh!</rational>|(crlf))
}

# Failing act Failed (correct enaction)
# The observed act is the enacted act
sp {Ernest*apply*token*assess*F*F
   (state <s> ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     assess
              ^ena      <ena>)
#   (<ern>     ^don      <don>)
   (<ena>     ^sta      F
              ^tok      S
              ^sch      <sch>
              ^tag      <tag>)
    -->
   (<ern>     ^obs      <ena>) 
   (write |<correct>Correct | <ena> |=| <sch> |F |<tag> |</correct>|(crlf))
}

#endregion

#region Learn #############################

# TOKEN assess -> learn -> context

sp {Ernest*propose*token*learn
   (state <s> ^name     Ernest
              ^token    learn)
-->
   (<s>       ^operator <op> + )
   (<op>      ^name     learn)
}

sp {Ernest*apply*token*learn
   (state <s> ^operator <op>
              ^token    <tok>)
   (<op>      ^name     learn)
    -->
   (<s>       ^token    <tok> -
              ^token    forget)
}

# ASSESS FAIL
# If the schema has failed and its act has a val (satisfaction value)
# the val is the average between the previous val and the don schema val

sp {Ernest*apply*val*fail*update
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     learn)
   (<ern>     ^suc      <don>
              ^obs      <fai>
              ^thi      <= 0)
   (<fai>     ^sch      <sch>
              ^val      <val1>
              ^tag      <tag1>
              ^sta      F)
   (<don>     ^val      <val2>
              ^tag      <tag2> )
   - (<ern>   ^dre      <t>)
-->
   (<ern>     #^fai      <fai> -
              ^suc      <don> -) 
   (<fai>     ^val      <val1> - 
              ^val      <val2> #(/ (+ <val1> <val2>) 2 )
              ^tag <tag1> -
              ^tag <tag2>)       
   (write |<construct>Fail | <fai> | = | <sch> |F ( | <val1> | -> | <val2> | ) from | <don> |</construct>| (crlf))
   }

# LEARN BY OBSERVATION (first learning mechanism)
# Search the existing schemas that match the obtained situation 
# Their context is the previous context 
# Their intention is the done schema
# They are part of the new situation
# Increment their weight

sp {Ernest*apply*assess
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     learn)
   (<ern>     ^obs      <int>
              ^temp     <sit>
              ^ltm      <ltm>
              ^stm      <stm>
              ^thi      <= 0)
   (<stm>     ^act      <con>)
   (<ltm>     ^sch      <don>
              ^act      <act>)
   (<act>     ^sch      <don>
              ^sta      S
              ^tag      <tag>)
   (<don>     ^con      <con>
              ^int      <int>
              ^wei      <wei> ) 
   (<con> ^sch <l1> ^sta <l2>)(<int> ^sch <l3> ^sta <l4>)
   - (<ern>   ^dre      <t>)
     -->
   (<sit>     ^act      <act>)
   (<don>     ^wei      (+ <wei> 1)
              ^wei      <wei> - )
   
   (write |<reinforce>Observe | <act> |=| <don> |S = ( | <con> |=| <l1> <l2> | , | <int> |=| <l3> <l4> | , | (+ <wei> 1) | ) | <tag> |</reinforce>| (crlf))
}

# Construct higher level schemas that do not exist
# Construct their succeed and fail acts
# their succeeding act is in the situation
# Their fail value is set to -5. Ernest is not able to assess the real cost of failure, but he just doesn't like to fail.

sp {Ernest*apply*construct
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     learn)
   (<ern>     ^obs      <don>
              ^ltm      <ltm>
              ^stm      <stm>
              ^temp      <sit>
              ^thi      <= 0)
   (<stm>     ^act      <c>)
   (<c>       ^sch      <con>
              ^sta      <sta>
              ^val      <val1>)
   (<don>     ^sch      <ena>
              ^sta      <exp>
              ^val      <val2>)
   - {(<ltm> ^sch <t> )(<t> ^con <c> ^int <don> )}
   - (<ern>   ^dre      <t>)
#     (<ena>   ^do       <do>) # limit level
#     (<con>   ^do       <do2>) # limit level
-->
   (<ltm>     ^sch      <ss>
              ^act      <act>
              ^act      <actF>)
   (<sit>     ^act      <act>)
   (<act>     ^sch      <ss>
              ^sta      S
              ^val      (+ <val1> <val2>))
   (<actF>    ^sch      <ss>
              ^sta      F
              ^val      -5 ) 
   (<ss>      ^con      <c>
              ^int      <don>
              ^wei      1)
   
   (write |<construct>Observe | <act> |=| <ss> |S(| (+ <val1> <val2>) |) = ( | <c> |=| <con> <sta> | , | <don> |=| <ena> <exp> | , 1 )</construct>| (crlf))
}

# LEARN BY INDUCTION (second learning mechanism)
# For all activated acts
# If the schema intention matches what was done
# then they are completed
# if the higher schema does not exist then it is created
 
sp {Ernest*apply*done*cur
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     learn) #limits learning
   (<ern>     ^ltm      <ltm>
              ^wom      <wom>
              ^obs      <don>
              ^temp      <tmp>
              ^thi      <= 0) 
   (<wom>     ^cur      <cur>)
   (<cur>     ^sit      <sit>
              ^act      <act>)
   (<sit>     ^act      <con>)
   (<con>     ^sta      <get>
              ^sch      <l1>
              ^val      <val1>)
   (<act>     ^sch      <sch>)
   (<sch>     ^int      <don>)
   (<ltm>     ^act      <int>)
   (<int>     ^sch      <sch>
              ^sta      S
              ^val      <val2>)
   - {(<ltm> ^sch <t>)(<t> ^con <con> ^int <int>)}
   - (<ern>   ^dre      <t>)
-->
   (<ltm>     ^sch      <sec>
              ^act      <actS>
              ^act      <actF>)
   (<tmp>     ^act      <actS>)
   (<actS>    ^sch      <sec>
              ^sta      S
              ^val      (+ <val1> <val2>))
   (<actF>    ^sch      <sec>
              ^sta      F
              ^val      -5 ) 
   (<sec>     ^con      <con>
              ^int      <int>
              ^wei      1) 
   (write |<complete>Confirm | <actS> | = | <sec> |S(| (+ <val1> <val2>) |) = ( | <con> |=| <l1> <get>| , | <int> |=| <sch>|S , 1)</complete>|(crlf))
}

# if the second order schema already exists
# then reinforce it
# Its succeeding act is in the situation

sp {Ernest*apply*done*cur*reinforce
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     learn)
   (<ern>     ^ltm      <ltm>
              ^wom      <wom>
              ^obs      <don>
              ^temp      <tmp>
              ^thi      <= 0)
   (<ltm>     ^act      <act>
              ^sch      <sec>)
   (<wom>     ^cur      <cur>)
   (<cur>     ^sit      <sit>
              ^act      <act2>)
   (<sit>     ^act      <con>)
   (<act2>     ^sch      <sch>)
   (<act>     ^sch      <sec>
              ^tag      <tag>
              ^sta      S)
   (<sec>     ^con      <con> 
              ^int      <int>
              ^wei      <wei> )
   (<con>     ^sta      <l2>
              ^sch      <l1>)
   (<int>     ^sch      <sch>
              ^sta      S)
   (<sch>     ^int      <don>)
   - (<ern>   ^dre      <t>)
        -->
   (<tmp>     ^act      <act>) 
   (<sec>     ^wei      (+ <wei> 1)
              ^wei      <wei> -) 
   (write |<complete>Confirm | <act> | = |<sec>|S = ( | <con> |=|<l1> <l2>| , | <int> |=|<sch>|S , |(+ <wei> 1)|) | <tag> |</complete>|(crlf))
}

# Clear working memory
# TODO keep ongoing activations?

sp {Ernest*apply*abort*cur
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     learn)
   (<ern>     ^wom      <wom>)
-->
    (<ern>     ^wom     <wom> -
               ^wom     <mwom>)
}

#endregion

#region forget #############################
# (not currently used)

# TOKEN assess -> learn -> context

sp {Ernest*propose*token*forget
   (state <s> ^name     Ernest
              ^token    forget)
-->
   (<s>       ^operator <op> + )
   (<op>      ^name     forget)
}

sp {Ernest*apply*token*forget
   (state <s> ^operator <op>
              ^token    <tok>)
   (<op>      ^name     forget)
    -->
   (<s>       ^token    <tok> -
              ^token    context)
}

sp {Ernest*apply*forget
   (state <s> ^ern      <ern>
              ^operator <op>
              ^token    <tok>)
   (<op>      ^name     forget)
   (<ern>     ^ltm      <ltm>)
   (<ltm>     ^sch      <sch>)
   (<sch>     ^wei      <wei> > 0)
    -->
   (<sch>     ^wei      <wei> -
              ^wei      (- <wei> .01))
}

sp {Ernest*apply*clear
   (state <s> ^ern      <ern>
              ^operator <op>
              ^token    <tok>)
   (<op>      ^name     forget)
   (<ern>     ^ltm      <ltm>)
   (<ltm>     ^sch      <sch>
              ^act      <act>)
   (<act>     ^sch      <sch>
              ^sta      <sta>
              ^eff      <eff>
              ^tag      <tag>)
   (<sch>     ^wei      <wei> <= 0)
   
    -->
   (<ltm>     ^sch      <sch> -
              ^act      <act> -) 
   (write |<forget>Forget | <act> |=| <sch> <sta> <tag>|</forget>|(crlf))
}

#endregion

#region Situation #########################

# token context  -> trace

sp {Ernest*propose*token*memo
   (state <s> ^name     Ernest
              ^token    context)
-->
   (<s>       ^operator <op> + )
   (<op>      ^name     context)
}

sp {Ernest*apply*token*memo
   (state <s> ^operator <op>
              ^token    <tok>)
   (<op>      ^name     context)
-->
   (<s>       ^token    <tok> -
              ^token    select)
}

# SITUATION
# Creates the curent situation
# Includes the done act 
 
sp {Ernest*sit*don
    (state <s> ^name     Ernest
               ^ern      <ern>
               ^operator <op>)
    (<op>      ^name     contextooooo)
    (<ern>     ^sit      <sit>
               ^don      <don>)
    (<don>     ^sch      <sch> 
               ^sta      <l2>
               ^tag      <tag>)
    -->
    (<sit>     ^act      <don>)
    
    (write |<context>Situation done | <don> |=| <sch> <l2> | | <tag> |</context>|(crlf))
}

# The top situation acts are in the situation
# Only if their schemas are based on frozen schemas

sp {Ernest*apply*memo*context
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     context)  
   (<ern>     ^sit      <sit>
              ^temp     <tmp>)
   (<tmp>     ^act      <act>)
   (<act>     ^sch      <sch>
              ^sta      <sta>
              ^tag      <tag>)
   (<act>     ^sch.con.sch.wei  <wei1> > 4)
   (<act>     ^sch.int.sch.wei  <wei2> > 4)
-->
   (<sit>     ^act      <act>)
           
   (write |<context>Situation top | <act> |=| <sch> <sta> | | <tag> |</context>| (crlf))
}

# ACTIVATION
# Succeeding Acts that have a schema that is in the situation are activated
# The activation is associated to the previous situation
# (Acts from the curent situation do not create activation because their context is lost anyway)
# (The previous situation will be kept as long as there is an activated schema based on it)

sp {Ernest*propose*activate*schema*don
   (state <s> ^name      Ernest
              ^ern       <ern>
              ^operator  <op>)
   (<op>      ^name      context)
   (<ern>     ^stm       <stm>
              ^ltm       <ltm>
              ^wom       <wom>
              ^con       <don>)
   (<ltm>     ^act       <act>)
   (<act>     ^sch       <sch>
              ^tag       <tag>
              ^sta       S)
   (<sch>     ^con       <don>
              ^int       <int>
              ^wei       <wei>)
   (<don>     ^sch       <l3> ^sta <sta> )
   (<int>     ^sch       <l4> ^sta <sta2>)
-->
   (<wom>     ^cur       <cur>)
   (<cur>     ^sit       <stm>
              ^act       <act>)
     
   (write |<activate>Activate | <act> | = |<sch> |S = ( | <don> |=| <l3> <sta>| , | <int> |=| <l4> <sta2> | , |<wei> |) | <tag> |</activate>|(crlf))
}

# Activate schema from the don's intention

sp {Ernest*propose*activate*schema*don*int
   (state <s> ^name      Ernest
              ^ern       <ern>
              ^operator  <op>)
   (<op>      ^name      context)
   (<ern>     ^ltm       <ltm>
              ^wom       <wom>
              ^con       <don>)
   (<don>     ^sch       <donsch> ^sta S)
   (<donsch>  ^con       <doncon>
              ^int       <donint>)
   (<ltm>     ^act       <act>)
   (<act>     ^sch       <sch>
              ^tag       <tag>
              ^sta       S)
   (<sch>     ^con       <donint>
              ^int       <int>
              ^wei       <wei>)
   (<donint>     ^sch       <l3> ^sta <sta> )
   (<int>     ^sch       <l4> ^sta <sta2>)
-->
   (<wom>     ^cur       <cur>)
   (<cur>     #^sit       <sit>
              ^act       <act>)
#   (<sit>     ^act       <doncon>) Dont construct schema by confirmation from an int activation
     
   (write |<activate>Activate int | <act> | = |<sch> |S = ( | <donint> |=| <l3> <sta>| , | <int> |=| <l4> <sta2> | , |<wei> |) | <tag> |</activate>|(crlf))
}

# Activates schema from the top situation
# These activations are used for the selection but not for the learning 
# because they are not attached to any situation.

sp {Ernest*propose*activate*schema*temp
   (state <s> ^name      Ernest
              ^ern       <ern>
              ^operator  <op>)
   (<op>      ^name      context)  
   (<ern>     ^ltm       <ltm>
              ^wom       <wom>
              ^temp      <tmp>)
   (<tmp>     ^act       <con>)
   (<ltm>     ^act       <act>)
   (<act>     ^sch       <sch>
              ^tag       <tag>
              ^sta       S)
   (<sch>     ^con       <con>
              ^int       <int>
              ^wei       <wei>)
   (<con>     ^sch       <l3> ^sta <sta> )
   (<int>     ^sch       <l4> ^sta <sta2>)
   (<con>     ^sch.con.sch.wei  > 4)
   (<con>     ^sch.int.sch.wei  > 4)
   -->
   (<wom>     ^cur       <cur>)
   (<cur>     ^act       <act>)
     
   (write |<activate>Activate top | <act> | = |<sch> |S = ( | <con> |=| <l3> <sta>| , | <int> |=| <l4> <sta2> | , |<wei> |) | <tag> |</activate>|(crlf))
}

# SHIFT
# The curent situation becomes the short term memory situation
# and the previous stm is only supported by the activations

sp {Ernest*apply*memo*clear*old*context
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     context)
   (<ern>     ^stm      <stm>
              ^sit      <sit>)
-->
   (<ern>     ^stm      <stm> -
              ^stm      <sit> 
              ^sit      <sit> -)    
      
#   (write |<trace>Clear old context </trace>| (crlf))
}

# CLEAR
# Clear the done acts

sp {Ernest*apply*memo*clear*obs
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     context)
   (<ern>     ^obs      <don>)
-->
   (<ern>     ^obs      <don> -)
}
sp {Ernest*apply*memo*clear*con
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     context)
   (<ern>     ^con      <don>)
-->
   (<ern>     ^con      <don> -)
}

# Clear the temporary situation

sp {Ernest*apply*memo*clear*context
   (state <s> ^name     Ernest
              ^ern      <ern>
              ^operator <op>)
   (<op>      ^name     context)
   (<ern>     ^temp      <sit>)
-->
   (<ern>     ^temp      <sit> -)
}

# If the done act is secondary 
# and it is a repetition
# then say Bored!

#sp {Ernest*apply*boring
#   (state <s> ^name     Ernest
#              ^ern      <ern>
#              ^operator <op>
#              ^cnt      <cnt>
#              ^token    <tok>)
#   (<op>      ^name     context)
#   (<ern>     ^don      <act>)
#   (<act>     ^sch.con  <con>
#              ^sch.int  <con>
#              ^tag      <tag>
#              ^val      <val>
#              ^cnt      <ste>) 
#   (<con>     ^sch.con  <t2>)
##   - (<ern>     ^sta      dream)
#-->
##   (<ern>     ^sta      dream)
#   (<s>        ^name     Ernest -
#               ^ern      <ern> -
#               ^token    <tok> -
#               ^cnt      <cnt> - )
#   (write |<rational>Bored!</rational>|(crlf))
##   (write |<trace>Stop,| <cnt> |,| <val> |,| <ste> |,| (/ <val> <ste>)|,| <tag> |</trace>|(crlf))
#   }

#endregion

#region Trace #############################

# When a new act is constructed 
# its tag is the concatenation of its con and int tags

sp {Ernest*tag*act
    (state <s> ^name     Ernest
               ^ern      <ern>)
    (<ern>     ^ltm      <ltm>)
    (<ltm>     ^act      <act>)
    (<act>     ^sch.con  <con>
               ^sch.int  <int>
               ^val      <val>)
    (<con>     ^tag      <tag1>
               ^cnt      <cnt1>)
    (<int>     ^tag      <tag2>
               ^cnt      <cnt2>)
-->
    (<act>     ^tag      (concat <tag1> <tag2>)
               ^cnt      (+ <cnt1> <cnt2> )
               ^eff      (/ <val> (+ <cnt1> <cnt2> )) )
}

# If the done act is secondary 
# and it is not a repetition
# then say Good!

#sp {Ernest*trace*secondary
#   (state <s> ^name     Ernest
#              ^ern      <ern>
#              ^token    context)
#   (<ern>     ^don      <act>)
#   (<act>     ^sch.con  <con>
#              ^sch.int  <int> {<> <int> <con>})
#              ^sch.int  <con> {<> <int> <con>})
#              ^sch.int  <int> <> <con>)
#      (<int>     ^sch.con  <t2>)
#-->
#   (write |<rational>Good!</rational>|(crlf))
#}

#endregion