anchor.diff:     (operator-metadata :type operator-metadata))
     (:documentation
      "Let F be a referentially transparent Common Lisp function that accepts
  -   n arguments, and let A1...AN be data structures with index space Ω. The
  -   the application of f to A1...AN is a data structure that maps each index
  -   k ∈ Ω to (F (A1 k) ... (AN k))."))
  +    n arguments, and let A1...AN be data structures with index space Ω. The
  +    the application of f to A1...AN is a data structure that maps each
  +    index k ∈ Ω to (F (A1 k) ... (AN k))."))
   
   (define-class reduction (data-structure)
     ((operator          :type function)
  
positive.code: (defgeneric reference (object space transformation)
    (:documentation
     "Return a -- potentially optimized and simplified -- data structure
     equivalent to an instance of class REFERENCE.")
    (:method-combination or)
    (:method or ((object data-structure)
                 (space index-space)
  
negative.code:    (order             :type (member :up :down :arbitrary) :initform :up))
    (:documentation
     "Let F be a referentially transparent Common Lisp function that accepts
      two arguments, and let A be a data structure of dimension n, i.e. a
      mapping from each element of the cartesian product of the spaces S1,
      ..., Sn to some values. Then the reduction of A by F is a data
      structure of dimension n-1 that maps each element k of S1 ⨯ ... ⨯ Sn-1
      to the pairwise combination of the elements {a(i) | i ∈ k ⨯ Sn} by F in
      some ORDER."))
  
  (define-class fusion (data-structure) ()
    (:documentation
     "Let A1...AN be strided arrays with equal dimension, each mapping from
      an index space Ωk to a set of values.  Furthermore, let the sets
      Ω1...ΩN be pairwise disjoint, and let Ωf = ∪ Ω1...Ωk be again a valid
      index space. Then the fusion of A1...AN is a data structure that maps
      each index i ∈ Ωf to the value of i of the unique strided array Ak
      whose index space contains i."))
  
  (define-class reference (data-structure)
    ((transformation :type transformation))
    (:documentation
     "Let A be a strided array with domain ΩA, let ΩB be a strided array
      index space and let T be a transformation from ΩB to ΩA. Then the
      reference of A by ΩB and T is a strided array that maps each index
      tuple k \in ΩB to A(T(k))."))
  
  (define-class kernel ()
    ((target          :type immediate)
  