anchor.diff:                         (make-array (length (inputs lazy-array)) :initial-element nil))))
               (:copier nil)
               (:predicate nil))
  -  (name (gensym))
     (lazy-array nil :type lazy-array :read-only t)
     ;; An alist with one (argument-index . a-d-record) entry per reference to
     ;; this record's lazy array.
  
positive.code:   (with-accessors ((transformation transformation)
                     (shape shape)) reference
      (if (transformation-invertiblep transformation)
          (make-reference
           output-gradient
           (shape reference)
           (invert-transformation (transformation reference)))
          ;; The input gradient of a broadcasting reference is the average of
          ;; all incoming gradients.
          (let ((axes '()))
  
negative.code:           index))))))
  
  (defun ad-record-output-gradient (ad-record)
    (let* ((cached-value (ad-record-output-gradient-cache ad-record)))
      (if (not (null cached-value))
          cached-value
          (let* ((lazy-array (ad-record-lazy-array ad-record))
                 (zero (coerce 0 (element-type lazy-array)))
                 (zeros (reshape zero (shape lazy-array)))
                 (alist (ad-record-alist ad-record))
                 (gradients
                   (loop for (index . record) in alist
                         collect
                         (fuse* zeros (ad-record-input-gradient record index)))))
            (setf (ad-record-output-gradient-cache ad-record)
                  (α #'*
                     (ad-record-lazy-array ad-record)
  