anchor.diff:    (varreduce (append vars1 vars2)))
   
   ; Multiply two variables
  -; Only used with variables with the same symbol
  +;; Only used with variables with the same symbol
   (defun var* (var1 var2)
     (make-var (sym var1)
               (+ (pwr var1) (pwr var2))))
   
  -; Simplify polynomial by adding terms of the same order
  +; Simplify polynomial
  +;; Add terms of the same order
   (defun polyreduce (poly)
     ((tokenreduce term+ equal-order) poly))
   
  -; Multiply variables with the same symbol
  +; Simplify variable list
  +;; Multiply terms with the same symbol
   (defun varreduce (variables)
     ((tokenreduce var* equal-sym) variables))
   
  
positive.code:                    (make-tokenlist (cdr tokens)))
      nil))
  
  ; Construct a polynomial and simplify
  (defun make-poly (terms)
    (polyreduce (filter id (make-termlist terms))))
  
  ; Construct a term
  (defun make-term (coefficient variables)
    (term-simplify (cons coefficient
                         (list (filter id (make-varlist variables))))))
  
  ; Construct a variable
  (defun make-var (symbol power)
    (var-simplify (cons symbol power)))
  
  (defun coeff (term) (car term)) ; Term coefficient
  (defun vars (term) (cadr term)) ; Term variables
  (defun sym (var) (car var)) ; Variable symbol
  (defun pwr (var) (cdr var)) ; Variable power
  
  (defun id (val) val) ; Identity function
  
  (defun reduce (fun lst)
    (accumulate fun (car lst) (cdr lst)))
  
negative.code:     (lambda (token2)
        (fun (equal (attr token1) (attr token2))))))
  
  ; Simplify term
  ;; Return an empty list if it evaluates to zero
  (defun term-simplify (term)
    ((token-simplify coeff) term))
  
  ; Simplify variable
  ;; Return an empty list if it evaluates to one
  (defun var-simplify (variable)
    ((token-simplify pwr) variable))
  
  