anchor.diff:  		(let ((ct (sentence-get-token-by-id sentence id)))
   		  (if (equal "PUNCT" (token-upostag ct))
   		      (push (list ct 'punct-causes-nonproj-of (token-id tk)) errors))))))))))
  -
  -
  
positive.code:         ((> a b)
           (cons a (range (- a 1) b)))))
  
  
  (defun get-projection (token sentence)
    (let ((pset (mapcar (lambda (tk)
  			(cons (token-id tk) (token-head tk)))
  		      (sentence-tokens sentence))))
      (labels ((child (tk)
  	       (mapcar #'car (remove-if-not (lambda (n) (equal n tk)) pset :key #'cdr)))
  	     (aux (tokens projection)
  	       (if (null tokens)
  		   projection
  		   (aux (append (cdr tokens) (child (car tokens)))
  			(adjoin (car tokens) projection)))))
        (sort (aux (list (token-id token)) nil) #'<=))))
  
  
  (defun is-token-projective (token sentence)
    (if (equal 0 (token-head token))
        (values t nil)
        (let* ((htk    (find (token-head token) (sentence-tokens sentence) :key #'token-id :test #'equal))
  	     (prj    (get-projection htk sentence))
  	     (arange (if (< (token-head token) (token-id token))
  			 (range (1+ (token-head token)) (1- (token-id token)))
  			 (range (1+ (token-id token)) (1- (token-head token)))))
  	     (aset   (sort (set-difference arange prj :test #'equal) #'<= )))
  	(values (not aset) aset))))
  
  
negative.code: 
  |#
  
  (defun is-descendant-t-n (id-1 id-2 sentence)
    (let ((parent (token-head (find id-1 (sentence-tokens sentence)
  				  :key #'token-id :test #'equal))))
      (cond
        ((equal parent 0) nil)
        ((equal parent id-2) t)
        (t
         (is-descendant-t-n parent id-2 sentence)))))
  
  (defun range (a b)
    (assert (and (integerp a) (integerp b)))
  