Three Efficient All-Erasure Decoding Methods for Blaum–Roth Codes

Abstract

Blaum–Roth Codes are binary maximum distance separable (MDS) array codes over the binary quotient ring ${\mathbb{F}}_2\left[x\right]/\left(M_p\left(x\right)\right)$, where $M_p\left(x\right)=1+x+\cdots +x^{p-1}$, and p is a prime number. Two existing all-erasure decoding methods for Blaum–Roth codes are the syndrome-based decoding method and the interpolation-based decoding method. In this paper, we propose a modified syndrome-based decoding method and a modified interpolation-based decoding method that have lower decoding complexity than the syndrome-based decoding method and the interpolation-based decoding method, respectively. Moreover, we present a fast decoding method for Blaum–Roth codes based on the LU decomposition of the Vandermonde matrix that has a lower decoding complexity than the two modified decoding methods for most of the parameters.

1. Introduction

Redundancy is necessary in storage systems in order to provide high data reliability in case of disk failures [1]. Replication and erasure codes are two main ways of including redundancy. The idea of replication is that the data in one disk are copied to multiple disks. The storage system replaces damaged disks with their copies when some disks are erased. It is fast to repair the erased disks but requires a lot of storage space. In contrast, erasure codes provide higher data reliability with a small storage cost.

Maximum distance separable (MDS) codes [2] are typical erasure codes that have optimal tradeoff between storage cost and data reliability, i.e., they can achieve the minimum storage cost given a level of data reliability. Binary MDS codes are special MDS codes that have lower computational complexity in the encoding/decoding procedures, since only XORs and cyclic-shift operations are involved. Some existing constructions of binary MDS codes are EVENODD codes [3,4], RDP codes [5], and X-codes [6,7], which can correct any two-column (we use “column" and “disk" interchangeably in this paper) erasures. RTP codes [8], Star codes [9,10], and extended EVENODD codes [11,12,13,14] can correct any three-column erasures. With the rapid increase in the data scale in storage systems [15], we need to design binary MDS codes that can correct any number of erasures as well as efficient encoding/decoding methods. Graftage codes [16] can achieve various tradeoffs between storage and repair bandwidth, while we focus on efficient decoding methods of binary MDS codes. Blaum–Roth codes [17] are this type of code, which are designed over the ring ${\mathcal{R}}_p={\mathbb{F}}_2\left[x\right]/\left(M_p\left(x\right)\right)$, where $M_p\left(x\right)=1+x+\cdots +x^{p-1}$, and p is a prime number.

When some columns are erased, the syndrome-based decoding method [17] and the interpolation-based decoding method [18] have been proposed to recover the erased columns. In the decoding methods [17,18], there are three basic operations over the ring ${\mathcal{R}}_p$: (i) addition, (ii) multiplication of a power of x and a polynomial, and  (iii) division of factor $1+x^b$ with $1\le b\le p-1$. It is shown in the decoding methods [17,18] that we can first take the operations (i) and (ii) modulo $1+x^p$ and then take the results of modulo $M_p\left(x\right)$, while operation (iii) in the decoding methods [17,18] is directly taken as modulo $M_p\left(x\right)$.

In this paper, we show that we can also compute operation (iii) as modulo $1+x^p$, which has lower computational complexity than modulo $M_p\left(x\right)$. We propose modified decoding methods for the two existing decoding methods [17,18] that have a lower decoding complexity than the original decoding methods by computing operation (iii) as modulo $1+x^p$ instead of modulo $M_p\left(x\right)$. The reason our modified decoding methods have much lower decoding complexity than the decoding methods [17,18] is twofold. First, all the operations in our decoding methods are taken as modulo $1+x^p$, while the existing decoding methods execute the divisions as modulo $M_p\left(x\right)$. Second, we propose new algorithms in the decoding procedure to reduce the number of operations. Please refer to Section 3 for our two modified decoding methods. Moreover, the efficient LU decoding method [19] proposed for extended EVENODD codes decoding can also be employed to recover the erased columns of Blaum–Roth codes. We show that the LU decoding method has lower decoding complexity than the two modified decoding methods for most of the parameters. We define the decoding complexity as the total number of XORs required to recover the erased columns.

2. Blaum–Roth Codes

In this section, we first review the construction of Blaum–Roth codes [17] and then show the efficient operations over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$. Finally, we present an algorithm to compute multiple multiplications, which have two nonzero terms over ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ with lower complexity.

2.1. Construction of Blaum–Roth Codes [17]

The codeword of Blaum–Roth codes [17] is a $(p-1)\times n$ array ${\left[c_{i,j}\right]}_{i=0,j=0}^{p-2,n-1}$ that is encoded from the $(p-1)k$ information bits, where $c_{i,j}\in {\mathbb{F}}_2$ and $n\le p$. We can view any k columns of the $(p-1)\times n$ array as information columns that store the $(p-1)k$ information bits and the other $r=n-k$ columns as parity columns that store the $(p-1)r$ parity bits. For $j=0,1,\dots ,n-1$, we represent the $p-1$ bits in column j by a polynomial $c_j\left(x\right)={\sum }_{i=0}^{p-2}{c}_{i,j}{x}^i$. The $(p-1)\times n$ array of Blaum-Roth codes is defined as

$$\left(\begin{array}{cccc}{c}_0\left(x\right)& c_1\left(x\right)& \cdots & c_{n-1}\left(x\right)\end{array}\right)·{\mathbf{H}}_{r\times n}^T\equiv \mathbf{0}\left(\mathrm{mod}{M}_p\left(x\right)\right),$$

where ${\mathbf{H}}_{r\times n}$ is the $r\times n$ parity-check matrix

$${\mathbf{H}}_{r\times n}=\left[\begin{array}{ccccc}1& 1& 1& \cdots & 1\\ 1& x& x^2& \cdots & x^{n-1}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 1& x^{(r-1)}& x^{(r-1)2}& \cdots & x^{(r-1)(n-1)}\end{array}\right],$$

and $\mathbf{0}$ is the all-zero row of length r. We denote the Blaum–Roth codes defined above as $\mathcal{C}(p,n,r)$. When $p\ge n$ and p is a prime number, we can always retrieve all the information bits from any k out of the n polynomials [17], i.e., $\mathcal{C}(p,n,r)$ are MDS codes.

If we let $c_{p-1,j}=0$ for all $j=0,1,\dots ,n-1$, then $\mathcal{C}(p,n,r)$ can be equivalently defined as the following $p·r$ linear constraints. (The subscripts are taken as modulo p unless otherwise specified.)

$$\sum _{j=0}^{n-1}{c}_{{⟨m-\ell ·j⟩}_p,j}=0,$$

where $0\le m\le p-1$ and $0\le \ell \le r-1$.

Suppose that the $\lambda$ columns ${\left\{e_i\right\}}_{i=0}^{\lambda -1}$ are erased, where $\lambda \ge 2$ and $0\le e_0<\cdots <e_{\lambda -1}<n$. Let the $\delta =n-\lambda$ surviving columns be ${\left\{h_j\right\}}_{j=0}^{\delta -1}$, where $0\le h_0<\cdots <h_{\delta -1}<n$ and ${\left\{e_i\right\}}_{i=0}^{\lambda -1}\cup {\left\{h_j\right\}}_{j=0}^{\delta -1}=\{0,1,\dots ,n-1\}$. We have

$$\left(\begin{array}{cccc}{c}_{e_0}\left(x\right)& c_{e_1}\left(x\right)& \cdots & c_{e_{\lambda -1}}\left(x\right)\end{array}\right)·{\mathbf{V}}_{\lambda \times \lambda }^T=\mathbf{S},$$

(1)

over the ring ${\mathcal{R}}_p$, where ${\mathbf{V}}_{\lambda \times \lambda }$ is the $\lambda \times \lambda$ square

$${\mathbf{V}}_{\lambda \times \lambda }=\left[\begin{array}{ccccc}1& 1& 1& \cdots & 1\\ x^{e_0}& x^{e_1}& x^{e_2}& \cdots & x^{e_{\lambda -1}}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ x^{(\lambda -1)e_0}& x^{(\lambda -1)e_1}& x^{(\lambda -1)e_2}& \cdots & x^{(\lambda -1)e_{\lambda -1}}\end{array}\right],$$

and $\mathbf{S}=\left(\begin{array}{cccc}{S}_0\left(x\right)& S_1\left(x\right)& \cdots & S_{\lambda -1}\left(x\right)\end{array}\right)$, where the $\lambda$ syndrome polynomials are

$$S_{\ell }\left(x\right)=\sum _{j=0}^{\delta -1}{x}^{\ell ·h_j}{c}_{h_j}\left(x\right)\mathrm{for}0\le \ell \le \lambda -1.$$

(2)

In this paper, we present three efficient decoding methods to solve the linear systems in Equation (1) over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$.

2.2. Efficient Operations over ${\mathbb{F}}_2\left[x\right]/(1+x^p)$

It is more efficient to compute the multiplication of a power of x and division of the factor $1+x^b$ over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ rather than over the ring ${\mathcal{R}}_p$: (i) Let $a\left(x\right)\in {\mathcal{R}}_p$, and the multiplication $x^i·a\left(x\right)$ over the ring ${\mathcal{R}}_p$ in [17] (Equation (19)) takes $p-1$ XORs, while the multiplication $x^i·a\left(x\right)$ over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ takes no XORs [20]. (ii) Let $g\left(x\right),f\left(x\right)\in {\mathbb{F}}_2\left[x\right]/(1+x^p)$, where d is a positive integer, which is coprime with p. Consider the equation

$$(1+x^d)g\left(x\right)\equiv f\left(x\right)(\mathrm{mod}1+x^p),$$

(3)

where $f\left(x\right)$ has an even number of nonzero terms. Given such $f\left(x\right)$ and d, we can compute $g\left(x\right)$ by Lemma 1.

Lemma 1.

[Lemma 8] in [21] The coefficients of $g\left(x\right)$ in Equation (3) are given by

$$\begin{array}{cc}\hfill g_{p-1}& =0,g_{p-d-1}=f_{p-1},g_{d-1}=f_{d-1},\hfill \\ \hfill g_{p-(\ell +1)d-1}& =g_{p-\ell d-1}+f_{p-\ell d-1}\mathrm{for}\ell =1,2,\dots ,p-3.\hfill \end{array}$$

By Lemma 1, computing the division $\frac{f\left(x\right)}{1+x^d}$ takes $p-3$ XORs, but we are not sure whether $g\left(x\right)$ has an even number of nonzero terms or not. If we want to guarantee that $g\left(x\right)$ has an even number of nonzero terms, we should use Lemma 2 to compute the division $\frac{f\left(x\right)}{1+x^d}$.

Lemma 2.

[Lemma 13] in [20] The coefficients of $g\left(x\right)$ in Equation (3) are given by

$$\begin{array}{cc}\hfill g_0& =f_{2d}+f_{4d}+\cdots +f_{(p-1)d},\hfill \\ \hfill g_{\ell d}& =g_{(\ell -1)d}+f_{\ell d}\mathrm{for}\ell =1,2,\dots ,p-1.\hfill \end{array}$$

By Lemma 2, the division $\frac{f\left(x\right)}{1+x^d}$ takes $\frac{3p-5}{2}$ XORs, and $g\left(x\right)$ has an even number of nonzero terms. However, computing the division $\frac{f\left(x\right)}{1+x^d}$ in [Corollary 2] in [17] takes $2(p-1)$ XORs over the ring ${\mathcal{R}}_p$, which is strictly larger than the decoding methods in Lemmas 1 and 2. It is shown in [Theorem 5] in [19] that we can always solve the equations in Equation (1) over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ of which all the solutions are congruent to each other after modulo $M_p\left(x\right)$. Therefore, we can first solve the equations in Equation (1) over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ and then obtain the unique solution by taking modulo $M_p\left(x\right)$ to reduce the computational complexity.

2.3. Multiple Multiplications over ${\mathbb{F}}_2\left[x\right]/(1+x^p)$

Note that in our modified syndrome-based decoding method and the modified interpolation-based decoding method, we need to compute multiple polynomial multiplications, where each polynomial has two nonzero terms. Suppose that we want to compute the following m multiplications

$$\mathcal{L}\left(x^{\tau }\right)=\prod _{i=0}^{m-1}(x^{\tau }-x^{{\xi }_i})(\mathrm{mod}1+x^p),$$

(4)

where m is a positive integer, $0\le \tau \le p-1$ such that $\tau \notin \{{\xi }_0,{\xi }_1,\dots ,{\xi }_{m-1}\}$, and $0\le {\xi }_0<\cdots <{\xi }_{m-1}<n$.

We can derive from Equation (4) that

$$\mathcal{L}\left(x^{\tau }\right)=x^{\pi }·\prod _{i=0}^{m-1}(1+x^{d_i})(\mathrm{mod}1+x^p),$$

(5)

where $\pi ={\sum }_{i=0}^{m-1}min(\tau ,{\xi }_i)$ modulo p and $d_i=|\tau -{\xi }_i|$ for $i=0,1,\dots ,m-1$.

Algorithm 1 presents a method to simplify the multiplications in Equation (4). In Algorithm 1, we use ${\mathsf{\Gamma }}_{\ell }$ to denote the number of the polynomial $1+x^{\ell }$ in the multiplication $\mathcal{L}\left(x^{\tau }\right)$. Note that we only need to count the number of $1+x^{\ell }$ for $1\le \ell \le \frac{p-1}{2}$, because the equation $1+x^{\ell }\equiv x^{\ell }·(1+x^{p-\ell })$ modulo $1+x^p$ holds for $\frac{p-1}{2}<\ell <n$. If ${\mathsf{\Gamma }}_{\ell }>1$, then we have ${(1+x^{\ell })}^{{\mathsf{\Gamma }}_{\ell }}={(1+x^{\ell })}^{{\mathsf{\Gamma }}_{\ell }-2\lfloor \frac{{\mathsf{\Gamma }}_{\ell }}{2}\rfloor }·{(1+x^{2\ell })}^{\lfloor \frac{{\mathsf{\Gamma }}_{\ell }}{2}\rfloor }$. Therefore, we can always merge ${\mathsf{\Gamma }}_{\ell }$ multiplications ${(1+x^{\ell })}^{{\mathsf{\Gamma }}_{\ell }}$ into ${\mathsf{\Gamma }}_{\ell }-\lfloor \frac{{\mathsf{\Gamma }}_{\ell }}{2}\rfloor$ multiplications and the computational complexity can be reduced with Algorithm 1. When Algorithm 1 is executed, all elements of count-array $\mathsf{\Gamma }$ should be zero or one, and the length $\eta$ of the final $\mathcal{L}\left(x^{\tau }\right)$ is between 1 and m.

Algorithm 1: Simplify the multiple multiplications.

3. Decoding Algorithm

In this section, we present two decoding methods over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ by modifying two existing decoding methods [17,18] that can reduce the decoding complexity.

Recall that the $\lambda$ erased columns are $\lambda$ columns ${\left\{e_i\right\}}_{i=0}^{\lambda -1}$, and the $\delta =n-\lambda$ surviving columns are $\delta$ columns ${\left\{h_j\right\}}_{j=0}^{\delta -1}$.

3.1. Modified Syndrome-Based Method

We define the function of the indeterminate z

$$G_i\left(z\right)=\prod _{s=0,\ne i}^{\lambda -1}(1-x^{e_s}z)=\sum _{\ell =0}^{\lambda -1}{G}_{i,\ell }\left(x\right)z^{\ell },$$

and the syndrome function $S\left(z\right)={\sum }_{\ell =0}^{r-1}{S}_{\ell }\left(x\right)z^{\ell }$, where $0\le i\le \lambda -1$ and $S_{\ell }\left(x\right)$ is given in Equation (2). We can obtain in [Equation (18)] in [17] that

$$\begin{array}{cc}\hfill \prod _{s=0,\ne i}^{\lambda -1}(x^{e_i}-x^{e_s})c_{e_i}\left(x\right)& \equiv \sum _{\ell =0}^{\lambda -1}{G}_{i,\lambda -1-\ell }\left(x\right)S_{\ell }\left(x\right)\hfill \\ \hfill & \equiv {\sigma }_i\left(x\right)\left(\mathrm{mod}{M}_p\left(x\right)\right).\hfill \end{array}$$

Therefore, the ${\sigma }_i\left(x\right)$ can be regarded as the coefficient of $z^{\lambda -1}$ of the polynomial $G_i\left(z\right)S\left(z\right)$. Then, the erased column $c_{e_i}\left(x\right)$ is given by $\frac{{\sigma }_i\left(x\right)}{{\prod }_{s=0,\ne i}^{\lambda -1}(x^{e_i}-x^{e_s})}$, where $0\le i\le \lambda -1$.

Note that the terms of set ${\left\{S_{\ell }\left(x\right)z^{\ell }\right\}}_{\ell =\lambda }^{r-1}$ are not involved in computing the coefficient of $z^{\lambda -1}$ of the polynomial $G_i\left(z\right)S\left(z\right)$. Thus, we can just consider the first $\lambda$ terms (the $\lambda$ coefficients of degrees less than $\lambda$) of $S\left(z\right)$ when computing these coefficients, but all the r terms of $S\left(z\right)$ are calculated in [Step 1] in [17]. This is one essential way our modified syndrome-based decoding method obtains a lower decoding complexity than the original method in [17].

Moreover, the syndrome polynomials $S_{\ell }\left(x\right)$ satisfy

$$S_0\left(1\right)=S_1\left(1\right)=\cdots =S_{\lambda -1}\left(1\right),$$

(6)

i.e., the $\lambda$ syndrome polynomials $S_{\ell }\left(x\right)$ either all have an even number of nonzero terms, or they all have an odd number of nonzero terms, from the definition of Equation (2).

Let $G\left(z\right)=(1-x^{e_i}z)G_i\left(z\right)$ and $Q\left(z\right)=G\left(z\right)S\left(z\right)$. Then, we have

$$\begin{array}{cc}\hfill Q\left(z\right)& =(1-x^{e_i}z)\prod _{s=0,\ne i}^{\lambda -1}(1-x^{e_s}z)S\left(z\right)\hfill \\ \hfill & =\prod _{s=0}^{\lambda -1}(1-x^{e_s}z)S\left(z\right)=\sum _{\ell =0}^{r+\lambda -1}{Q}_{\ell }\left(x\right)z^{\ell }.\hfill \end{array}$$

(7)

Thus, $Q\left(z\right)$ is independent of the erasure index i, and we only need to compute $Q\left(z\right)$ once in the decoding procedure. Recall that ${\sigma }_i\left(x\right)$ is the coefficient of $z^{\lambda -1}$ of the polynomial $G_i\left(z\right)S\left(z\right)$; then, the ${\sigma }_i\left(x\right)$ is also the coefficient of $z^{\lambda -1}$ of the polynomial $\frac{Q\left(z\right)}{(1-x^{e_i}z)}=\frac{(1-x^{e_i}z)G_i\left(z\right)S\left(z\right)}{(1-x^{e_i}z)}$ for all $0\le i\le \lambda -1$. Suppose that

$$\frac{Q\left(z\right)}{(1-x^{e_i}z)}=f_0^i\left(x\right)+f_1^i\left(x\right)z+\cdots +f_{\lambda -1}^i\left(x\right)z^{\lambda -1}+\cdots ,$$

we can derive the recurrence formula

$$f_{\ell }^i\left(x\right)=\left\{\begin{array}{cc}{Q}_0\left(x\right),\hfill & \ell =0;\hfill \\ x^{e_i}·f_{\ell -1}^i\left(x\right)+Q_{\ell }\left(x\right),\hfill & \ell >0;\hfill \end{array}\right.$$

(8)

where $0\le i\le \lambda -1$. Notice that ${\sigma }_i\left(x\right)=f_{\lambda -1}^i\left(x\right)$ holds. Similar to $S\left(z\right)$, we only compute the first $\lambda$ terms (the $\lambda$ coefficients of degrees less than $\lambda$) of $Q\left(z\right)$, since the other coefficients of $Q\left(z\right)$ are not needed, but all the $r+\lambda$ terms of $Q\left(z\right)$ are calculated in [Step 2] in [17]. This is another way our modified syndrome-based decoding method obtains a lower decoding complexity than the original method in [17]. Algorithm 1 shows our modified syndrome-based decoding method over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$.

The following Lemma shows that we can always compute the divisions in steps 11–12 of Algorithm 2 by Lemmas 1 and 2 when $\lambda \ge 2$.

Lemma 3.

In steps 11–12 of Algorithm 2, the ${\sigma }_i\left(x\right)$ has an even number of nonzero terms for all $0\le i\le \lambda -1$, and we can employ Lemmas 1 and 2 to compute the divisions.

Proof. 

From Equation (8) and steps 7–10 of Algorithm 2, we obtain

$${\sigma }_i\left(x\right)=x^{(\lambda -1)e_i}{Q}_0\left(x\right)+x^{(\lambda -2)e_i}{Q}_1\left(x\right)+\cdots +Q_{\lambda -1}\left(x\right),$$

where $0\le i\le \lambda -1$. If the number of polynomials in the set ${\left\{Q_j\left(x\right)\right\}}_{j=0}^{\lambda -1}$, which has an odd number of nonzero terms, is an even number, then the ${\sigma }_i\left(x\right)$ has an even number of nonzero terms for $0\le i\le \lambda -1$. In the following, we will show this is true. According to Equation (6) and step 3 of Algorithm 2, $Q_0\left(1\right)=\cdots =Q_{\lambda -1}\left(1\right)$ holds.

Firstly, we consider $Q_0\left(1\right)=\cdots =Q_{\lambda -1}\left(1\right)=1$. We denote the $\lambda$ polynomials ${\left\{Q_j\left(x\right)\right\}}_{j=0}^{\lambda -1}$ with $\epsilon =0,1,\dots ,\lambda$ as ${\{Q_j^{\epsilon }\left(x\right)\}}_{j=0}^{\lambda -1}$. Let $Q_j^0\left(x\right)$ be the initial $Q_j\left(x\right)$ for $0\le j\le \lambda -1$.

To prove that the number of polynomials with an odd number of nonzero terms in the set ${\{Q_j^{\epsilon }\left(x\right)\}}_{j=0}^{\lambda -1}$ is even, it is equivalent to prove that ${\sum }_{j=0}^{\lambda -1}{Q}_j^{\epsilon }\left(1\right)=0$.

Algorithm 2: Modified syndrome-based decoding method.

According to Equation (7) and steps 4–6 of Algorithm 2, we have

$$Q_j^{\epsilon }\left(1\right)=\left\{\begin{array}{cc}{Q}_j^{\epsilon -1}\left(1\right),\hfill & j=0;\hfill \\ Q_{j-1}^{\epsilon -1}\left(1\right)+Q_j^{\epsilon -1}\left(1\right),\hfill & 1\le j\le \lambda -1;\hfill \end{array}\right.$$

(9)

where $\epsilon =1,2,\dots ,\lambda$. The $Q_j^1\left(1\right)=0$ holds for all $j\ge 1$. We can obtain by induction

$$Q_j^{\epsilon }\left(1\right)=Q_{j-1}^{\epsilon -1}\left(1\right)+Q_j^{\epsilon -1}\left(1\right)=0\mathrm{for}\mathrm{all}j\ge \epsilon \ge 1.$$

(10)

Note that ${\sum }_{j=0}^{\lambda -1}{Q}_j^2\left(1\right)=0$; we can suppose that there are an even number of polynomials in the set ${\{Q_j^{\epsilon }\left(x\right)\}}_{j=0}^{\lambda -1}$, which has an odd number of nonzero terms, when $\epsilon =y\ge 2$, i.e., ${\sum }_{j=0}^{\lambda -1}{Q}_j^y\left(1\right)=0$ first. We have ${\sum }_{j=0}^{\lambda -1}{Q}_j^{y+1}\left(1\right)$; so,

$$\begin{array}{cc}\hfill \sum _{j=0}^{\lambda -1}{Q}_j^{y+1}\left(1\right)& =Q_0^y\left(1\right)+\sum _{j=1}^{\lambda -1}(Q_{j-1}^y\left(1\right)+Q_j^y\left(1\right))\hfill \\ \hfill & =\sum _{j=0}^{\lambda -1}{Q}_j^y\left(1\right)+\sum _{j=0}^{\lambda -2}{Q}_j^y\left(1\right)\hfill \\ \hfill & =Q_{\lambda -1}^y\left(1\right)=0.\hfill \end{array}$$

(11)

Equation (11) comes from Equation (10) with $j=\lambda -1$. Therefore, there are an even number of polynomials in the set ${\{Q_j^{y+1}\left(x\right)\}}_{j=0}^{\lambda -1}$, which has an odd number of nonzero terms.

Secondly, when $Q_0\left(1\right)=\cdots =Q_{\lambda -1}\left(1\right)=0$, the argument is similar. This completes the proof.  □

According to Lemma 3, we can use Lemmas 1 and 2 to compute the divisions in step 12. The number of divisions required in step 12 is recorded as $L_i$, which ranges from 1 to $\lambda -1$ for $i=0,1,\dots ,\lambda -1$. So, we can obtain $c_{e_i}\left(x\right)$ in step 12 by recursively computing the division $L_i$ times, while the number of nonzero terms of the polynomial resulting from the first $L_i-1$ divisions is even. Therefore, we can execute these divisions by Lemma 2 and execute the last division by Lemma 1. The computational complexity $T_D$ in steps 11–12 of Algorithm 2 is

$$T_D=\sum _{i=0}^{\lambda -1}((L_i-1)\frac{3p-5}{2}+p-3),$$

(12)

where $\lambda (p-3)\le T_D\le \lambda (\lambda -2)\frac{3p-5}{2}+\lambda (p-3)$.

In steps 11–12 of Algorithm 2, we take the $\lambda (\lambda -1)$ division without Algorithm 1, in which $\lambda$ divisions are executed by Lemma 1 and $\lambda (\lambda -2)$ divisions are executed by Lemma 2; however, the number of the divisions can be reduced with Algorithm 1. In Table 1, we show the average number of divisions in steps 11–12 of Algorithm 2 executed by Lemma 1 and Lemma 2 with Algorithm 1 for $(p,n)\in \left\{\right(5,5),(7,7\left)\right\}$.

Table 1. The average number of XORs involved in steps 11–12 of Algorithm 2.

p, n	λ	Without Algorithm 1			Apply Algorithm 1			Improvement(%)
		Lemma 2	Lemma 1	XORs	Lemma 2	Lemma 1	XORs
(5, 5)	2	0	2	4	0	2	4	0%
	3	3	3	21	2	3	16	23.81%
	4	8	4	48	0	4	8	83.33%
(7, 7)	2	0	2	8	0	2	8	0%
	3	3	3	36	2.4	3	31.2	13.33%
	4	8	4	80	4.4	4	51.2	36%
	5	15	5	140	1	5	28	80%
	6	24	6	216	6	6	72	66.67%

We specify the computational complexity of Algorithm 2 as follows:

• Steps 1–2 take $\lambda (\delta -1)p=\lambda (n-\lambda -1)p$ XORs.
• Steps 3–6 take $\lambda (\lambda -1)p$ XORs.
• Steps 7–10 take $\lambda (\lambda -1)p$ XORs.
• Steps 11–12 take $T_D$ XORs by Equation (12).

Then, the computational complexity $T_{Alg 2}$ of Algorithm 2 is

$$T_{Alg 2}=\lambda (n+\lambda -3)p+T_D,$$

(13)

where

$$p{\lambda }^2+((n-2)p-3)\lambda \le T_{Alg 2}\le \frac{5(p-1)}{2}{\lambda }^2+((n-5)p+2)\lambda .$$

Recall that the computational complexity of the decoding method in [17] is

$$\frac{7p-4}{2}{\lambda }^2-\frac{7p-2}{2}\lambda +r(n-1)p.$$

which is strictly larger than $T_{Alg 2}$.

Table 2 evaluates the computational complexity of the decoding method in [17] and Algorithm 2 for some parameters. The results in Table 2 demonstrate that Algorithm 2 has much lower decoding complexity, compared with the original decoding method in [17]. For example, Algorithm 2 has 40.60% less decoding complexity than the decoding method in [17] when $(p,n,r)=(7,7,4),\lambda =3$.

Table 2. Decoding complexity of method in [17] and Algorithm 2.

p, n, r	λ	XORs in [17]	XORs of ${\mathit{T}}_{\mathit{Alg}2}$	Improvement(%)
(5, 5, 3)	2	89	44	50.56%
	3	150	91	39.33%
(7, 7, 4)	2	211	92	56.40%
	3	300	178.2	40.60%
	4	434	275.2	36.59%

The reason why Algorithm 2 has lower decoding complexity than the decoding method in [17] can be summarized as the following three points.

Firstly, we only consider the first $\lambda$ terms (the $\lambda$ coefficients of degrees less than $\lambda$) for both $S\left(z\right)$ and $Q\left(z\right)$ in computing the coefficients of $z^{\lambda -1}$, while all r terms of $S\left(z\right)$ and all $r+\lambda$ terms of $Q\left(z\right)$ are calculated in the decoding method in [17], where $r\ge \lambda$.

Secondly, all the divisions in Algorithm 2 are executed over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ by Lemmas 1 and 2, which takes $p-3$ XORs and $\frac{3p-5}{2}$ XORs for each division, respectively. In addition, the division in [17] is executed over the ring ${\mathcal{R}}_p$, which takes $2(p-1)$ XORs [17] (Corollary 2).

Thirdly, we apply Algorithm 1 to steps 11–12 of Algorithm 2, which can significantly reduce the number of divisions, thus reducing the number of XORs required.

3.2. Modified Interpolation-Based Decoding Method

According to the decoding method in [18], we can recover the erased column $c_{e_i}\left(x\right)$ with $0\le i\le \lambda -1$ by

$$c_{e_i}\left(x\right)=\sum _{j=0}^{\delta -1}{c}_{h_j}\left(x\right)\frac{f_i\left(x^{h_j}\right)}{f_i\left(x^{e_i}\right)}\left(\mathrm{mod}{M}_p\left(x\right)\right),$$

(14)

where $f_i\left(y\right)={\prod }_{s=0,\ne i}^{\lambda -1}(y-x^{e_s})$ and $f\left(y\right)={\prod }_{s=0}^{\lambda -1}(y-x^{e_s})$. Let

$$a_j\left(x\right)=c_{h_j}\left(x\right)·f\left(x^{h_j}\right)=\prod _{s=0}^{\lambda -1}(x^{h_j}-x^{e_s})·c_{h_j}\left(x\right)\left(\mathrm{mod}{M}_p\left(x\right)\right),$$

(15)

where $0\le j\le \delta -1$. Then, $a_j\left(x\right)$ has an even number of nonzero terms, and we only need to compute once for $a_j\left(x\right)$ in the decoding procedure, since $a_j\left(x\right)$ is independent of the erasure index i. Let

$$\begin{array}{cc}\hfill b_i\left(x\right)& =\sum _{j=0}^{\delta -1}\frac{a_j\left(x\right)}{x^{h_j}-x^{e_i}}\left(\mathrm{mod}{M}_p\left(x\right)\right),\hfill \end{array}$$

(16)

$$\begin{array}{cc}\hfill c_{e_i}\left(x\right)& =\frac{b_i\left(x\right)}{f_i\left(x^{e_i}\right)}=\frac{b_i\left(x\right)}{{\prod }_{s=0,\ne i}^{\lambda -1}(x^{e_i}-x^{e_s})}\left(\mathrm{mod}{M}_p\left(x\right)\right),\hfill \end{array}$$

(17)

where $0\le i\le \lambda -1$, and $M_p\left(x\right)=1+x+\cdots +x^{p-1}$. Algorithm 3 shows our modified interpolation-based method over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$.

After using Algorithm 1, the number of polynomial multiplications in step 2 ranges from 1 to $\lambda$. Thus, the computational complexity $T_M$ in steps 1–2 of Algorithm 3 is

$$(n-\lambda )p\le T_M\le (n-\lambda )\lambda p.$$

(18)

Algorithm 3: Modified interpolation-based method.

In steps 1–2, we need to take $\lambda$ multiplications without Algorithm 1, which takes $(n-\lambda )\lambda p$ XORs; however, with Algorithm 1, the number of multiplications involved in steps 1–2 can be reduced. In Table 3, we show the average number of XORs involved in steps 1–2 of Algorithm 3 with Algorithm 1 for $(p,n)\in \left\{\right(5,5),(7,7\left)\right\}$. The results in Table 3 show that we can reduce the number of XORs with Algorithm 1, especially for a large value of $\lambda$.

Table 3. The average number of XORs involved in steps 1–2 of Algorithm 3.

p, n	λ	Without Algorithm 1		Apply Algorithm 1		Improvement(%)
		Multiplication	XORs	Multiplication	XORs
(5, 5)	2	6	30	5	25	16.67%
	3	6	30	2	10	66.67%
	4	4	20	2	10	50%
(7, 7)	2	10	70	9	63	10%
	3	12	84	8.4	58.8	30%
	4	12	84	3.6	25.2	70%
	5	10	70	4	28	60%
	6	6	42	3	21	50%

Only steps 4 and 6 of Algorithm 3 are needed to compute the division. We should employ Lemma 2 to execute the divisions in steps 3–4 in Algorithm 3, since $b_i\left(x\right)$ in step 6 of Algorithm 3 should have an even number of nonzero terms. Notice that steps 5–6 of Algorithm 3 are exactly the same as steps 11–12 of Algorithm 2.

We specify the computational complexity of Algorithm 3 as follows:

• Steps 1–2 require $T_M$ XORs by Equation (18).
• Steps 3–4 need $\lambda (\delta -1)$ additions and $\lambda \delta$ divisions by Lemma 2, which require $\lambda (n-\lambda -1)p+\lambda (n-\lambda )\frac{3p-5}{2}$ XORs in total.
• Steps 5–6 require $T_D$ XORs by Equation (12).

Then, the computational complexity of Algorithm 3 is

$$T_{Alg 3}=T_M+\lambda (n-\lambda -1)p+\lambda (n-\lambda )\frac{3p-5}{2}+T_D,$$

(19)

where

$$-\frac{5(p-1)}{2}{\lambda }^2+(\frac{5n-2}{2}p-\frac{5}{2}n-3)\lambda +np\le T_{Alg 3}\le -2p{\lambda }^2+(\frac{7n-6}{2}p-\frac{5}{2}n+2)\lambda .$$

Recall that the computational complexity of the decoding method in [18] is

$$(-2p+1){\lambda }^2+(4(n-1)p-3n+4)\lambda +n(p-1),$$

which is larger than that of our Algorithm 3.

Table 4 evaluates the computational complexity of the decoding method in [18] and Algorithm 3 for some parameters. The results in Table 4 demonstrate that our Algorithm 3 had much lower decoding complexity, compared with the original decoding method in [18]. For example, Algorithm 3 had a 34.13% lower decoding complexity than the decoding method in [18], when $(p,n,r)=(7,7,4),\lambda =3$.

Table 4. Decoding complexities of the decoding method in [18] and our Algorithm 3.

p, n, r	λ	XORs in [18]	XORs of ${\mathit{T}}_{\mathit{Alg} 3}$	Improvement(%)
(5, 5, 3)	2	122	79	35.25%
	3	146	71	51.37%
(7, 7, 4)	2	292	207	29.11%
	3	378	249	34.13%
	4	438	228.4	47.85%

The reason why Algorithm 3 has a lower decoding complexity than that of the decoding method in [18] is summarized as follows.

Firstly, all the divisions in Algorithm 3 were executed over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$ by Lemmas 1 and 2, which used $p-3$ XORs and $(3p-5)/2$ XORs for each division, respectively. The division in the decoding method in [18] was executed over the ring ${\mathcal{R}}_p$, which used $2(p-1)$ XORs.

Secondly, we applied our Algorithm 1 to steps 1–2 and steps 5–6, which significantly reduced the number of multiplications, thus reducing the number of XORs required.

4. LU Decomposition-Based Method

The LU factorization of a matrix [22] is to express the matrix as a product of a lower triangular matrix $\mathbf{L}$ and an upper triangular matrix $\mathbf{U}$. According to the LU factorization of the Vandermonde matrix [23], we can express a Vandermonde matrix as a product of several lower triangular matrices and several upper triangular matrices. Therefore, we can solve the Vandermonde linear equations by first solving the linear equations with the encoding matrices that are the upper triangular matrices and then solving the linear equations with the encoding matrices that are the lower triangular matrices.

Suppose that the $\lambda$ erased columns are $\lambda$ columns ${\left\{e_i\right\}}_{i=0}^{\lambda -1}$ and the $\delta =n-\lambda$ surviving columns are ${\left\{h_j\right\}}_{j=0}^{\delta -1}$. Algorithm 4 shows our LU decomposition-based method over the ring ${\mathbb{F}}_2\left[x\right]/(1+x^p)$.

According to [Theorem 8] in [19], Equation (1) can be factorized into

$$\left(\begin{array}{cccc}{c}_{e_0}\left(x\right)& c_{e_1}\left(x\right)& \cdots & c_{e_{\lambda -1}}\left(x\right)\end{array}\right)·({\mathbf{L}}_{\lambda }^{\left(1\right)}{\mathbf{L}}_{\lambda }^{\left(2\right)}\cdots {\mathbf{L}}_{\lambda }^{(\lambda -1)})·({\mathbf{U}}_{\lambda }^{(\lambda -1)}{\mathbf{U}}_{\lambda }^{(\lambda -2)}\cdots {\mathbf{U}}_{\lambda }^{\left(1\right)})=\mathbf{S},$$

(20)

over the ring ${\mathcal{R}}_p$, where ${\mathbf{U}}_{\lambda }^{\left(\theta \right)}$ is the upper triangle matrix

$${\mathbf{U}}_{\lambda }^{\left(\theta \right)}=\left[\begin{array}{cc}{\mathbf{I}}_{\lambda -\theta -1}& \mathbf{0}\\ ine\mathbf{0}& \begin{array}{cccccc}1& x^{e_0}& 0& \cdots & 0& 0\\ 0& 1& x^{e_1}& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & 1& x^{e_{\theta -1}}\\ 0& 0& 0& \cdots & 0& 1\end{array}\end{array}\right],$$

(21)

and ${\mathbf{L}}_{\lambda }^{\left(\theta \right)}$ is the lower triangle matrix

$${\mathbf{L}}_{\lambda }^{\left(\theta \right)}=\left[\begin{array}{cc}{\mathbf{I}}_{\lambda -\theta -1}& \mathbf{0}\\ ine\mathbf{0}& \begin{array}{ccccc}1& 0& \cdots & 0& 0\\ 1& x^{e_{\lambda -\theta }}+x^{e_{\lambda -\theta -1}}& \cdots & 0& 0\\ ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& \cdots & x^{e_{\lambda -2}}+x^{e_{\lambda -\theta -1}}& 0\\ 0& 0& \cdots & 1& x^{e_{\lambda -1}}+x^{e_{\lambda -\theta -1}}\end{array}\end{array}\right],$$

(22)

for $\theta =1,2,\dots ,\lambda -1$.   

Algorithm 4: LU decomposition-based method.

We specify the computational complexity of Algorithm 4 as follows:

• Steps 1–2 require $\lambda (\delta -1)p=\lambda (n-\lambda -1)p$ XORs.
• Steps 3–11 require $\lambda (\lambda -1)p+(\lambda -1)(p-3)+(\lambda -1)(\lambda -2)(3p-5)/4$ XORs at most, according to [Theorem 10] in [19].

Then, the computational complexity of Algorithm 4 is

$$T_{Alg 4}=\frac{3p-5}{4}{\lambda }^2+\frac{(4n-13)p+3}{4}\lambda +\frac{p+1}{2}.$$

(23)

5. Comparison and Conclusions

Table 5 evaluates the decoding complexity of Algorithm 2–4 for some parameters. The results of Table 5 demonstrate that Algorithm 2 performs better than Algorithm 3 if $\lambda \le \frac{n}{2}$; otherwise, if $\lambda >\frac{n}{2}$, then Algorithm 3 has less decoding complexity. Algorithm 4 has less decoding complexity than both Algorithms 2 and 3, when $\lambda$ is small. However, when $\lambda$ is large, Algorithm 3 is more efficient than Algorithm 4. For example, compared with Algorithm 2–4 have $21.98\%$ and $40.66\%$ less decoding complexity, respectively, when $(p,n,r)=(5,5,4),\lambda =3$.

Table 5. Decoding complexities of the proposed three decoding methods.

p, n, r	λ	Total XORs			$\frac{{\mathit{T}}_{\mathit{Alg} 2}-{\mathit{T}}_{\mathit{Alg} 3}}{{\mathit{T}}_{\mathit{Alg} 2}}$	$\frac{{\mathit{T}}_{\mathit{Alg} 2}-{\mathit{T}}_{\mathit{Alg} 4}}{{\mathit{T}}_{\mathit{Alg} 2}}$
		${\mathit{T}}_{\mathit{Alg} 2}$	${\mathit{T}}_{\mathit{Alg} 3}$	${\mathit{T}}_{\mathit{Alg} 4}$
(5, 5, 4)	2	44	79	32	−79.55%	27.27%
	3	91	71	54	21.98%	40.66%
	4	128	38	81	70.31%	36.72%
(7, 7, 6)	2	92	207	74	−125%	19.57%
	3	178.2	249	121	−39.73%	32.10%
	4	275.2	228.4	176	17.01%	36.05%
	5	343	171	239	50.15%	30.32%
	6	492	141	310	71.34%	36.99%

In this paper, we presented three efficient decoding methods for the erasures of Blaum–Roth codes that all have lower decoding complexity than the existing decoding methods. The efficient implementation of the proposed decoding methods in practical storage systems is one of our future works.