anchor.diff:        (#\n (return nil)))))
   
   (defun user-confirm (from to)
  -  (format t "Is ~a → ~a? " from to)
  +  (let ((*print-case* :downcase))
  +    (if from
  +        (format t "If something is~{ ~a~}, is it~{ ~a~}? " from (set-difference to from))
  +        (format t "Is everything~{ ~a~}? " to)))
     (ask-y-or-n))
   
   (defun user-extend (e)
  
positive.code: (defun assoc-relation (l)
    (lambda (g1 m1)
      (member (cons g1 m1) l :test #'equal)))
  
  (defun explore (e m j i)
    "E ⊆ M; J is E → M
  
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))))
  