anchor.diff:                                 (q5 1 q6)
                                  (q6 :epsilon q5) (q6 :epsilon q8)
                                  (q8 :epsilon q10))
  -                             'q9 'q10))
  +                             'q9 (finite-set 'q10)))
           (regex-2-15-a '(:closure 1))
           (regex-2-15-b '(:concatenation 0 (:closure 1)))
           (regex-2-15-c '(:union (:concatenation 0 (:closure 1)) 1)))
  
positive.code:   `(lisp-unit:assert-true (finite-set-equal ,a ,b)))
  
  (lisp-unit:define-test dfa-equal-basic
    (lisp-unit:assert-true (dfa-equal (make-fa '((0 a 1) (1 b 0)) 0 1)
                                      (make-fa '((x a y) (y b x)) 'x 'y)))
    (lisp-unit:assert-false (dfa-equal (make-fa '((0 a 1) (1 b 0)) 0 1)
                                       (make-fa '((x a y) (y b x)) 'y 'x))))
  
  
  
  (lisp-unit:define-test dfa-minimize
    (lisp-unit:assert-true
     (dfa-equal (fa-minimize-brzozowski (make-fa '((0 a 1) (1 b 2) (2 a 1)) 0 1))
                (make-fa '((0 a 1) (1 b 0)) 0 1)))
    (flet ((min-cmp (dfa)
             (dfa-equal (fa-minimize-brzozowski dfa)
                        (dfa-minimize-hopcroft dfa))))
      (lisp-unit:assert-true
       (min-cmp (make-fa '((0 a 1) (1 b 2) (2 a 1)) 0 1)))
  
      (lisp-unit:assert-true
       (make-fa '((0 a 1) (1 b 0)
                  (0 e 2) (1 e 2))
                0 2))
      (lisp-unit:assert-true
       (min-cmp (make-fa '((0 a 1) (1 b 0) (1 c 2) (2 a 1)
                           (0 e 3) (1 e 3) (2 e 3))
                         0 3)
                ))))
  
  ;; examples from the dragon book
  
negative.code:   (let* ((fig-3-56  '(:concatenation (:closure (:union a b)) a b b))
           (fig-3-63 (make-fa '((0 b 0) (0 a 1) (1 a 1) (1 b 2) (2 a 1) (2 b 3)
                                (3 a 1) (3 b 0))
                              0 (finite-set 3)))
           (my-fig-3-36 (regex->nfa fig-3-56))
           (my-fig-3-63 (nfa->dfa my-fig-3-36)))
  
  