anchor.diff:  ;; constants. This makes it possible to move the classification of many
   ;; transformations to load time.
   (define-compiler-macro classify-transformation
  -    (&whole whole &environment env
  -            function input-constraints output-dimension)
  +    (&whole whole &environment env function input-constraints)
     (if (and (constantp input-constraints env)
  -           (constantp output-dimension env)
              (not (free-variables function)))
         `(load-time-value
           (classify-transformation
            ,function
  -         ,input-constraints
  -         ,output-dimension))
  +         ,input-constraints))
         whole))
   
   (defmacro τ (input-forms &rest output-forms)
  
positive.code:        :linear-operator A
         :translation-vector b)))
  
  (defun classify-transformation (f input-constraints output-dimension)
    (let* ((input-dimension (length input-constraints))
           (args (map 'list
                      (λ constraint (or constraint 0))
  
negative.code:              (setf (aref arg-conses i) arg-cons))
      ;; Initially x is the zero vector (except for input constraints, which
      ;; are ignored by A), so f(x) = Ax + b = b
      (let* ((translation-vector (multiple-value-call #'vector (apply f args)))
             (output-dimension (length translation-vector))
             ;; now determine the scaled permutation matrix A
             (column-indices (make-array output-dimension
                                         :element-type 'array-index
                                         :initial-element 0))
             (values (make-array output-dimension
                                 :element-type 'rational
                                 :initial-element 0)))
        ;; set one input at a time from zero to one (ignoring those with
        ;; constraints) and check how it changes the result
        (iterate (for input-constraint in-vector input-constraints)
  