anchor.diff:  
     "
     (adt:match scully.rule-trees::rule-tree tree
  -    ((scully.rule-trees::node term% _ lo)
  +    ((scully.rule-trees::node term% hi lo)
        (if (< term% term)
  -       (advance-tree lo term)
  +       (if (member term% heads)
  +         (advance-tree hi term heads)
  +         (advance-tree lo term heads))
          (tree-to-result tree)))
       (_ (tree-to-result tree))))
   
  -(defun advance-forest (forest term)
  +(defun advance-stratum (stratum term &optional heads)
  +  "Advance the stratum up to (but not beyond) `term`.
  +
  +  Two values will be returned:
  +
  +  1. The new stratum (possibly NIL).
  +  2. Any new heads to add (possible NIL).
  +
  +  "
  +  (process-stratum (rcurry #'advance-tree term heads) stratum))
  +
  +(defun advance-forest (forest term &optional heads)
     "Advance the rule forest up to (but not beyond) `term`.
   
     Two values will be returned:
  
positive.code:     (while new-heads)
      (finally (return (values stratum all-new-heads)))))
  
  (defun walk-stratum-negative (stratum heads)
    (process-stratum (rcurry #'walk-tree-negative heads) stratum))
  
  
  (defun finalize-heads (forest heads)
    "Finalize the set of heads to add and return the appropriate ZDD."
    (multiple-value-bind (f h) (advance-forest forest (rf-lower-bound forest))
      (setf heads (append heads h)
            forest f))
    (iterate
      (for stratum :in (rf-strata forest))
      (multiple-value-bind (s h) (walk-stratum-positive stratum heads)
        (setf heads (append heads h)
              stratum s))
      (multiple-value-bind (s h) (walk-stratum-negative stratum heads)
        (setf heads (append heads h)
              stratum s))
      (finally (return (zdd-set heads)))))
  
negative.code: 
  
  
  (defparameter *r* (make-zdd-reasoner *rules*))
  (defparameter *i* (initial-iset *r*))
  (defparameter *j* (initial-iset *r*))
  
  (with-zdd
    (-<> *r*
      (make-iset '(
                   (true (control xplayer))
                   (true (cell 1 1 B)) (true (cell 1 2 x)) (true (cell 1 3 o))
                   (true (cell 2 1 B)) (true (cell 2 2 o)) (true (cell 2 3 o))
                   (true (cell 3 1 x)) (true (cell 3 2 x)) (true (cell 3 3 x))
                   ))
      (apply-rule-forest *r* <> (zr-possible-forest *r*))
      (draw-zdd *r* <>)
      (dump-iset *r* <>)
      (no <>)
      ))
  
  
  (defun test ()
    (with-zdd
      (-<>
          (zdd-union
            ; (make-iset *r* '(
            ;                  (true (control oplayer))
            ;                  (true (cell 1 1 o)) (true (cell 1 2 x)) (true (cell 1 3 x))
            ;                  (true (cell 2 1 x)) (true (cell 2 2 o)) (true (cell 2 3 b))
            ;                  (true (cell 3 1 x)) (true (cell 3 2 o)) (true (cell 3 3 b))
            ;                  ))
            (make-iset *r* '(
                             (true (control oplayer))
                             (true (cell 1 1 o)) (true (cell 1 2 x)) (true (cell 1 3 x))
                             (true (cell 2 1 x)) (true (cell 2 2 b)) (true (cell 2 3 o))
                             (true (cell 3 1 x)) (true (cell 3 2 o)) (true (cell 3 3 b))
                             )))
        (apply-rule-forest *r* <> (zr-possible-forest *r*))
        (zdd-join (make-iset *r* '((does oplayer (mark 3 3))
                                   (does xplayer noop))))
        (apply-rule-forest *r* <> (zr-happens-forest *r*))
        ; (zdd-meet <> (zr-next-zdd *r*))
        (dump-iset *r* <>)
        (no <>)
        ; (draw-zdd *r* <>)
        )))
  