anchor.diff:                              d-edge)))))
         ;; result
         (make-fa d-edge
  -               (loop ; start
  -                  for q across d-states
  -                  for i from 0
  -                  when (intersection q (fa-start nfa))
  -                  collect i)
  -               (loop ; accept
  -                  for q across d-states
  -                  for i from 0
  -                  when (intersection q (fa-accept nfa))
  -                  collect i)))))
  +               (fa-subset-indices (fa-start nfa) d-states)
  +               (fa-subset-indices (fa-accept nfa) d-states)))))
   
   ;; Brzozowski's Algorithm
   (defun dfa-minimize-brzozowski (dfa)
  
positive.code:   (aref (fa-states fa) i))
  (defun fa-token-name (fa i)
    (aref (fa-tokens fa) i))
  
  (defun make-fa-simple (edges start accept)
    (let (states tokens)
  
negative.code: (defun dfa-minimize-hopcroft (dfa)
    (let ((p (list (fa-accept dfa)
                   (set-difference (map 'list #'identity (fa-states dfa))
                                   (fa-accept dfa)))))
      ;; build minimal states
      (loop
         with imover = (fa-inv-mover dfa)
         with q = (list (fa-accept dfa))
         while q
         for a = (pop q)
         do (loop for c below (length (fa-tokens dfa))
               for x = (reduce (lambda (x i-q)
                                 (union x (funcall imover i-q c)))
                               a :initial-value nil)
               when x
               do (loop for yy on p
                     for y = (car yy)
                     for i = (and (cdr y)
                                  (intersection y x))
                     when i
                     do (let ((j (set-difference y x)))
                          (assert (and j i))
                          ;; i is smaller
                          (when (< (length j) (length i))
                            (rotatef i j))
                          (loop for zz on q
                             when (equal y (car zz))
                             do (rplaca zz j))
                          (push i q)
                          (rplaca yy i)
                          (rplacd yy (cons j (cdr yy)))))))
      ;; build edges
      (let ((edges))
        (loop with mover = (fa-mover dfa)
           for ds in p
           for i-q from 0
           do (loop
                 for i-z from 0 below (length (fa-tokens dfa))
                 for q-next = (funcall mover (car ds) i-z)
                 when q-next
                 do (push (list i-q
                                (fa-token-name dfa i-z)
                                (position-if (lambda (q) (find (car q-next) q))
                                             p))
                          edges)))
        (make-fa edges
                 (fa-subset-indices (fa-start dfa) p)
                 (fa-subset-indices (fa-accept dfa) p)))))
  
  
  ;; (defun nfa-e-close (n e-lookup)
  