anchor.diff:                  (mapcar (lambda (rhs-expr)
                             (list '= lhs-expr rhs-expr))
                           ;; remove all but the expressions whose value is the same as lhs-expr
  -                        (remove lhs-expr (make-exprs rhs)
  +                        (remove (eval lhs-expr) (make-exprs rhs)
                             :test-not #'eql
                             :key #'eval)))
                 (make-exprs lhs))
  
positive.code: 
  (defun precedes-p (op1 op2 lhs)
    "Return T if an expression of OP2 can be written without parentheses at the LHS/RHS of an expression of OP1."
    )
  
  (defun unary-p (expr)
    "Return T if EXPR is the application of a unary operator."
  
negative.code:     (remove-duplicates
        (mapcar #'prefix-to-infix
          (mapcan (lambda (i &aux (sides (split numbers i))) ;p17
                    ;; consider negations as well (reducing them later is much more cumbersome)
                    (append (make-equations (car sides) (cadr sides))
                            (make-equations (cons (- (caar sides)) (cdar sides))
                                            (cons (- (caadr sides)) (cdadr sides)))
                            ))
            (range 1 (1- (length numbers))))) ;p22
        :test #'equal)))
  
  