2006-07-06:

Must the !_val of a Literal be a string?  Why not a number or symbol
if appropriate?  (A symbol could stand for itself or a rigid object
designator grounded some way.)


2006-02-26:

'this-step' machinery in action.lisp is obolete.


2006-02-19:

Alternatives contexts & mechanisms for returning values from actions,
processes, and expansions:

- In atomics, value needn't be returned, but it can be
    :value (b - Boolean)
    :effect (and (when (foo) (= b true))
                 (when (not (foo)) (= b false)))

    Better written (return (foo)) [= withOutput in Owl-S]
    [2006-02-26: There's an emerging difference between terms,
    actions, and predicates.  You can't return a predicate value,
    because it's not an evaluable term; it denotes a Prop, not a
    Boolean.  I guess you could write (return (current-value (foo))),
    and (hmmm), opt-eval currently coerces fluents to their current
    values, so you _can_ write (return (foo)), or (output (foo)), or
    whatever.]

- Processes should have values, and :stop-effects should have whatever
  facilities :effects have.
  For that matter, you could have :start-values and :stop-values.
  (But there's no real need for :start-values, because these can
  always be effects of the event that starts the process.)

- Duratives correspond to dur-start action followed by processes,
  terminated by dur-stop or natural causes.  It's natural to give a
  durative a :value clause.  If there's no dur-stop part, then the
  clause is associated with the dur-happening process.  Even if there
  is a dur-stop, it operates by removing a condition for the
  dur-happening process, so the value still belongs there.

It could be useful to have :event definitions.  An event is just like
a process, except that it is instantaneous, so it has effects
immediately.  It is well defined only if its effects delete its
condition.  (Our semantics forbid simultaneous events, so we can't
have two events that together wipe out each other's conditions.)


2005-02-12:

Somewhere we should take note of the peculiar role of 'quote' in the
Opt system.  It is not a mediator between program and data as in the
normal Lisp world.  Instead, it persists in data for the purpose of
distinguishing between rigid constants such as 'true' and
symbols-as-data, such as '(quote true)'.  

How are Rigids handled in the Qexp system?  Are they a special kind of
atom?

If there is just one :input link, then its fields should be accessible
using the !> notation.


2005-12-03:

Can the 'atom' qexp-class be used for literals?  The 'quote' would
have to be explicit, in order to distinguish between a and (quote a),
and, for that matter, "abc" and (quote "abc").  The cool part is that,
because atoms already have the lowest u-priority, nothing would unify
with the inside of a literal.


2005-11-03:

If term is of form (f ...), and f is (Fun y <- ...), then the system
should be able to infer that (is y term). [done]


Argspec property "seg" is apparently inconsistently used and probably
useless. 


2005-10-29

(!& make <type> ...) is problematic because !& is handled inside
lisplang, which doesn't know that 'make' isn't a function.  We need to
postpone the higher-order stuff until the handler for whatever
Lisp dialect we're in can get ahold of the form. ["Solution": In
(!& f ...), if f has a handler, we pass the form to it with the !&
moved to the end: (f ... !&).  The handler must know what to do with
it.  The syntactic context is left the same, which might be wrong.]


2005-10-23:

Apparently variable-free syntax for &rest parameters is broken.  
   &rest -- <type>
generates syntax errors.  Oops: Forgot what the syntax was!  It's 
&rest (= <type>), which works fine.


2005-10-01:

The durative expansion omits the :value of the action, which should
become the value of the dur-happening process.


2005-09-26:

Method definitions don't work as described in the manual.  The manual
implies that the parameters are implicitly declared to be the same as
the vars of the action the method belongs to.  But the implementation
looks for a complete function definition, thus allowing a method to
specialize on some of its arguments. [This isn't the right thing; the
parser should look for a term unifiable with the term for the
function. 2006-01-02] 


2005-08-20:

Quick thought on literals: Let (quote <l>) be a context such that
nothing can be quantified into the arg position.  (quote "abc") is the
literal "abc",which is _not_ equal to the string "abc".  We will,
though, have something like (lit-val (quote "abc") "abc").  The object
of 'know-val-is' is a literal.  (quote "abc") is of type (Lit
String).  So 'know-val-is' is of type

    (Fun (Fluent Boolean) <- ((Literal y) !& y))

You can say 
(exists (x) (know-val-is x)), 
but not (exists (x) (know-val-is (quote x)))


Shorthand for input links: In '(link :input L A)', for each input link
L, bind one var for each slot.  Its type should be an artificial
'Link-slot' type.  Then 'var-val-typed-exp' can coerce it to the
proper function of L.  [Not its type, its _val_ - 2005-09-18]




2005-08-18:

We're going to need Qexp-classes for all the "special operators" in
the Opt action language, such as 'with-links', 'link', 'foreach',
etc.  In particular, 'with-links' should be a binder like 'forall' and
'exists'.   


2005-08-13:

Suppose in switching to the "q" branch that we base the resulting code
on Nisp, and factor the whole deduction module (everything dependent
on index.lisp) out.  

    File dependency graph: 

    13: requirements
     . 12: builtins
     .  . 11: coerce
     .  .  . [deduction 10]
     .  .  . 9: checker
     .  .  .  . [definers 8]
    11: context
     . [deduction 10]
     . 8: definers   ^checker
     .  . [parsers 7]
    11: reduction
     . 10: deduction   ^context ^coerce
     .  . 9: dedutils
     .  .  . 8: assertion
     .  .  .  . 7: internalize
     .  .  .  .  . [process 6]
     .  .  .  .  . [axiom 5]
     .  .  .  . 6: index
     .  .  .  .  . [action 5]
     .  .  .  .  . 2: expdt
     .  .  .  .  .  . [types 1]
     .  .  .  .  .  . [symboid 0]
     .  .  .  .  . 2: varsubst
     .  .  .  .  .  . 1: unify
     .  .  .  .  .  .  . <0: symboid>   ^expdt
     .  .  .  .  . 0: setindex

Everything above this point could be nispified, except 'checker',
'definers', and perhaps 'setindex'.
Everything below here is syntax checker

     .  . 7: parsers   ^definers
     .  .  . 6: process   ^internalize
     .  .  .  . 5: action   ^index
     .  .  .  .  . [more-syntax 4]
     .  .  .  .  . 4: expansion
     .  .  .  .  .  . [syntax 3]
     .  .  .  .  .  . <0: defectexp>
     .  .  .  .  . <0: nilscompat>
     .  .  .  .  . [funcheck 0]
     .  .  . 5: axiom   ^internalize
     .  .  .  . 4: more-syntax   ^action
     .  .  .  .  . 3: syntax   ^expansion
     .  .  .  .  .  . 2: basics
     .  .  .  .  .  .  . 1: types   ^expdt
     .  .  .  .  .  .  .  . <0: typeconseq>
     .  .  .  .  .  .  .  . <0: typedexp>
     .  .  .  .  .  .  .  . <0: typeintsect>
     .  .  .  .  .  .  .  . <0: namespace>
     .  .  .  .  .  .  . <0: synutils>
     .  .  .  .  .  . <0: flagsource>
     .  .  .  .  .  . <0: teshow>
     .  .  .  .  .  . <0: bvarparse>
     .  .  .  .  .  . <0: typecheck>
     .  .  .  .  .  . <0: unkelim>
     .  .  .  .  .  . <0: tvarelim>
     .  .  .  .  .  . <0: typebounds>
     .  .  .  .  .  . <0: slot>
     .  .  .  . <0: funcheck>   ^action

2005-06-29:

Opt needs its own readtable, so other YTools module files can be read
even though @ is redefined.  Perhaps yt-bibtex needs one, too, for the
cases of !* and !@.


2005-06-12:

Syntax should be extended to allow (forall 1 (u < Animal) ...) or
whatever. 


2005-06-10:

If we allow (forall (x - u !& u - (T)) (P x)), how can we forbid its
negation?

Suppose we want to prove a 'forall'; as a goal, it is essentially
negated.  (forall (x - (Lst ?u)) (= (reverse (reverse x)) x))

Would it do to contemplate 
   (forall (u - (T))
      (exists (x - (Lst u))
          (not (= (reverse (reverse x)) x))))
This is stronger than the negation, so if it leads to a contradiction,
then it doesn't prove what we wanted it to.

Better idea: In (exists ( ... !& u - (T)) ...), bind u to an
unk-type.  (Or vice versa: universals are unk types, existentials are
typevars) 


2005-06-09:

maxmatcher might want to focus on binding action variables first,
because remaining vars can be sampled to give plausible subgoals and
costs.  As long as the action is in the running, we'll get chances
later to reason in detail about its impact.

Another observation: If all variables are assigned, and the remaining
goals in the maxmatch have all been seen before (in this maxmatch),
then it's likely that there's no point in completing the match,
because the literals we get are probably not going to be arranged in a
pattern radically different from the ones we already have.

If goals can be partitioned into sets not sharing variables, then we
can find matches for the sets separately and take the Cartesian
product (although there's no point in actually producing the whole
thing). 

For a given action, we can cache matches for various bindings. (?)

2005-06-08:

Action (deduce (-vars-) pattern) is satisfied when there is a solution
(if more than one, pick arbitrarily).  Any input and output links can
be used as variables without declaring them.

   (link :input x (deduce () (p ?x ?y)) :output y)

Outputs must be variable-free.  (Note similarity of this action to the
macro 'deduce'.)

Uterms now have Qexps as terms.  But Qexps are define in qunify.lisp,
which depends on types.lisp, where Uterms are defined.  Obviously,
Qexp declaration should be moved to types.lisp.


2004-05-10:

We need a smoother way to call 'deduce' at a listener so it won't
matter that I keep forgetting that you have to use the domain local to
an initial situation.

2004-12-02:

'formula-antecedent-atoms' (in dedutils) should surely return !(), not
(list fmla), when given an ordinary atom.


2004-12-01:

Handling prelinks without finding linkspots during internalization: 
We assume that all ways of handling goal with predicate P will be
known by the time the domain is defined.  

So if you're internalizing a rule, and you find a goal with P,
internalize all the P rules if not already internalized, then do all
matches.  Result: In general you return n (>= 0) instances of the
rule. 

2004-11-26:

Implement 'result' and 'collect-value' as described in the Opt manual.
[Addendum 2005-06-07: 'result' should be 'value'; 'collect-value'
should be subsumed by 'compute' _and_ 'destructure', no?]

2004-11-16:

The variable pddl2.1-compatible* should be called pddl-compatible*.

2004-10-25:

'assertion-add' must take a Qexp as argument, but it's almost always
called using a backquoted Sexp.  So we must combine quoted material
with Qexps to be substituted in.  

Similarly for assertion-fetch E.g., in 'trigger-forward-rules', we
want to substitute the given 'pat' for ?ante and let ?conse be a new
variable, then call 'sit-assertion-fetch' on the resulting pattern.


2004-10-17:

In 'qexp-classes.lisp', shouldn't have to ensure that the
data-structures domain exists!  (Move 'list' to global-opt-env*.)
[done]


2004-10-15:

index-pat-maker in Qexp-handler should take an argument saying whether
the pattern is for indexing or fetching.  Also, it needs a Bdgenv
argument, or should be applied only to Qexps with all variables
substituted with values from a Bdgenv.

'symbolify' in expdt.lisp doesn't know about namespaces or
Canonized-symbols. 

In cases where we really do need to feed an S-expression to 'deduce',
there must be some way of factoring the operation into two pieces: a
type-checkable phase at compile time, and a substitution at run time.

2004-10-07:

place-qexp-index-pat and get-qexp-sexp should probably take id and env
arguments.  The implied varsubst would be folded into the
computation.  Ooops -- can't cache it if it depends on id and env.
Another reason to cache indexer and not sexper.  Another possibility
is to cache the generator of index positions.

2004-09-17:

Notes on (q)unification -- 

Occur-checker is a bit trickier than expected.  If a variable occurs
twice, then we can't postpone the occur-check to the end (because
first value may be circular, so we may get an infinite recursion).
Solution: Bind var tentatively to (*unchecked exp).  (Maybe a new
qexp-class?)  At the end of unification we run through the env and
resolve all the *uncheckeds by doing occur-check.  If we need a qvar's
value before the end, we resolve it when we need it.  This may mean
that 'qexp-normalize', when called inside the unifier, must be
prepared to encounter a circular var refeerence.

2004-08-04:

Does scope-time* need to be incremented in derived-parse?

2004-07-29:

Do multiple :namespace fields really make sense in Opt?  Won't any
namespace have to be associated with at least a skeletal domain?
Would it hurt to require that?


2004-07-28:

(define (domain B)
   (:partial "http:// ...")    ; :partial and :remote are the same
   (:objects doe - Fowl)
   ...)

(define (domain A)
   (:extends (:name B :prefix "b"))
   (:namespace (:name B :prefix "c"))
   (:objects c:doe - Fish)
   ...)

Are the symbols b:doe and c:doe the "same" symbol?  If not, do they
refer to the same object?  Is it Fish or Fowl?

Perhaps a URI can't be used as both a namespace and a domain.


2004-07-27:

Perhaps ':alludes-to' is too confusing.  An alternative would be to
provide a "partial definition" facility.  I.e., replace this:

(define (domain foo)
   (:alludes-to (:domain "http://a.b.org/baz.opt"
			 :prefix "baz"))
   ...)

with

(define (domain baz)
  (:remote  "http://a.b.org/baz.opt")
   ...)

(define (domain foo)
   (:extends (domain baz :prefix :baz"))
   ...)

where the first 'define' is a partial definition of a remote ontology,
as signaled by the URL.  

The advantage is that :alludes-to declares symbols such as 'baz:x'
"telekinetically," as it was.  The reader has to realize they're not
being redefined in 'foo'.  

When an ontology is redefined, rather than overwrite any previous
definition, one has to check if there is an existing remote
definition, and if so save it somewhere and check that it's true after
installing the new definition.  

We need a domain-local variable <Remote URI>; when defining a domain,
if the value of this variable is non-false, we know we have to do the
save-recheck described above.

-------

For portability: Get rid of references to 'net.uri' package.


2004-07-25:

Key requirement to make :alludes-to work is that symbol S, when it
resolves to non-local Canonized-symbol C, be checked in the domain
that "owns" C's namespace.


2004-07-24:

:alludes-to still doesn't do the trick.  We still don't have the XML
option of a productive but inert namespace, that is, a namespace that
two web agents can both use, but never anticipate loading, that, in
fact, may not correspond to anything loadable.

Perhaps :alludes-to can cover this, but picture this scenario:
Ontology A alludes to namespace S with prefix 's'.  Loading A declares
a bunch of symbols s:one, s:two, etc.  Now you load B, which also
alludes to S, with prefix 'p'.  If B declares p:two, then the
declaration must be consistent with A's declaration about s:two.
Currently the declaration of s:two is in A; should it be in S in some
sense, so that B can see it?

Retry: In RDF, namespaces have nothing to do with scoping, since there
is no scoping.  (Use of bare fragments such as "#foo" looks like
scoping because the current document provides a default URI to go in
front of the "#", but that's just an abbreviation convention.)

In Opt, every name has a scope, usually the domain and its
descendents.  

In translating back and forth, we need to fasten on a namespace (or
set, but for simplicity pretend it's a single namespace) to be the
scope for a document defining an ontology.  

Recommendations:
  - :alludes-to should create an "unloaded" ontology (corresponding to
    S, above).  
  - Two allusions to the same ontology must be consistent, which is
    just a way of saying that the picture that emerges of an
    alluded-to ontology must be consistent.
  - If an unloaded ontology gets loaded (by an explicit 'define
    (domain S)', what's happened before must be consistent.
  - We require explicitly that after reloading an ontology that
    alludes to S one must reload S and anyone else that alludes to S.
    (Analogous to requirement that if A :extends B, reloading B
    requires reloading A.)
  - A domain can have multiple namespaces.  These behave like packages
    in Lisp, and say nothing at all about scoping.  If domains A and B 
    share the same namespace, and B :extends A, then B can shadow A's
    binding of a symbol in that namespace, but if it doesn't, then
    everything it says about that object named by that symbol will be
    unioned to what A said.

2004-07-20:

Even if you don't export a symbol, it could be returned as the result
of a deduction.   Would there be a problem printing it?

2004-07-19:

In addition to :extends, one wants to be able to write, e.g.,

   (:refers (:domain "http://..." :prefix ("foo" lion tiger)))

Now you can declare

   (:objects @foo:lion @foo:tiger - Animal)) 

If the real symbols 'lion' and 'tiger' from the domain are ever
encountered, their declarations must be consistent.

Also, declaring @foo:lion to be a constant or a predicate or whatever
does not cause it to belong to the domain it's declared in.  It must
somehow be marked as belonging to the given domain.

(It probably makes no sense to have a "" prefix, because the prefix on
such a symbol must unambiguously point to a domain.)

2004-07-16:

Can we have (forall (&key ...))? No, but we can have

(forall (x - Integer &rest (u) r - (Lst u) !& u - (TT))
   (iff (apply P (cons x r))
        (= x (length r))))

for pointless predicate (P ?n - Integer &rest (y) s - (y)) which is
true of any k objects of which the first is k-1 and the rest are
lists.  (P 1 (list foo)) and (P 2 (list foo oof) (list 99)),
but not (P 2 (list foo)) [wrong number of args], 
or (P 2 foo (list 99)) [second arg not a list], although this one
could still be provable via some other axiom.  (Possible that the use
of 'length' above is illegal.)

(There doesn't seem to be any way of quantifying over all predicates; 

   (forall (p - (Fun Prop <- (&rest (u) r - u !& u - (TT))))
      ...)

gets all the predicates with no &key args.  However, we can consider
those to be pure syntactic sugar for the unkeyified version with args
in alphabetically-sorted-key order.)

2004-07-14:

(:types Effect - Prop)

Effects are parsed with (action-context effect) on context stack, so
that 'increase', 'when', etc. are handled correctly. 

How can we have a process or event fire when a fluent change (assign,
increase, or decrease) occurs?  Can an event be specified to occur
when some other event occurs?

2004-07-12:

We really need (if-match x (--decls--) m subterm y), meaning
"if m (containing new variables declared in decls) matches x, then
subterm (using same variables), else y."  

E.g.: (\\ (tp - (Tup Number String)) (if-match tp (n s) (tuple n s) n 0))

Syntactic sugar for
(if-true-of-one (\\ (--decls--) (= m x))
		(\\ (--decls--) subterm)
		y)

(if-true-of-one pt ps y) is a new primitive term, satisfying axiom schema:

(forall (!& v - (TT))
   (if (exists! (&rest (v) r - v)
	  (apply pt r))
       (forall (&rest (v) r - v)
	  (if (apply pt r)
	      (= (if-true-of-one pt ps y)
		 (apply ps r))))
       (= (if-true-of-one pt ps y)
	  y)))
       
[handled by opt-eval?]

(true-of-one! pt ps) = (if-true-of-one pt ps (error))

(match! x (--d--) m s) = (true-of-one! (\\ (--d--) (= m x))
				       (\\ (--d--) s))

2004-07-08:

(lit-ob lit x) is just the inverse of (eval x lit)!


2004-07-07:

'eval' should always produce a term of the form (lit $x$), which
guarantees that $x$ is a literal.  $x$ might be an arbitrary form,
however, such as (+ sk29 3.5), if sk29 is of type (Literal Number).
There's no need to wrap 'lit's around the pieces of this, as in
(+ (lit sk29) (lit 3.5)).  When is (lit $x$) coerceable to $x$?
Obviously when encountered by 'eval' itself.  

What about (fl-v $flu$)?  Must we have statements of the form
(current-value $f$ (lit $x$))?  Could we say
(current-value (card my-fingers) (street-number tony-blair))?

(:action (find-out)
    :value (x - Date)
    :effect (know-val-is (birthday tony-blair) x))

or should  we say

(:action (find-out)
    :value (x - (Literal Date))
    :effect (know-val-is (birthday tony-blair) x))

Projection would produce a skolem term (lit sk29).

-----

Why not say that (lit (list 1 2)) is the external representation of
the list (1 2)?  Or perhaps (lit (cons 1 (cons 2 empty-list))) would
be better. (Note: (lit emptylist) is the external representation of
().) 

We could eliminate all :callables except for the arithmetic ones (so
that we wouldn't depend on Lisp's general interpreter).

Does 'equation' mean the same thing as '='?  
(= (+ ?x 1) 3) can succeed with ?x = 2 (not '(lit 2)').

(= (num-planets star1036) ?n) is satisfied by n=(num-planets
star1036).  What about (eval (num-planets star1036) ?n)?  Now we
require n to be a (Literal Number).


2004-07-06:

Formerly in literals.txl: 

  Some further remarks: Strings, numbers, and boolean are not the only
  types that support literals.  If $y_1$ and $y_2$ are
  literal-supporting types, then so is \tstt{(Tup $y_1$ $y_2$)}, or
  pairs of objects of types $y_1$ and $y_2$.  For instance, \tstt{<1,
    "a">} might be the standard name for the pair whose first element is
  1 and whose  second element is the string "a".  Might be, but in fact
  isn't, at least not in Opt, which requires the Lispy syntax
  \tstt{(lit (tuple 1 "a"))}.  

This is madness.  Clearly we can use tuples of literals instead of
having to introduce the concept of literal tuples.

Nagging problem: Suppose I have the goal 

    (eval (+ (car (list 1 (+ 3 4))) 4) ?v)

'car' evaluates to the literal 1, refuting the idea that computation
is always over literals.

Hold on!  The literal corresponding to (list 1 (+ 3 4)) is not a term
of the form (lit ...); it's just the list (1 7)!  This list has no
representation in Opt.  


2004-06-16:

(:names-from (:url "...") ...) -- just like :extends except that we
find just the objects we want.  If their types are undefined then we
get an error.  

2004-06-14:

Implementing namerals:  New type of Qexp, QNameral whose head is either a
single Lisp object if args=(known), or is an ordinary expression if
args=(unknown). 


04-06-10:

Have to eliminate the residual 'step-value's from action.lisp, now
that values are not thought of as properties of steps.  One
possibility is to introduce the notion of a "step link," such that
every step has one, which is handled by the execution engine by
channeling it to a "real" link.

Implement 'new': (new (x - Y) (p x)) can occur in an effect.  'x' is
replaced by a Skolem term taking as args the current situation, the
action, all :var variables and other universal variables whose scope
the 'new' expression occurs in, plus a small integer K = the ordinal
of this occurrence of 'new' in the effect.


04-06-02:

Get the Number ontology right and use it in requirements.opt.

04-06-01:

Should lists unify with tuples?  (list ?x b) = (tuple a ?y) ?
Presumably not.  So the tactic in unifying apply-Qexps with app-Qexps
is suspect. [04-09-21: On the other hand, type checking has already
been done.  All "listy" expressions have been reduced to the bland
internalized format.]


04-05-09:

Finding more than one counterexample to a 'forall' query (or to any
query with only nonmon continuations) is redundant.

Big bug: It's easier than I thought for a nonmonotonic continuation to
be taken prematurely.  E.g.,

   (and g (forall (...) (if g ...)))

An answer to the first g causes the entire search to run for the
'forall'; if the only counterexample involves the second $g$
occurrence, it won't be pursued until the deducer has erroneously
decided there are no counterexamples, and control returns to
processing answers to the first 'g'.

Solution: All nonmonotonic continuations must be suspended until
monotonic quiescence has been reached. [done]

The only sane way to keep some queries while deleting others is to
run, in essence, a 'gc' over the Query-answer-gen table at a point
where it is safe to do so, such as just before the next
deduction. [actual fix: allocate table fresh before each deduction]

04-05-01:

Price of getting deduction to work is that recursive queries are not
cached globally.  This probably makes little difference, but the whole
issue should be rethought in the context of :prelink-ing.


04-04-26:

Deductive macros appear to be broken.  (What isn't?)

04-03-22:

safe-varsubst keeps Qexps; it "normalizes" them so they don't consist
of a single bound variable.

04-03-20:

What we want to be able to say:

(forall (u - (TT))
   (forall (p1 p2 - (Fun Boolean <- (&rest (u) x - u)))
      (iff (subprop p1 p2)
	   (forall (&rest (u) y - u)
	      (if (apply p1 y)
		  (apply p2 y))))))

Alternatively, let 'all' be a property of a predicate: (all $p$) means
that $p$ is true for all argument rows of the type $p$ applies to.

(all (\\ 1 (u - (TT))
        (all (\\ (p1 p2 - (Fun Boolean <- (&rest (u) x - u)))
		(iff (subprop p1 p2)
		     (all (\\ (&rest (u) y - u)
			     (if (apply p1 y)
				 (apply p2 y)))))))))

Do we need to note explicitly the level of a forall that corresponds
to an 'all' of a level-1 predicate?

How do we unify the argspecs of a binder?  Intuitively, we want a
substitution that makes them identical.

Glitch: We internalize (forall (x - Dog) (if (p x) (q x))) into 
(forall (x) (if (and (p x) (is Dog x)) (q x))).

But if we write it as (all (\\ (x - Dog) (if (p x) (q x)))), and the
system knows nothing about 'all', we have to take care of the type
'Dog' some other way.  Hence 'forall' can't be defined in terms of
'all'; it has to be the other way around:

all - (Fun Boolean <- (Fun Boolean <- (&rest (u) r - u))
		      !& u - (TT))

   (forall (p - (Fun Boolean <- (&rest (u) r - u !& u - (TT))))
      (forall [1] (v - (TT))
	 (iff (all p)
	      (forall (&rest (v) s - v)
	         (p s)))))





04-03-19:

We could merge Typedexps and Qexps.  We could use ordinary Lisp CLOS
dispatching instead of special-purpose handler hack.  Not worth it,
especially given things like how param lists are represented.

04-03-17:

Not clear that the !_term of an Action-defn is at the right level.
Keyword args are alphabetized, but otherwise not made explicit.  
(See 'fundef-rec-term' in action.lisp.)

04-03-12:

High priority: Must make conts and sub-queries temporary for
stratified preds. [done]

A Query-answer-gen can be gc'ed if its entire body is temp.  A
Deductive-continuation can be gc'ed if its qconj is temp.  [done]

Goal-calls should not be uniquified in the first place.  [done]

04-02-26:

The gen-id idea for Query-answer-gen's is not thread-safe.  To make it
so, one would have to make Query-answer-gen-gen-id into a _set_ of ids
corresponding to active query searches, or make each thread keep track
of all the active Query-answer-gen's some other way.  Ids would have
to be more complex, so that it would be cheap to cull the sets,
flushing old gen-id's that were no longer active.

04-02-24:

In some cases, the setting of status flags for Query-answer-gen and
Query-ans-spec (in deduction) should be unwind-protected so that the
flag is restored if an interrupt or error occurs.

04-02-01:

Move disjunctive-normal-form to index.lisp. [done]

04-01-17:

sit-index field on Initial-situation should be supersedable by
explicit sit-cache argument to uniquify-situation.  Planner must
create a cache and make sure it gets passed all the way down to
succ-create.  The cache becomes a field of Plan-prob-soln, but can't
be reached from the situation at all.

04-01-12:

Handling circular deductions: If a predicate is stratified, we proceed
as now.  Otherwise, we have stored with predicate all the ways of
reducing it.  (I.e., disjunctive normal form for all the antecedents
of rules that apply.)   [moot]

03-12-14:

Need to allow multiple :prefix specs in an :extends, with notations
such as

(:extends (:uri <uri> :prefix "" (foo baz) :prefix "foo" :all-other-symbols))

03-12-13:

It's extremely awkward to insist that subtypes of a type be disjoint,
especially in the case where a type gets two different partitionings
because of type translation.  The default force of a declaration such
as (:types Sub1 Sub2 Sub3 - Super) should remain as it is now, but it
actually is shorthand for something like 
(:type-partition Super (Sub1 Sub2 Sub3 _)), 
where the '_' means there's an unnamed subtype that absorbs elements
not of type Sub1, Sub2, or Sub3.  A true partition would then omit the
'_'.  

If two subtypes may overlap, they might be declared thus:

(:types Sub Bus /- Super)

meaning that there may be objects of type Sub and Bus.

The hard part is introducing intersection types into an already
complex system.  

03-11-22:

In 'build-context', should probably allow 'inits' to include
Typed-exps and Qexps.

03.10.18:

Occasions should be split off from Uterms, which should be defined in
opt-types, not top-types.  Signed-occasion should inherit from Uterm,
not Occasion. [done]

03.10.16:

There's no way to share variables between a test and the true branch.
You have to say:
(test (exists (x) (know-val-is (password server) x))
      (forsome (x)
	 (know-val-is (password server) x)
	 (send server x)))

Test should have its own quantifier:

(test (x)
   (know-val-is (password server) x)
   (send server x))

03.09.24:

We could avoid tedium by allowing interlarded terms :link L in seqs,
so that

   (seq a :link l b :link m c)

would abbreviate

   (seq (link a :output l)
	(link :input l
	      b
	      :output m)
	(link :input m
	      c))

03-08-25:

'constant' is used in 'opt-eval', but doesn't appear in the manual.
(constant $v$) is a fluent whose value is $v$ in all situations.

03-08-24:

'wait-while' is referred to in the manual, but doesn't seem to exist.
Ditto 'wait-for'.  Internally (in optop, file continproj), there is an
action 'wait' that just means "wait for any event, allowing continuous
changes to occur in the meantime."   (What about 'watch'?)

03-07-26:

'typelist-parse' in parmsparse doesn't work on any list more complex
than a list of the types of required args.

03-07-06:

Rule: The only symbols that get canonicalized are those with Domain
(or Type-system) scope.

03-07-05:

What do we do about 'at' and 'over'?  Put them in the requirements
namespace? [yes]

03-06-29:

If all symbols are canonized, can we just introduce a class
Typed-canonized-symbol, and do away with Sym-with-type?  Or is that a
waste of time given that all expressions should be typed?

namespace.lisp should be moved to hacks directory; it has nothing to
do with Opt as such.

The global variables namespace-mode* and namespace* should not be
global, but I don't see any way to avoid it.  For now, anybody that
cares about the value (specifically 'opt-load') should rebind it.

03-06-27:

Declaring requirement R means that you import all symbols from R's
defining domain with prefix "". 

03.06.26:

URI for a Domain should not have to commit to notation
E.g., http://www.foobar.edu/onto/zoo.opt#zoomgt
means "Find ontology in onto/ directory in any notation, verify that
fragment "#zoomgt" is there, translate into Opt, and return to me."

What if file extension is .html?  Ignore and translate to Opt.  So
exension can really be omitted.

03.06.12:

Rename "universal" slot of Quantified-typed-exp to "bvars-to-freevars"
or "flush-quantifier"; or flip its polarity and rename it to
"keep-quantifier".  Or "quant-flushed-when-internalized".

03.05.19:

imports and exports from opt are a mess.


03.05.14:

Namespaces must support the notion of a canonical name.  That is, if
the same symbol is imported by two different routes, one must be
chosen as the canonical name.  Canonical names have the usual EQ
property, that two canonical names designate the same name only if
they're EQ. [done]

03.03.29:

In a domain, *all* types and type-funs should be scanned and
forward-defined before going back and handling them in detail. [done]

03.03.07:

Model of overloading: If a funtype has the 'overloaded' feature, then
the type checker avoids passing argument types down, instead leaving
them unconstrained.  Then a special handler associated with the
funtype scans the types of the checked arguments.  It revises the
types of each one in an idiosyncratic way, yielding new arg types and a
result type for the whole function call.  Each arg is type-transed to
its new type, and the whole thing is then given the result type.

E.g., < does the usual thing with floats and such
        plus if an arg is (Fluent n), all the others get coerced to
	that.

03.03.02:

Implement 'result', which links the value of the
result-producing step of an expansion to
the value of the expandee.

if's in effects look useful again: 
   (forall (dd rd - Date oa da - Airport dd rd - Date
            l - (Lst AirFairQuote))
      (message-exchange 
          dsdata-air-fare-agent
          (make AirFareQuoteRequest :depart-date dd
                                    :return-date rd
                                    :origin-airport oa
                                    :dest-airport da)
          l 
          (effect
             (forall (r - AirFareQuoteResponse
                      al - Airline td tr - Time amt - m)
                (if (and (member r l)
			 (not (!_error-occurred r))
			 (= (!_airline r) al))
		    (know-val (fare al (round-trip oa da dd rd))))))
          !\& AirFareQuoteRequest (Lst AirFareQuoteResponse)))


03.02.22:

(lv link) is apparently undeclared.  Should replace occurrence of
'link-value' in file 'search'. 

03.01.23:

Add arg to bdgenv-contract that says whether to discard bindings with
ids > discard or >= discard, thus avoiding the idiom of adding 1 to
ids (which breaks the Varid abstraction).

02.11.11:

Annoying bug:  (derivative (dist ?cv ?pt1)
			   (/ (base-speed ?cv)
		              (fl-v (traffic ?pt1 ?pt2))))

If you leave the fl-v out, Opt complains that 

               <<Wrong type: #{Type Number}
                   for [(/ (base-speed ?cv) (fl-v (traffic ?pt1 ?pt2)))]
                 Wanted #{Type (Fluent Float)}>>)

Obviously, it's putting the fl-v in itself, then failing to coerce for
some reason.

02.09.24:

When a global Opt symbol (a requirement, problem, or domain) is
redefined as a different entity (e.g., a requirement becomes a
domain), Opt should print a warning message and just redefine it, not
go into an unrecoverable state.

02.08.26:

Need to get Slides working like Steps.

02.06.11:

closed-world assumption is now buried deep inside deduction.nsp .  Not
clear how Opt could ever deal with an open world until this is fixed
somehow. 

02.06.09:

When quantifiers are eliminated, variables must be renamed!  Otherwise
we get gibberish from things like 
(or (forall (x) (p x)) (forall (x) (q x)))
which should turn into
(or (p ?x1) (q ?x2))
not
(or (p ?x) (q ?x))

Also, if we leave a quantifier in, we have to keep track of the
scoping relationships in the Quantified-typed-exp, or we'll never know
exactly what the quantifier means.

02.05.27:

If Bdgenv's are kept sorted in decreasing id order, then we don't have
to worry about long Bdgenvs any more, because uvar-lookup can stop as
soon as it finds a lower id than the one it's looking for.

02.05.21:

Implement min and max!

Need a function (ending $p$), which is true over any open interval in
which $p$ is true throughout the interval but false at the end.



02.05.20:

'typed-exp-argtypes-infer' has no method for looking inside
Quantified-typed-exp's, so it fails to remove some redundant type
checks. 

02.05.18:

There's no need for more than one entry in the :builtins field of
(define (requirement ...) ...). [moot]

02.05.11:

Handling gigantic :init's: We could make all :init assertions into
facts at first.  Then, if a fact is erased, we would remove it from
the fact index and add it to the index of every situation in a space.  
Tricky to debug, but infinitely more efficient in the case where most
facts never get erased. {If most of them are equalities on
non-fluents, we could move them to facts automatically.}


02.05.09:

Why are qvarbdgs-constraints ignored in action definitions?

(:action (foo ?x - Rutabaga)
   :precondition (ripe ?x)
   ...)

Why isn't (is ?x Rutabaga) added to the preconditions?  (Similarly for
methods.) 

Apparently -- they aren't ignored!  See use of 'add-type-filter-conj'
in 'causation-defn-basic-internalize' in optop/domain.nsp .  So the
question flips: Why can't we declare :parameters to be
:unconstraining? 


Need internalizers for Forsome-typed-exp and Foreach-typed-exp

It would be nice (and easy) to have a pprinter for 'define'.


02.04.23:

foxlong-parse is too brittle.

Basically, the Fox-Long modalities ('(at start ...)' etc.) can occur
at any depth.  They should be part of the context of normal effect
processing.  (Conditions are simpler.)

No one ever checks requirement :universal-preconditions, or 
:existential-preconditions and :conditional-effects (except for :vars
field).  [fixed; similarly for 'when']

Ways of handling the wretched durative syntax:
  a - Recurse through the Fox-Long grammar
  b - Build typed-exps, then recurse through them, adding time specs
      to untimed ones (to what level?)
  c - Handle in internalize, regress, or whoever sees these things as
      clumsily-defined processes 

Advantage of c: Every typed-exp that isn't a Durham-timed-typed-exp
can be given a default time-spec that classifies it into the correct
bin. 

We adopt (a) for :duration.  

For condition and effect, we use "foxlong modalities" to parse
  (at start ...) and the other crap.  The resulting grammar may be
  too general; too bad.

Then we adopt tactic (c) to actually tear these things into pieces.

What's the relation between Action and (Step Void)?  [see opt/types.nsp]
Is series really of type (Fun (Step Void) <- (&rest Action))?
  [yes, but now it's called sequence]
Perhaps: (def-type Action (Step (Val &rest Obj))) [done]


02.04.22:

foxlong-parse default time-scoper convention is broken.

?duration can occur in effects as well as duration field.



02.03.13:

durative-actions have values.  How does that mesh with the process
view?

Is a durative action allowed to have an expansion?  No! -- Its process
*is* its expansion.

02.02.28:

We really need to rewrite the unifier and indexer completely so that
we're not working with S-expressions at all.  Instead, we have
structures (Uterms?) with fields:

   categ: :qvar, :constant, :string, :application, :cons, :binder
   handler: Faster than dispatching on categ
   type: Not used by unifier, but allows us to recover all the type 
         information of external form
   head: The var, constant, or function
   length: Number of subexps
   subexps: () unless :application, when it's the args, or :binder, 
      when it's the vars and body (?)
   s-expression: pure S-expression version for use by indexer, debugging
   canonical: true iff term is "uniquified"
   constatn: true iff term has no free qvars

We could then dispense with Sym-with-type's.   

The ':cons' category is used to store lists of all types.

These things are unintelligible to people, but get rendered back to
external form when needed.

S-expression might be computed on demand.  E.g., varsubst might not
want to build S-expression *and* Uterm.  (Note that Uterm is currently
used to mean "uniquified term," but the two concepts appear to be
merging.) 

02.02.23:

:maintain's are defined over channels.  

(constrained a
   (maintain-over-channel c p))

means "Do a, but between the time when c is written and it is first
read, keep p true."

(let-var ((chan (channel Boolean)))
   (parallel
      (series (in-context (a1)
		 :then chan)
	      (a2))
      (series (a3)
	      (in-context (a4)
	          :wait chan))))


Effects-in-context: Why not have an implicit effect for every step in
an expansion, something like (plan-okay-so-far ...)?  The problem is
to fill in the "..." without mentioning step names, and to make the
scheme work for loops.

02.02.07:

Do we still need param-constraints and var-constraints in Action-defn?

02.01.30:

Why are :value fields sometimes treated as Tups?  The mere fact that
the implementation has to make a tuple of them internally should not
be relevant. 

02.01.29:

Internalizing of \\-expressions is of course all wrong.  

02.01.19:

Treating (not (p x)) as requiring a filter condition only if p is a
Predicate (i.e., a constant domain-scope function with restype Prop
and a special blessing) makes no type-theoretic sense, but since it
applies only for internalizing perhaps it's kosher.

02.01.18:

Boolapp-typed-exp could be a subclass of Connective-typed-exp, which
could be a subclass of App-typed-exp.  But the 'fcn' slot of
Boolapp-typed-exp would have to be renamed to avoid clash with
inherited slot of App-typed-exp.

'not' internalizer must flip goal-position, but it can't because 'not'
is treated as an ordinary function. [jerry-rigged to work]

02.01.14:

'polarity' of goal is inadequate; we need to know if it occurred *as a
goal*.  E.g., in (<- (baz ?x) (foo ?x)), (foo ?x) occurs as a goal.
In (<- (baz ?x) (p (foo ?x))) it does not. [fixed]

Of course, a deductive macro that occurs as a non-goal is not going
to accomplish much.

02.01.12:

Adding "qvarbdgs constraints" to implications is necessary only
because we're using a first-order engine for a higher-order language.
That is, (forall (x y - Mammal)
            (<- (rears y x) (mother y x)))

gets turned into 
     (<- (rears ?y ?x) 
	 (and (mother ?y ?x) (is Mammal ?y) (is Mammal ?x)))

only because the rule will be invoked for non-Mammals now and then.
In the higher-order world, the rule is equivalent to

   (FORALL (\\ (x y - Mammal) (if (mother y x) (rears y x))))

where FORALL - (Fun Prop <- (p - (Fun Prop <- (&rest (= u))) 
			     !& u - (TT)))

((!& FORALL u) p) is true if and only if for all arg tuples x of type
u, (p x).  In the example, for all arg tuples (Arg m c) of type 
(Tup x y - Mammal), 

     ((\\ (x y) (if (mother y x) (rears y x)))
      m c)

But there are no wffs or inference rules that allow you ever to apply
the \\-expression to anything that isn't of the correct type.  In the
first-order engine, the rules allow such interactions.
  
Tricky part: Exactly where do we do the analysis concerning whether
the constraints are necessary?

Can typed-exp-type-narrow play a role?  Only if predicates are
different from functions-returning-booleans.  So that for *every*
function F of type (Fun Prop <- y), the type consequences of (F a)
having value true are that a is of type y, and the type consequences of
(F a) having value false are that a is of type Obj.  

How far does the type propagation go?  Suppose I have 
   (and (num-chambers (heart ?x) 2) ...)
where heart - (Fun Heart <- Animal) 
and num-chambers - (Fun Integer <- Heart)
Should we have to test if ?x is a mammal??

The idea is that in the translation to first-order, if a predicate gets
the wrong-type argument, it is false.  If a function gets a wrong-type
argument, it denotes some unpredictable value of the correct
type. (E.g., (heart eiffel-tower) denotes some heart, but not one
about which we can know anything.)

Hence if we can infer (num-chambers (heart ?x) 2), or 
(not (num-chambers (heart ?x) 2)) {open-world interpretation of
'not'!}, then (heart ?x) must be a "known" heart, and therefore ?x
must be bound to a term denoting an Animal.

This really looks more like "value" propagation than "type"
propagation.  The *type* of (heart ...) is always Heart, but the value
is either "some knowable heart" or "some unknowable heart."

Consider 
(forall (x - Animal)
   (if (not (scaly x)) (fuzzy x)))

where scaly - (Fun Prop <- Animal) and fuzzy - (Fun Prop <- Physob)

This could in principle be internalized as
   (if (and (not (scaly ?x)) (is Animal ?x))
       (fuzzy ?x))
or
   (if (and (not (fuzzy ?x)) (is Animal ?x))
       (scaly ?x))

--






02.01.07:

Coercing between type y and type (Fluent y): 

(coerce (Fluent y) y fl-v) seems to be about right.  It turns
(= (contents bottle1) 0) 
to 
(= (fl-v (contents bottle1)) 0)

Going the other way we just say (coerce y (Fluent y) identity).  
This may seem logically suspect, but it keeps the inference engine
simple.  The only place we would get into trouble with this is if we
had types such as (Fluent (Fluent Integer)).  But we never will.  (?)

02.01.05:

deduction.nsp depends on parsers.nsp only to get 'build-opt-call'.
index.nsp depends on action.nsp only to get 'type-predify'.
This sort of thing muddies the orthogonality between the particular
syntax of Opt and the deduction/indexing engine.

02.01.01:

'is' and 'if' are currently not bound to anything.  They should be
bound to something of type 'Reserved-word' or the like; here is where
we could stick in info about 'is' being "rigid."

Why isn't 'on' of type (Fun (Fluent Boolean) <- (x y - Block))?

'if' is de facto overloaded.  Consider two expressions:

[1]   (if (null (contents box1))
	  block1
	  (car (contents box1)))

[2]   (if (on a b)
	  a b)

In (if <e> <t> <f>), if <e> is of type Boolean, then the whole thing
is of type <s>, where <s> is the common supertype of the types of <t>
and <f>.  If <e> is of type (Fluent Boolean), then the whole thing is
of type (Fluent <s>), where <s> is the common supertype of the types
of <t> and <f>

The first is of type Block, because 'null' is of type 
(Fun Boolean <- (Lst ?u)).  ('(contents box1)' must be coerced to
(fl-v (contents box1)), given that
contents - (Fun (Fluent (Lst Physob)) <- Box) .)

[2] is of type (Fluent Block).  

So type Prop might be defined as (Alt Boolean (Fluent Boolean)).

Perhaps 'null' and its kin are not predicates in the PDDL sense.
Perhaps Prop is just (Fluent Boolean), and and null is therefore not a
predicate.  

01.12.29:

Extension: (:objects (acm (uri-ref "http://www.acm.org")) ...)
and the like.

For this to be really useful, we need to let every reference to 'acm'
resolve to (uri-ref ...) "at read time" as it were, but have every
reference to (uri-ref ...) print as 'acm' (in some togglable way).

01.08.12:

How about a data type Formula, which contains within it an external
and internal form?  Application code sees the former, while the
deductive machinery sees the latter.  Might be tricky to keep track of
which context you're in.

01.07.31:

Replace :extends with :imports :

(:imports (<domain> :localnames ((<locname> <domname>)*)
		    :hide (-syms-)
		    :prefix (<pref> -syms-)))
		    
where last occurrence of -syms- can be :all or :all-others.

Domain inherits from its ancestors only through its parents.  (Except
for universal-ancestors*, presumably?)

Every domain has a name-map, which is an efficient table giving
mapping from 
   pref1 : pref2 : root     {a renamed sym}
to symview,

where symview specifies how a symbol is viewed in this domain:
   sym (the symbol) home (the domain that declared it)
   hidden (Boolean), preferred representation (renamed sym)
sym+home

Hidden symbols have no entry in the name-map and no preferred
representation.  They print as ~name.

Name maps are filled using parent-name-filter for each parent, which
recapitulates the stuff in the :imports.

01.07.27:

Implement be, have-effect, return.

Why is super-if-sub recursive?  (in type-index)

01.07.23:

Currently addenda can't have :facts fields; fix.
Neither can situations and problems.  These would get added to
fact-index, not situation-index, of initial situation. [fixed]

01.07.21:

Not clear why there is an asymmetry between axioms, and assertions of
the form (<- q p).  Except of course that we check for an axiom that
concludes <- q p), while we can't check for an assertion of the form
(<- (<- q p) r) without risking an infinite regress.  Also, there are
procedural axioms, but not procedural "<- assertions." [asymmetry gone]

01.07.15:

If slot-access-fcn is of form (*multi f), then the form applying it to
x should be (multiple-value-call f x).  Alternatively, we could use
nth-value.  But either way the typed-exps to be built are tedious.

------

01.07.14:

Not terribly consistent about when we discard Typed-exp and store an
S-expression in various Opt data structures. [hopefully now closer to
ideal: store Typed-exps wherever possible]

Right way to handle :value variables in action :effect: Bind them to
"symbol macros" that replace v with (!_v (step-value this-step)).  (Of
course, this means we have to implement symbol macros, which isn't
hard.) 

01.06.03:

We currently don't allow things like
   (:axiom
       :vars (?e - (Fluent u) ?x - u !& u - (T))
       ...)
Should we?  

01.06.01:

Putting deduction back into opt:

  Some situations must be mutable ("contexts"); others are immutable,
     and there is exactly one copy of a situation with a given set of
     contents. 
  
  Apparently we can't have "cut" because rules are not ordered, even
     within a rule group.

The easiest way to implement cut is with a few pseudo-predicates:

(<- (= ?x ?y)
    (branch (guard (and (match ?x (fluent-val ?x1))
			(match ?y (fluent-val ?y1)))
		   (and (current-val ?x1 ?cx)
			(current-val ?y1 ?cy)
			(= ?cx ?cy)))
            (guard (match ?x (fluent-val ?x1))
		   (and (current-val ?x1 ?cx)
			(= ?cx ?y)))
	    (guard (match ?y (fluent-val ?y1))
		   (and (current-val ?y1 ?cy)
			(= ?x ?cy)))))
                   
branch is proceduraly defined so that as soon as the first conjunct of
a guard clause succeeds, the remaining guard clauses are discarded.

(match ?t1 ?t2) just means "succeed if ?t1 and ?t2 unify".

To use backward chaining with immutable situations, you have to create
a situation, do chaining, then freeze it, check the index, and
possibly discard it.


01.05.31:

Now that we've replaced (<type> x) with (is <type> x), do we want to
handle goals of the form (is ?t x)?

01.05.26:

Situations need to be brought back if we're going to do planning.

01.05.25:

The right way to implement definers: Every parse function should return
two values: the flagged source, and a macro expansion.  The flagged
source goes into the .chk file.  The macro expansion goes into the
.fasl file (after being compiled, of course).  We still have to
evaluate most of the macro expansion at compile time, too, or type
checking will not be possible.


01.05.23:

Handling tags:

  problem 1: < doesn't mean the right thing; not a problem when tag is
     defined, but could be when it's referred to.
  problem 2: where do tags get bound?  If we allow nested
     constraineds, then they should be global:
       (constrained
            (series
               (constrained (parallel (tag a (foo))
				      (tag b (foo)))
		  ...)
	       (tag c (baz)))
         (in-context (series b c) ...))

  Action-typed-exp all have a tags field. [done] Note that rebuilding such a
  thing requires finding all the tags again.

  Another reason for overloading: (series ...) can operate on both 
    actions and events (time intervals).  For now, we cheat and
    identify these two things.

01.05.22:

Steps toward making OPT a reality:

  Get overloading working [postponable]
      exp-rebuild, defined in types/terebuild.nsp, is necessary for
      overload.  Several methods for exp-rebuild are missing.
  Make parsers use synutils.[done]  (Get flag count right. [done] )
  Reintegrate :action defs [done], but separate new Unpop from OPT
  Write manual

  Finish pcdaml, and inverse.
  Write module to transform DAML to OPT
     lxml->xml
     Walk tree and fix literals
     Check types
     Write Typed-exp -> RDF++
        Typed-exp -> OPT already exists (typed-exp-sexp)
     
  A more modular mcd-loader would be nice.


-----

If actions are reintegrated, does that mean we keep track of
situations?

Presumably not.

Nor do we have a solution checker for plans.  The semantics of action
hierarchies are presumably different, too.

$Id: notes.txt,v 1.109 2006/08/20 17:41:41 dvm Exp $