A brief adventure in C++ by Michael Cotton

List decoding

constructing a bivariate polynomial, Q(x , y) so that the data points of the codeword are zeros (with a certain multiplicity) of Q(x , y). Also, we want the (1 , k-1) weighted degree of the polynomial to be as small as possible.

finding all factors, y – p(x) that divide Q(x , y) where p(x) has degree k – 1 or less. These p(x), y-roots form the list of possibilities for the decoded codeword.

Factorization

If Q(x , y) is in F[x , y] and Q(a , b) = 0, then Q has a zero at (a , b).

Q has a zero of multiplicity m at (0,0) if the coefficients of each term = 0 for all terms where i + j < m and i and j are the powers of x and y, respectively.

Q(x , y) has a zero of multiplicity m at (a , b) if Q(x + a , y + b) has a zero of multiplicity m at (0,0).

Note that a zero of multiplicity m requires m(m+1)/2 coefficients are zero.

For Kötter’s solution to the interpolation problem, we use a (1 , k-1)-reverse lexicographic monomial order.

This means that we determine the degree of each monomial term by first multiplying the power of y by (k-1) and adding the power of x.

For example, x2y3 has weighted degree 2 + 3(k-1)

Finally, a reverse lexicographic order is one where two monomials of the same degree are ordered in decreasing powers of x.

The weighted degree of a polynomial is the weighting applied to the highest powers of its variables.

We let FL[x , y] is the set of polynomials from F[x , y] with a y-degree less than or equal to L.

Note that FL[x , y] is an F[x]-module which means that if Q(x , y) is in FL[x , y] and p(x) is in F[x], then p(x)Q(x , y) is also in FL[x , y].

The interpolating polynomial may be constructed with the desired zeros by satisfying a number of (Hasse) derivative conditions.

Fortunately, the Hasse derivative as a mapping from F[x , y] to F is a linear functional… i.e. D(aP + bQ) = aD(P) + bD(Q) where a,b are field elements and P,Q are polynomials.

Each of the derivative mappings has a kernel associated with it. A kernel is everything that is mapped to zero.

Kötter’s solution takes advantage of working with f[x]-modules and linear functionals to provide a rather efficient method for finding a minimal element of the cumulative kernel from these mappings.

Then finally, we’re ready to factor it.

The factorization problem is to take the interpolation polynomial Q(x , y) and find all polynomials p(x) such that y – p(x) divides Q. We call these polynomials the y-roots of Q.

To begin, let Q0= Q/xm , where m is the highest power of x that divides Q(x , y), and we find the first coefficient(s) by finding the root(s) of Qo(0,y) = 0.

The algorithm derives the next Qu so that the next coefficient(s) are also the root(s) 0f Qu(0,y) = 0

Seemingly random choices for decoding candidates coming out of the factor tree.

Higher interpolation multiplicities seem to cause numerous problems. The big one is that the interpolation polynomial seems to lose the structure necessary for the factoring to work.

While the list decoder without strong interpolation should match the performance of the bounded distance decoding, it does consistently worse. However, the difference seems constant, and I believe it is because, currently, a decoding failure in the list decoder will result in 50 percent error for every bit in the codeword. I am confident that, for m=1, the list decoding algorithm is working properly, although a test for probability of decoder failure is needed.