anchor.diff:                `(|get-value| ,step-ops))))
   
   
  -(defun smt-plan-context ( &key
  -                            operators facts
  -                            state-vars
  -                            ground-actions
  -                            initial-true
  -                            initial-false
  -                            initial-state
  -                            goal
  -                            smt)
  +(defun smt-plan-context (&key
  +                           operators
  +                           facts
  +                           domain
  +                           goal
  +                           smt)
     "Fork an SMT solver and initialize with base plan definitions."
  -  (let* ((operators (when operators
  -                      (load-operators operators)))
  -         (facts (when facts (load-facts facts)))
  -         (type-map (compute-type-map (pddl-operators-types operators)
  -                                     (pddl-facts-objects facts)))
  -         (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
  -                                                  (set-difference  state-vars initial-true :test #'equal))))
  -         (initial-state (or initial-state
  -                            `(and ,@initial-true
  -                                  ,@(loop for v in initial-false collect `(not ,v)))))
  -
  -         (goal (or goal (pddl-facts-goal facts)))
  +  (let* ((domain (or domain (ground-domain operators facts :goal goal)))
  +         (state-vars (ground-domain-variables domain))
  +         (ground-actions (ground-domain-operators domain))
  +         (initial-state (ground-domain-start domain))
            (n-op (length ground-actions))
            (n-var (length state-vars)))
       (format t "~&ground actions: ~D" n-op)
  
positive.code:                              (bool-args args)
                               'bool
                               exp)))
      (let* ((op-i (smt-plan-op-step ground-actions 'i))
             (op-vars (smt-plan-step-fun-args state-vars ground-actions 'i 'j)))
        (print op-i)
        ;(print op-vars)
  
negative.code: 
  
  
  (defun smt-plan-step-fun (domain)
    "Generate the per-step assertion for a planning problem"
    (labels ((bool-args (list)
               (loop for x in list
  