anchor.diff:            (0 null-process)
             (1 (car (map-parallel-composition #'identity par)))
             (otherwise par)))
  -      (progn
  -        (error "The (variable) process ~a is not contained in ~a, and thus can not be removed."
  -               process par)
  -        par)))
  +      (error "The (variable) process ~a is not contained in ~a, and thus can ~
  +              not be removed."
  +             process par)))
     (:method ((process process-variable) (var process-variable))
       (if (find process (process-variables-in var))
         null-process
  -      (progn
  -        (error "The (variable) process ~a is not contained in ~a, and thus can not be removed."
  -               process var)
  -        var)))
  +      (error "The (variable) process ~a is not contained in ~a, and thus can ~
  +              not be removed."
  +             process var)))
     (:method ((process process-variable) trigger)
       (if (find process (process-variables-in (process trigger)))
         (typecase (process trigger)
           (process-variable (setf (process trigger) null-process))
           (parallel-composition (setf (process-variables (process trigger))
                                       (delete process
  -                                            (process-variables (process trigger))))
  -                              (case (length (map-parallel-composition #'identity
  -                                                                      (process trigger)))
  +                                            (process-variables
  +                                             (process trigger))))
  +                              (case (length (map-parallel-composition
  +                                             #'identity
  +                                             (process trigger)))
                                   (0 (setf (process trigger) null-process))
  -                                (1 (setf (process trigger) (car (map-parallel-composition #'identity
  -                                                                                          (process trigger))))))))
  -      (error "The (variable) process ~a is not contained in ~a, and thus can not be removed."
  +                                (1 (setf (process trigger)
  +                                         (car (map-parallel-composition
  +                                               #'identity
  +                                               (process trigger))))))))
  +      (error "The (variable) process ~a is not contained in ~a, and thus can ~
  +              not be removed."
                process (process trigger))))
     (:method ((process message) kell)
       (if (find process (messages-in (process kell)))
  
positive.code: 
  (defgeneric compose-processes (process-a process-b)
    (:documentation
     "Conses up a new parallel composition that contains both process-a and process-b.")
    (:method (process-a process-b)
      (let ((pc (make-instance 'parallel-composition)))
        (compose-processes (compose-processes pc process-a)
  
negative.code:         (message (setf (process kell) null-process))
          (parallel-composition (setf (messages (process kell))
                                      (delete process (messages (process kell))))
                                (case (length (map-parallel-composition
                                               #'identity
                                               (process kell)))
                                  (0 (setf (process kell) null-process))
                                  (1 (setf (process kell)
                                           (car (map-parallel-composition
                                                 #'identity
                                                 (process kell))))))))
        (error "The (message) process ~a is not contained in ~a, and thus can ~
                not be removed."
               process (process kell))))
    (:method ((process kell) kell)
      (if (find process (kells-in (process kell)))
  