anchor.diff:          weightsOut = (mIdentity netOutputs.Length)
           outputLayerErrors = (answers, netOutputs) ||> List.map2 (-) }
      
  -    let newNeuronAndError inputs outputErrors outputWeights  output oldNeuron = 
  -        let neuronError = 
  -            ((outputWeights, outputErrors) ||> List.map2 (*)  |> List.sum) 
  -            * output * (1.0 - output) 
  -        let newNeuron = 
  -            (bias::inputs, oldNeuron) ||> List.map2 (fun input oldWeight -> 
  -                oldWeight + learningConstant * neuronError * input)
  -        (newNeuron, neuronError)
  -    let newLayerAndErrors inputs  oldLayer bpData= 
  -        let newLayer, errors = 
  -            (bpData.weightsOut, bpData.values, oldLayer) 
  -            |||> List.map3 (newNeuronAndError inputs bpData.outputLayerErrors)
  -            |> List.unzip
  -        {   newNet = newLayer::(bpData.newNet)
  -            values = inputs 
  -            weightsOut = (mTranspose oldLayer).Tail
  -            outputLayerErrors = errors}
  -    let bpResult = (allInputs, net, initialBpState) |||> List.foldBack2 newLayerAndErrors  
  +    let updateLayer inputs oldLayer bpData =         
  +        let neuronErrors = 
  +            (bpData.weightsOut, bpData.values) 
  +            ||> List.map2 (fun outputWeights value -> 
  +                ((0.0, outputWeights, bpData.outputLayerErrors) 
  +                    |||> List.fold2 (fun s w e -> s + w*e)) * value * (1.0 - value))
  +        let newLayer =
  +            (oldLayer, neuronErrors) 
  +                ||> List.map2 (fun oldNeuron neuronError ->
  +                (bias::inputs, oldNeuron) ||> List.map2 (fun input oldWeight -> 
  +                    oldWeight + learningConstant * neuronError * input))
  +        let newBpState = {
  +             newNet = newLayer::(bpData.newNet)
  +             values = inputs 
  +             weightsOut = (mTranspose oldLayer).Tail
  +             outputLayerErrors = neuronErrors}
  +        newBpState
  +    let bpResult = 
  +        (allInputs, net, initialBpState) 
  +            |||> List.foldBack2 updateLayer  
       bpResult.newNet
   
   // Measure
  
positive.code:     let samples = getSamples xorCases 10000
      printfn "cost before: %f" (calcCost samples (feedForward net) )
      xorCases |> Array.iter (fun (inputs, answer) -> printfn "%f" (feedForward net inputs).[0])
      let finalNet = (net, samples) ||> List.fold (fun net (input, answers) -> (trainNet net input answers))
      printfn "cost after:  %f" (calcCost samples (feedForward finalNet) )
      xorCases |> Array.iter (fun (inputs, answer) -> printfn "%f" (feedForward finalNet inputs).[0])
  
  
negative.code:     outputLayerErrors : float list
  }
  
  let backPropagate net args answers =
      let allValues = evalNet net args
      let allInputs, netOutputs = bodyAndTail allValues
   
      let initialBpState = {
          newNet = []
  