Folded Reed–Solomon code

Folding of Reed–Solomon code with folding parameter m=3

The above definition is made more clear by means of the diagram with ${\displaystyle m=3}$, where ${\displaystyle m}$ is the folding parameter.

The message is denoted by ${\displaystyle f(X)}$, which when encoded using Reed–Solomon encoding, consists of values of ${\displaystyle f}$ at ${\displaystyle x_{0},x_{1},x_{2},\ldots ,x_{n-1}}$, where ${\displaystyle x_{i}=\gamma ^{i}}$.

Then bundling is performed in groups of 3 elements, to give a codeword of length ${\displaystyle n/3}$ over the alphabet ${\displaystyle \mathbb {F} _{q}^{3}}$.

Something to be observed here is that the folding operation demonstrated does not change the rate ${\displaystyle R}$ of the original Reed–Solomon code.

To prove this, consider a linear ${\displaystyle [n,k,d]_{q}}$ code, of length ${\displaystyle n}$, dimension ${\displaystyle k}$ and distance ${\displaystyle d}$. The ${\displaystyle m}$ folding operation will make it a ${\displaystyle \left[{\tfrac {n}{m}},{\tfrac {k}{m}},{\tfrac {d}{m}}\right]_{q^{m}}}$ code. By this, the rate ${\displaystyle R={\tfrac {k}{n}}}$ will be the same.

Decoding a folded Reed–Solomon code

Folded Reed–Solomon codes are basically the same as Reed Solomon codes, just viewed over a larger alphabet. To show how this might help, consider a folded Reed–Solomon code with ${\displaystyle m=3}$. Decoding a Reed–Solomon code and folded Reed–Solomon code for the same fraction of errors ${\displaystyle \rho }$ are tasks of almost the same computational intensity: one can unfold the received word of the folded Reed–Solomon code, treat it as a received word of the original Reed–Solomon code, and run the Reed–Solomon list decoding algorithm on it. Obviously, this list will contain all the folded Reed–Solomon codewords within distance ${\displaystyle \rho }$ of the received word, along with some extras, which we can expurgate.

Also, decoding a folded Reed–Solomon code is an easier task. Suppose we want to correct a third of the errors. The decoding algorithm chosen must correct an error pattern that corrects every third symbol in the Reed–Solomon encoding. But after folding, this error pattern will corrupt all symbols over ${\displaystyle \mathbb {F} _{q}^{3}}$ and will eliminate the need for error correction. This propagation of errors is indicated by the blue color in the graphical description. This proves that for a fixed fraction of errors ${\displaystyle \rho ,}$ the folding operation reduces the channel's flexibility to distribute errors, which in turn leads to a reduction in the number of error patterns that need to be corrected.

It is a Welch–Berlekamp-style interpolation (because it can be viewed as the higher-dimensional generalization of the Welch–Berlekamp algorithm). Suppose we received a codeword ${\displaystyle y}$ of the ${\displaystyle m}$-folded Reed–Solomon code as shown below

${\displaystyle \left({\begin{bmatrix}y_{0}\\y_{1}\\y_{2}\\\cdots \\y_{m-1}\end{bmatrix}},{\begin{bmatrix}y_{m}\\y_{m+1}\\y_{m+2}\\\cdots \\y_{2m-1}\end{bmatrix}},\ldots ,{\begin{bmatrix}y_{n-m}\\y_{n-m+1}\\y_{n-m+2}\\\cdots \\y_{n-1}\end{bmatrix}}\right)}$

We interpolate the nonzero polynomial

${\displaystyle Q(X,Y_{1},\ldots ,Y_{s})=A_{0}(X)+A_{1}(X)Y_{1}+\cdots +A_{s}(X)Y_{s},\qquad {\begin{cases}\deg(A_{i})\leqslant D&1\leqslant i\leqslant s\\\deg(A_{0})\leqslant D+k-1&\end{cases}}}$

by using a carefully chosen degree parameter ${\displaystyle D}$.

${\displaystyle D=\left\lfloor {\frac {N(m-s+1)-k+1}{s+1}}\right\rfloor }$

So the interpolation requirements will be

${\displaystyle Q\left(\gamma ^{im+j},y_{im+j},y_{im+j+1},\ldots ,y_{im+j+s-1}\right)=0,\quad {\text{for}}\quad i=0,1,\ldots ,{\tfrac {n}{m}}-1,j=0,1,\ldots ,m-s.}$

Then the number of monomials in ${\displaystyle Q(X,Y_{1},\ldots ,Y_{s})}$ is

${\displaystyle (D+1)s+D+k=(D+1)(s+1)+k-1>N(m-s+1)}$

Because the number of monomials in ${\displaystyle Q(X,Y_{1},\ldots ,Y_{s})}$ is greater than the number of interpolation conditions. We have below lemma

Lemma 1. ${\displaystyle 0\neq Q\in \mathbb {F} _{q}[X,Y_{1},\ldots ,Y_{s}]}$ satisfying the above interpolation condition can be found by solving a homogeneous linear system over ${\displaystyle \mathbb {F} _{q}}$ with at most ${\displaystyle Nm}$ constraints and variables. Moreover this interpolation can be performed in ${\displaystyle O(Nm\log ^{2}(Nm)\log \log(Nm))}$ operations over ${\displaystyle \mathbb {F} _{q}}$.[2]

This lemma shows us that the interpolation step can be done in near-linear time.

For now, we have talked about everything we need for the multivariate polynomial ${\displaystyle Q(X,Y_{1},\ldots ,Y_{s})}$. The remaining task is to focus on the message polynomials ${\displaystyle f(X)}$.

Lemma 2. If a candidate message polynomial ${\displaystyle f(X)\in \mathbb {F} [X]}$ is a polynomial of degree at most ${\displaystyle k-1}$ whose Folded Reed-Solomon encoding agrees with the received word ${\displaystyle y}$ in at least ${\displaystyle t}$ columns with

${\displaystyle t>{{D+k-1} \over {m-s+1}},}$

then ${\displaystyle Q(X,f(X),f(\gamma X),\ldots ,f(\gamma _{s-1}X))=0.}$[3]

Here "agree" means that all the ${\displaystyle m}$ values in a column should match the corresponding values in codeword ${\displaystyle y}$.

This lemma shows us that any such polynomial ${\displaystyle Q(X,Y_{1},\ldots ,Y_{s})}$ presents an algebraic condition that must be satisfied for those message polynomials ${\displaystyle f(x)}$ that we are interested in list decoding.

Combining Lemma 2 and parameter ${\displaystyle D}$, we have

${\displaystyle t(m-s+1)>{\frac {N(m-s+1)+s(k-1)}{s+1}}}$

Further we can get the decoding bound

${\displaystyle t\geqslant {\frac {N}{s+1}}+{\frac {s}{s+1}}\cdot {\frac {k}{m-s+1}}=N\left({\frac {1}{s+1}}+{\frac {s}{s+1}}\cdot {\frac {mR}{m-s+1}}\right)}$

We notice that the fractional agreement is

${\displaystyle {\dfrac {1}{s+1}}+{\dfrac {s}{s+1}}\cdot {\dfrac {mR}{m-s+1}}}$

During this step, our task focus on how to find all polynomials ${\displaystyle f\in {\mathbb {F} _{q}[X]}}$ with degree no more than ${\displaystyle k-1}$ and satisfy the equation we get from Step 1, namely

${\displaystyle A_{0}(X)+A_{1}(X)f(X)+A_{2}(X)f(\gamma X)+\cdots +A_{s}(X)f(\gamma ^{s-1}X)=0}$

Since the above equation forms a linear system equations over ${\displaystyle \mathbb {F} _{q}}$ in the coefficients ${\displaystyle f_{0},f_{1},\ldots ,f_{k-1}}$ of the polynomial

${\displaystyle f(X)=f_{0}+f_{1}X+\cdots +f_{k-1}X^{k-1},}$

the solutions to the above equation is an affine subspace of ${\displaystyle \mathbb {F} _{q}^{k}}$. This fact is the key point that gives rise to an efficient algorithm - we can solve the linear system.

It is natural to ask how large is the dimension of the solution? Is there any upper bound on the dimension? Having an upper bound is very important in constructing an efficient list decoding algorithm because one can simply output all the codewords for any given decoding problem.

Actually it indeed has an upper bound as below lemma argues.

Lemma 3. If the order of ${\displaystyle \gamma }$ is at least ${\displaystyle k}$ (in particular when ${\displaystyle \gamma }$ is primitive), then the dimension of the solution is at most ${\displaystyle s-1}$.[4]

This lemma shows us the upper bound of the dimension for the solution space.

Finally, based on the above analysis, we have below theorem

Theorem 1. For the folded Reed–Solomon code ${\displaystyle FRS_{q}^{(m)}[n,k]}$ of block length ${\displaystyle N={\tfrac {n}{m}}}$ and rate ${\displaystyle R={\tfrac {k}{n}},}$ the following holds for all integers ${\displaystyle s,1\leqslant s\leqslant m}$. Given a received word ${\displaystyle y\in (\mathbb {F} _{q}^{m})^{N}}$, in ${\displaystyle O((Nm\log q)^{2})}$ time, one can find a basis for a subspace of dimension at most ${\displaystyle s-1}$ that contains all message polynomials ${\displaystyle f\in \mathbb {F} _{q}[X]}$ of degree less than ${\displaystyle k}$ whose FRS encoding differs from ${\displaystyle y}$ in at most a fraction

${\displaystyle {\frac {s}{s+1}}\left(1-{\frac {mR}{m-s+1}}\right)}$

of the ${\displaystyle N}$ codeword positions.

When ${\displaystyle s=m=1}$, we notice that this reduces to a unique decoding algorithm with up to a fraction ${\displaystyle (1-R)/2}$ of errors. In other words, we can treat unique decoding algorithm as a specialty of list decoding algorithm. The quantity is about ${\displaystyle n^{O(1/\varepsilon )}}$ for the parameter choices that achieve a list decoding radius of ${\displaystyle 1-R-\varepsilon }$.

Theorem 1 tells us exactly how large the error radius would be.

Now we finally get the solution subspace. However, there is still one problem standing. The list size in the worst case is ${\displaystyle n^{\Omega (1/\varepsilon )}}$. But the actual list of close-by codewords is only a small set within that subspace. So we need some process to prune the subspace to narrow it down. This prune process takes ${\displaystyle q^{s}}$ time in the worst case. Unfortunately it is not known how to improve the running time because we do not know how to improve the bound of the list size for folded Reed-Solomon code.

Things get better if we change the code by carefully choosing a subset of all possible degree ${\displaystyle k-1}$ polynomials as messages, the list size shows to be much smaller while only losing a little bit in the rate. We will talk about this briefly in next step.

By converting the problem of decoding a folded Reed–Solomon code into two linear systems, one linear system that is used for the interpolation step and another linear system to find the candidate solution subspace, the complexity of the decoding problem is successfully reduced to quadratic. However, in the worst case, the bound of list size of the output is pretty bad.

It was mentioned in Step 2 that if one carefully chooses only a subset of all possible degree ${\displaystyle k-1}$ polynomials as messages, the list size can be much reduced. Here we will expand our discussion.

To achieve this goal, the idea is to limit the coefficient vector ${\displaystyle (f_{0},f_{1},\ldots ,f_{k-1})}$ to a special subset ${\displaystyle \nu \subseteq \mathbb {F} _{q}^{k}}$, which satisfies below two conditions:

Condition 1. The set ${\displaystyle \nu }$ must be large enough (${\displaystyle |\nu |\geq q^{(1-\varepsilon )k}}$).

This is to make sure that the rate will be at most reduced by factor of ${\displaystyle (1-\varepsilon )}$.

Condition 2. The set ${\displaystyle \nu }$ should have low intersection with any subspace ${\displaystyle S}$ of dimension ${\displaystyle s}$ satisfying ${\displaystyle S\subset \mathbb {F} _{q}^{k}}$ and ${\displaystyle |S\cap \nu |\leqslant L.}$ Such a subset is called subspace-evasive subset.

The bound for the list size at worst case is ${\displaystyle n^{\Omega (1/\varepsilon )}}$, and it can be reduced to a relative small bound ${\displaystyle O(1/\varepsilon ^{2})}$ by using subspace-evasive subsets.

During this step, as it has to check each element of the solution subspace that we get from Step 2, it takes ${\displaystyle q^{s}}$ time in the worst case (${\displaystyle s}$ is the dimension of the solution subspace).

Dvir and Lovett improved the result based on the work of Guruswami, which can reduce the list size to a constant.

Here is only presented the idea that is used to prune the solution subspace. For the details of the prune process, please refer to papers by Guruswami, Dvir and Lovett, which are listed in the reference.

If we don't consider the Step 3, this algorithm can run in quadratic time. A summary for this algorithm is listed below.

Overview of linear-algebraic list decoding algorithm for FRS code

Steps	Interpolation Root finding Prune
Runtime	${\displaystyle n^{\Omega (1/\varepsilon ^{2})}}$
Error radius	${\displaystyle 1-R-\varepsilon }$
List size	${\displaystyle n^{O(1/\varepsilon ^{2})}}$