anchor.diff:  
   (defun add-lump (lump bpn)
     "Add LUMP to BPN. MAX-N-STRIPES of LUMP gets set to equal that of
  -the previous last, non-weight lump of BPN."
  +  the previous last, non-weight lump of BPN."
     (when (find-lump (name lump) bpn)
       (error "Cannot add ~S: ~%
               a lump of same name has already been added to this network." lump))
  
positive.code:    (same-stripes-p
      :initform nil :initarg :same-stripes-p :reader same-stripes-p
      :documentation "Non-NIL iff all stripes are the same. If true, it
  effectively overrides both N-STRIPES and MAX-N-STRIPES and there is
  only one row in NODES and DERIVATIVES. Set up by the lump itself
  taking its inputs into account. Notably, ->WEIGHTs always have
  SAME-STRIPES-P T.")
     (nodes
      :initform nil :type mat :reader nodes
      :documentation "The values of the nodes. All nodes have values. It
  is conceptually a N-STRIPES x SIZE matrix that can be enlarged to
  MAX-N-STRIPES x SIZE by setting N-STRIPES.")
     (derivatives
      :initform nil :type mat :reader derivatives
      :documentation "Derivatives of nodes, input node derivatives are
  not calculated. A 1d array representing a matrix of the same dimension
  as NODES.")
     (default-value
      :initform #.(flt 0) :initarg :default-value :type flt
      :reader default-value
      :documentation "Upon creation or resize the lump's nodes get
  filled with this value.")))
  
  (declaim (inline derivatives*))
  (defun derivatives* (lump)
  
negative.code:    (softmax
      :reader softmax
      :documentation "A matrix of the same size as X, EXP'ed and
      normalized in groups of GROUP-SIZE.")
     (target
      :initarg :target :reader target
      :documentation "A lump of the same size as INPUT-LUMP that is the
      T in -sum_{k}target_k*ln(x_k) which the the cross entropy error.")
     (class-weights
      :initarg :class-weights
      :accessor class-weights
      :documentation "If non-NIL, an FLT-VECTOR of GROUP-SIZE. Useful
      TARGET's distribution is different on the training and test sets.
      Just set w_i to test_frequency_i/training_frequency_i.")
     (normalized-lump :reader normalized-lump))
    (:documentation "A specialized lump that is equivalent to hooking
    ->EXP with NORMALIZED-LUMP and ->CROSS-ENTROPY but is numerically
    stable. See
    <http://groups.google.com/group/comp.ai.neural-nets/msg/a7594ebea01fef04?dmode=source>
  
    It has two parameters X and TARGET. In the transfer phase it
    computes the EXP of each input node and normalizes them as if by
    NORMALIZED-LUMP. These intermediate values are placed into SOFTMAX.
    The value node K is nodes_k = - target_k * ln(softmax_k). Since the
    sum of this is cross entropy: - sum_k target_k * ln(softmax_k),
    simply plug this lump into an ->ERROR.
  
    In the derive phase it computes the cross entropy error of the
    normalized input: d(-sum_k{target_k * ln(softmax_k)})/dx_k = sum_j{
    target_j * (softmax_k - KDELjk)} which is equal to softmax_k -
    target_k if target sums to 1."))
  
  (defun add-cross-entropy-softmax (&key predictions-name expectations-name
                                    (error-name (list predictions-name :error))
  