anchor.diff:          (ground-derived type-objects (pddl-operators-derived operators))
         (make-ground-domain :variables ground-variables
                             :variable-type variable-type
  -                          :derived-variables (hash-table-keys derived-type)
  +                          :derived-variables (type-map-keys derived-type)
                             :derived-type derived-type
                             :operators ground-operators
                             :axioms derived-axioms
  
positive.code: 
  (defun create-state-variables (functions type-objects)
    "Create all state variables from `PREDICATES' applied to `OBJECTS'"
    (let ((variable-type (make-hash-table :test #'equal)))
      (dolist (f functions)
        ;; apply p to all valid arguments
        (dolist (args (collect-args (pddl-function-arguments f)
                                    type-objects))
          (let ((var (cons (pddl-function-name f) args)))
            (setf (gethash var variable-type) (pddl-function-type f)))))
      variable-type))
  
  (defun ground-derived-body (derived actual-args type-map)
    (labels ((arg-alist (dummies actuals)
  
negative.code:      for s in (ground-domain-variables domain)
       for v = (format-state-variable s i)
       collect (multiple-value-bind (type contains)
                   (tree-map-find types s)
                 (assert contains)
                 (smt-declare-fun v () type))))
  
  