anchor.diff:                    (lambda ,symbols
                       (declare (ignorable ,@symbols))
                       (values ,@output-forms))
  -                  ,input-constraints
  -                  ,(length output-forms)))))))
  +                  ,input-constraints))))))
   
   (test identity-transformation
     (let ((τ (τ (a b) a b)))
  
positive.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)))
            ;; 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)
  
negative.code: ;; 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)
    (if (and (constantp input-constraints env)
             (not (free-variables function)))
        `(load-time-value
          (classify-transformation
           ,function
           ,input-constraints))
        whole))
  
  (defmacro τ (input-forms &rest output-forms)
  