anchor.diff:      (assert (zerop (mod n-stripes batch-size)) ()
               "BATCH-SIZE ~S is not a divisor of N-STRIPES ~S." batch-size
               n-stripes)
  -    (flet ((foo (batch-mean batch-stddev)
  +    (flet ((foo (batch-mean batch-variance)
                (with-ones (ones (list batch-size 1))
                  (with-thread-cached-mats
                      ((x-mu* dimensions)
  
positive.code:                    (copy! nx diffs)
                     (gemm! -1 ones batch-mean 1 diffs)
                     (.square! diffs)
                     (sum! diffs batch-stddev :axis 0)
                     (scal! (/ batch-size) batch-stddev)
                     (.+! (variance-adjustment state) batch-stddev)
                     (.sqrt! batch-stddev))
                   ;; update population statistics
                   (scal! decay population-mean)
                   (axpy! (- 1 decay) batch-mean population-mean)
                   (scal! decay population-stddev)
                   (axpy! (- 1 decay) batch-stddev population-stddev))
                 ;; calculate the output
                 (multiple-value-bind (mean stddev)
                     (if (and *in-training-p*
                              (or (not use-population-p)
                                  ;; KLUDGE: let the population
                                  ;; statistics settle
                                  (< (n-steps state) (log 0.1 decay))))
                         (values batch-mean batch-stddev)
                         (values population-mean population-stddev))
                   ;; FIXOPT: when training this has been done above
                   (copy! nx nl)
                   (gemm! -1 ones mean 1 nl)
                   (with-thread-cached-mat (stddevs dimensions)
                     (gemm! 1 ones stddev 0 stddevs)
                     (.inv! stddevs)
                     (.*! stddevs nl)))
                 (scale-columns! (nodes (scale state)) nl)
                 (gemm! 1 ones (nodes (shift state)) 1 nl))))
        (let ((batch-dimensions (list batch-size size)))
  
negative.code:               (append1 (batch-mean lump) (make-mat (list 1 (size lump)))))))
    (elt (batch-mean lump) subbatch-index))
  
  (defun ensure-batch-variance (lump subbatch-index)
    (let ((length (length (batch-variance lump))))
      (if (< subbatch-index length)
          (setf (elt (batch-variance lump) subbatch-index)
                (adjust! (elt (batch-variance lump) subbatch-index)
                         (list 1 (size lump)) 0))
          (setf (slot-value lump 'batch-variance)
                (append1 (batch-variance lump)
                         (make-mat (list 1 (size lump)))))))
    (elt (batch-variance lump) subbatch-index))
  
  (defun ensure-population-mean (lump)
    (setf (slot-value lump 'population-mean)
  