anchor.diff:                vars)))
       vars))
   
  -(defstruct concrete-action
  +(defstruct ground-action
     name
     actual-arguments
     precondition
     effect)
   
   
  -(defun format-concrete-action (op step)
  -  (format-op (concrete-action-name op)
  -             (concrete-action-actual-arguments op)
  +(defun format-ground-action (op step)
  +  (format-op (ground-action-name op)
  +             (ground-action-actual-arguments op)
                step))
   
   (defun exp-args-alist (dummy-args actual-args)
  
positive.code:                              ;; exp
                               (apply #'smt-and
                                      (loop
                                         for op in concrete-actions
                                         for op-var in op-i
                                         collect
                                           (let ((pre (rewrite-exp (concrete-action-precondition op) 'i))
                                                 (eff (rewrite-exp (concrete-action-effect op) 'j)))
                                             `(or (not ,op-var)      ; action not active
                                                  (and ,pre          ; precondition holds
                                                       ,eff)))))))
  
negative.code:          (state-vars (or state-vars
                           (create-state-variables (pddl-operators-predicates operators)
                                                   type-map)))
           (ground-actions (or ground-actions
                                 (smt-ground-actions (pddl-operators-actions operators)
                                                        type-map)))
           (initial-true (unless initial-state (or initial-true (pddl-facts-init facts))))
           (initial-false (unless initial-state (or initial-false
  