How do you determine the number of errors in the Welch-Berlekamp method for decoding Reed-Solomon codes? I asked this question on cs.stackexchange, but the community appears to be very small and I got no response.
In the Welch-Berlekamp algorithm for decoding Reed-Solomon codes, one is given a list of points $(a_i, b_i)$ representing a message with $e$ errors on the $b_i$ in unknown locations (and $e$ is given to the algorithm). The output is a polynomial passing through all of the given points except those in which errors occurred, provided $e$ is sufficiently small.
The method involves solving a system of linear equations of the form
$$b_i E(a_i) = Q(a_i)$$
for all $i$ where $E$ has degree $e$ and $Q$ has degree at most $e+k-1$. The variables are the coefficients of $E$ and $Q$. 
To ensure that $E$ has degree $e$ one usually adds the constraint that the coefficient of $x^e$ is 1 to the linear system above. However, in practice one doesn't necessarily know $e$. One inefficient (but still polynomial time) way to deal with this is to try $e$ for all values starting with $(n+k-1)/2 - 1$ going down until a solution is found. 
My question is: is there a more efficient way to determine $e$? Alternatively, is there a modification to the linear system that allows one to use an upper bound on $e$ instead of the exact value?
In particular I want to use this specific decoder for Reed-Solomon codes, and not a completely different algorithm based on other techniques. 
 A: 
is there a more efficient way to determine e

Apparently not (unless you use a syndrome based algorithm). Wiki article describes the time complexity as O($N^3$).
http://en.wikipedia.org/wiki/Berlekamp%E2%80%93Welch_algorithm
Note the maximum value for e is ((n-k+1)/2)-1. If there are more than ((n-k+1)/2)-1 errors, then if the code is not a shortened code, there will always be an apparent solution that ends up creating a total of (n-k) (or more) errors. What typically happens is ((n-k+1)/2)-1 errors are created in addition to ((n-k+1)/2) errors, which will map into a valid code word (one that doesn't appear to have any errors). If the code is a shortened code, there's still some chance of a (n-k) error result, if the calculated error locations happen to fall within range of the shortened code. If any calculated error locations are outside the range, then an failure case (too many errors) is detected.
In case it's not clear to others here, the process starts off assuming the maximum error case e = ((n-k+1)/2)-1, and if there are less than e errors, the determinant for the set of linear equations will be zero, in which case e is decremented and the process repeated until the set of linear equations can be solved or e reaches zero (no errors).
