rootgoal ::= "(" make-root-goal <agent-name> <goal-description> ")"

agent-name ::= <symbol>

symbol ::= letter[{<any_character>}]

goal-description ::= "(" list <consequent> [<goal-rest>] ")"

goal-rest ::= <goal-name> | <goal-name> <goal-type> |
              <goal-name> <goal-type> <goal-url>

goal-name ::= <string>

string ::= """<letter>[{<any_character>}]"""

goal-type ::= <string>

goal-url ::= <string>

consequent :== <string> | "(" list {<consequent>} ")"

applicablestatement ::= "(" applicable-operator <op-name>  <goal-var> ")"

admissiblestatement ::= "(" admissible-operator <op-name> 
                        <parameters> <goalnameorvar> ")"

goalnameorvar ::= <goal-name> | <goal-var>

<goal-var> ::= <var>

<var> ::= "?"<symbol>

op-name ::= <string>

<parameters> ::= "(" {<stringvar>} ")"

stringvar ::= <var> | <string>

assignmentstatement ::= "(" assignment <op-name> <parameters>
                        <assignment> "}"

assignment ::= "(" list <stringvar> <stringvar> <stringvar> ")"

inputs ::= "(" inputs <op-name> <parameters>
          "(" {<assignment>} ")" ")"

contingencies ::= "(" contingencies <op-name> <parameters>
          "(" { "(" <string> [{<stringvar>}] ")" } ")" ")"

subgoalstatement ::= "(" subgoal <op-name> <parameters>
                      <goal-description> ")"

goalpreference ::= "(" prefer-goal <goalnameorvar> <goalnameorvar> ")"

operatorpreference ::= "(" prefer-operator  
                       "(" <opnameorvar> <parameters> ")"  
                       "(" <opnameorvar> <parameters> ")" 
                       <goalnameorvar> ")"

opnameorvar :== <op-name>|<var>

reduxrulehead ::= <applicablestatement> | <admissiblestatement> |
                  <assignmentstatement< | <subgoalstatement> | 
                  goal-preference | operatorpreference |
                  inputs | contingencies
  
reduxrule ::= "(" <= reduxrulehead  {<condition>} ")"

<condition> ::= "(" <symbol> {<string> | <symbol> | <var>} ")"

=================

Some common examples of conditions are:
  (REDUX "Goal-Type" ?goal "plan-service"))
  (REDUX "consequent" ?goal  ("curent-state" ?state))
If these two conditions occur in a rule, then ?goal
will unify only with those goals that of goal-type "plan-service"
and have a matching consequent; e.g., ("current-state" "s0").

The opname should be the same in at least one pair of applicability
and admissibility statements: this defines an operator. One such pair
should unify with each goal initially defined. At least one subgoal or
one assignment statement should be associated with each operator
defined.

The assignment and subgoals should be for an op-name for which
admissibility is defined: otherwise they will be useless. The
paramenters must similarly be consistent between an admissibility
statement and the associated assignment and subgoal pairs. (The 
same is true for the less-frequently used contingency and input 
statements.)  

Any opname or goalname mentioned in a preference should match a
defined operator or goal. 

A good editor would detect mismatches and alert the developer.