anchor.diff:  (defun assoc-relation (l)
     (lambda (g1 m1)
       (member (cons g1 m1) l :test #'equal)))
  +
  +(defun rule-based-closure (rules)
  +  (lambda (b)
  +    (iter
  +      (for changed = nil)
  +      (iter
  +        (for (p . q) in rules)
  +        (when (subsetp p b)
  +          (unless (subsetp q b)
  +            (setf b (union b q)
  +                  changed t))))
  +      (unless changed (return b)))))
   
   (defun explore (e m j i)
     "E ⊆ M; J is E → M
  
positive.code:       (#\n (return nil)))))
  
  (defun user-confirm (from to)
    (format t "Is ~a → ~a? " from to)
    (ask-y-or-n))
  
  (defun user-extend (e)
  
negative.code:       (with a = nil) ; A enumerates closed sets of m-closure on M, E, I
        (iter
          (for ajj = (m-closure a m e i))
          (until (set-equal a ajj))
          (if (user-confirm a ajj)
              (return (push (cons a ajj) l))
              (setf e (user-extend e))))
        (while (setf a (next-closure a m (rule-based-closure l)))))
      (values l (list e m j))))
  