anchor.diff:                     (make-tokenlist (cdr tokens)))
       nil))
   
  +; Construct a polynomial
   (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))
  -(defun vars (term) (cadr term))
  -(defun sym (var) (car var))
  -(defun pwr (var) (cdr var))
  +(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)
  +(defun id (val) val) ; Identity function
   
   (defun reduce (fun lst)
     (accumulate fun (car lst) (cdr lst)))
  
positive.code:              (filter (equal-fun not (car tokens)) (cdr tokens))))
        nil)))
  
  (defun equal-order (fun term)
    ((equal-token vars) fun term))
  
  (defun equal-sym (fun var)
    ((equal-token sym) fun var))
  
  
negative.code: (defun term*-out (term2)
    (lambda (term1) (term* term1 term2)))
  
  ; Negate the coefficient
  (defun termnegate (term)
    (cons (- (coeff term)) (list (vars term))))
  
  ; Add the powers together
  (defun var* (var1 var2)
    (make-var (sym var1)
              (+ (pwr var1) (pwr var2))))
  
  ; Add terms of the same order
  (defun polyreduce (poly)
    ((tokenreduce term+ equal-order) poly))
  
  ; Multiply variables with the same symbol
  (defun varreduce (variables)
    ((tokenreduce var* equal-sym) variables))
  
  