A Decoding Algorithm for Convolutional Codes

Abstract

It is shown how the decoding algorithms of Pellikaan and Rosenthal can be coupled to produce a decoding algorithm for convolutional codes. Bounds for the computational cost per decoded codeword are also computed. As a case study, our results are applied to a family of convolutional codes constructed by Rosenthal–Schumacher–York and, in this situation, the previous bounds turn out to be polynomial on the degree of the code.

1. Introduction

Many aspects of daily life require the transmission of large amounts of digital data in a timely and reliable manner. Among the different methods to detect and correct errors occurring during the transmission, convolutional codes are a standard tool for dealing with this issue. While the encoding algorithms present no difficulty at all, decoding algorithms are more involved and have been studied for decades. Depending on the signal, they can be classified into hard and soft decoding algorithms (e.g., [1], Ch. 14, 15). When it comes to decoding, maximum likelihood algorithms (e.g., such as Viterbi) often require a large amount of memory and their complexity depends exponentially on the degree [2,3]. Sequential decoding algorithms use a metric and a threshold in order to maintain memory and complexity under certain limits. Other decoding methods include list decoding and iterative decoding (see [4], Ch. 4–7).

An extremely active area of research is the pursuit of decoding algorithms of convolutional codes that balance the use of memory and computational complexity. For decades, the Viterbi algorithm, along with its variants and improvements, has been regarded as one of the most widely used maximum likelihood decoding algorithms.

A main goal of this paper is to offer a hard decoding algorithm (see Section 3.2), which is a combination of an algorithm proposed by Rosenthal [5] with another one given by Pellikaan [6] in terms of error-correcting pairs. The resulting algorithm is of the same type as Rosenthal’s; namely, it is an iterative algebraic decoding algorithm. A second main result consists of lower and upper bounds for the number of arithmetical operations required to decode a codeword (see Section 3.4), which we call the computational cost per codeword. Note that the complexity is directly proportional to the computational cost per codeword. It is worth noting that, unlike the Viterbi algorithm, the bounds for our algorithm depend polynomially on the code parameters.

A case study is presented in Section 4. Indeed, we apply our results to the family of convolutional codes considered in ([7], § IV; [8], § 6.3). We analyze how the parameters should be chosen in order for the assumptions to hold true. Finally, we are able to write simple expressions for the bounds of the computational cost per codeword.

The authors would like to thank the referees for their comments and suggestions that have helped to improve the paper.

2. Preliminaries and Notations

In this section, we introduce some notations and recall basic notions about linear and convolutional codes that will be useful in the following sections. A detailed exposition on the algebraic theory of error-correcting codes can be found in many references (for instance, see [1]).

2.1. Linear Codes and Error-Correcting Pairs

Let ${\mathbb{F}}_q$ be the finite field of q elements and let G be a ${\mathbb{F}}_q$-linear monomorphism:

$$G:{\mathbb{F}}_q^k\hookrightarrow {\mathbb{F}}_q^n.$$

(1)

We say that $\mathcal{C}=\mathrm{Im}G$ is an $(n,k)$-linear code over ${\mathbb{F}}_q$ and G is an encoder associated with $\mathcal{C}$. Thus, the encoding process is given by:

$$u⟼v=uG,$$

where u is called information word and v is called codeword.

Given a code, there is relevant numerical data associated with it. First, since $u\in {\mathbb{F}}_q^k$ consists of k symbols, $k\left(\mathcal{C}\right):=k$ will be called the dimension of the linear code $\mathcal{C}$. Similarly, $v\in {\mathbb{F}}_q^n$ consists of n symbols and, thus, $n\left(\mathcal{C}\right):=n$ will be called the length of $\mathcal{C}$. The minimum distance of $\mathcal{C}$ is the minimum among the weights of its non-zero codewords, and it will be denoted by $d_{\min }\left(\mathcal{C}\right)$ or, if no confusion arises, simply by d.

Moreover, there are also some maps and subspaces attached to $\mathcal{C}$. The dual code of the code $\mathcal{C}$, denoted by ${\mathcal{C}}^{\perp }\subseteq {\mathbb{F}}_q^n$, is given by:

$${\mathcal{C}}^{\perp }=\{v\in {\mathbb{F}}_q^n|\langle v,c\rangle =0\forall c\in \mathcal{C}\},$$

where the bilinear form $\langle ,\rangle :{\mathbb{F}}_q^n\times {\mathbb{F}}_q^n\to {\mathbb{F}}_q$ is defined as follows:

$$\langle a,b\rangle =a·b^{†}=\sum _{i=1}^n{a}_i{b}_i.$$

Throughout the paper, the transpose of a matrix M will be denoted by $M^{†}$ since we want to preserve t and T for other tasks.

The dual code ${\mathcal{C}}^{\perp }$ is an $(n,n-k)$-linear code and any generator matrix H of ${\mathcal{C}}^{\perp }$ is called the parity check matrix of the code $\mathcal{C}$; that is, ${\mathcal{C}}^{\perp }=\mathrm{Im}H$ for a given $H:{\mathbb{F}}_q^{n-k}\hookrightarrow {\mathbb{F}}_q^n$ of maximal rank with $G·H^{†}=0$.

The syndrome map of a fixed linear code $\mathcal{C}$, denoted by $\sigma$, is given by:

$$\begin{array}{cc}\hfill \sigma :{\mathbb{F}}_q^n⟶& {Hom}_{{\mathbb{F}}_q}({\mathcal{C}}^{\perp },{\mathbb{F}}_q)\hfill \\ \hfill a⟼& \sigma \left(a\right)\mathrm{where}\sigma \left(a\right)\left(b\right):=\langle a,b\rangle \hfill \end{array}$$

(2)

so that $a\in \mathcal{C}$ if and only if $\sigma \left(a\right)=0$.

Next, we recall the notions of the generalized Reed–Solomon code as well as of error-correcting pair, which turns out to be relevant when decoding linear codes (see [1], § 5.3; [6,9]).

First, we define the star multiplication of $a,b\in {\mathbb{F}}_q^n$, denoted by $a\ast b$, by coordinatewise multiplication $a\ast b:=(a_1{b}_1,\dots ,a_n{b}_n)\in {\mathbb{F}}_q^n$. For any two subspaces, $\mathcal{A}$ and $\mathcal{B}$, we introduce the set $\mathcal{A}\ast \mathcal{B}:=\{a\ast b|a\in \mathcal{A},b\in \mathcal{B}\}$.

Given positive integers $k\le n$, $\mathbf{a},$ an ntuple of pairwise distinct elements of ${\mathbb{F}}_q$ and $\mathbf{b},$ an ntuple of nonzero elements of ${\mathbb{F}}_q$, the associated generalized Reed–Solomon code of dimension k is the following subspace of ${\mathbb{F}}_q^n$:

$$\begin{array}{cc}\hfill {GRS}_k(\mathbf{a},\mathbf{b}):=& \langle \{\mathbf{b}\ast f\left(\mathbf{a}\right)\mathrm{where}f\left(z\right)=1,z,z^2,\dots ,z^{k-1}\}\rangle \hfill \\ \hfill =& \langle \{(b_1{a}_1^i,\dots ,b_n{a}_n^i)\mathrm{where}i=0,1,\dots ,k-1\}\rangle .\hfill \end{array}$$

For the sake of brevity, we say that $\mathcal{C}$ is GRS, if $\mathbf{a}$ and $\mathbf{b}$ exist as above, such that $\mathcal{C}={GRS}_k(\mathbf{a},\mathbf{b})$.

In this situation, it is proved in [1] (Thm. 5.3.3.) that ${GRS}_k{(\mathbf{a},\mathbf{b})}^{\perp }={GRS}_{n-k}(\mathbf{a},\mathbf{c})$, where $\mathbf{c}$ is any nonzero codeword in the 1-dimensional code ${GRS}_{n-1}{(\mathbf{a},\mathbf{b})}^{\perp }$. In particular, a code is generalized Reed–Solomon if and only if its dual is generalized Reed–Solomon.

Let $\mathcal{C}$ be a ${\mathbb{F}}_q$-linear code of length n. Following [6] (§ 2), a pair $(\mathcal{A},\mathcal{B})$ of ${\mathbb{F}}_{q^m}$-linear codes of length n is called an e-error-correcting pair for the $(n,k)$-linear code $\mathcal{C}$ if it verifies the following conditions:

1.

$\mathcal{A}\ast \mathcal{B}\subseteq {\mathcal{C}}^{\perp }$.

2.

$k\left(\mathcal{A}\right)>e$.

3.

$d\left(\mathcal{A}\right)+d\left(\mathcal{C}\right)>n$.

4.

$d\left({\mathcal{B}}^{\perp }\right)>e$.

We say that $\mathcal{C}$ has an error-correcting pair if there is an e-error-correcting pair over a finite extension of ${\mathbb{F}}_q$ for $e=⌊\frac{d\left(\mathcal{C}\right)-1}{2}⌋$. In the case of generalized Reed–Solomon codes, an explicit description of such a pair is known (see [9], Ex. 4.2.). Indeed, if $\mathcal{C}={GRS}_k(\mathbf{a},\mathbf{b})$ and ${\mathcal{C}}^{\perp }={GRS}_{n-k}(\mathbf{a},\mathbf{c})$, then:

$$\mathcal{A}:={GRS}_{e+1}(\mathbf{a},\mathbf{c})\mathcal{B}:={GRS}_e(\mathbf{a},\mathbf{1}),$$

(3)

where $\mathbf{1}:=(1,\dots ,1)\in {\mathbb{F}}_q^n$, form an e-error-correcting pair for $\mathcal{C}$ with $e=⌊\frac{n-k}{2}⌋$. Observe that the pair $(\mathcal{A},\mathcal{B})$ of (3) is defined on base field ${\mathbb{F}}_q$.

In addition, for a received word $r\in {\mathbb{F}}_q^n$, the error locating map of r with respect to the $(n,k)$-linear code $\mathcal{C}$, denoted by $E_r$, is defined by:

$$\begin{array}{cc}\hfill E_r:\mathcal{A}⟶& {Hom}_{{\mathbb{F}}_q}(\mathcal{B},{\mathbb{F}}_q)\hfill \\ \hfill a⟼& E_r\left(a\right)\mathrm{where}{E}_r\left(a\right)\left(b\right):=\langle r,a\ast b\rangle .\hfill \end{array}$$

We finish this section by introducing some notations used in the explanation of the algorithm. We denote by ${\left(a\right)}_0:=\left\{i\right|a_i=0\}$, the zero set of an element $a\in {\mathbb{F}}_q^n$. For $I=\{i_1,\dots ,i_e\}$ a set of indices with $1\le i_1<\dots <i_e\le n$, we denote:

$${\iota }_I:{\mathbb{F}}_q^e\hookrightarrow {\mathbb{F}}_q^n$$

the inclusion map that sends $a=(a_1,\dots ,a_e)\in {\mathbb{F}}_q^e$ to the vector whose $i_j$ th entry is $a_j$ for $j=1,\dots ,e$ and zeros everywhere else. Then, we have that the restricted syndrome map of a linear code $\mathcal{C}$ is:

$${\sigma }_I:{\mathbb{F}}_q^e⟶{Hom}_{{\mathbb{F}}_q}({\mathcal{C}}^{\perp },{\mathbb{F}}_q)$$

given by the composition ${\sigma }_I=\sigma \circ {\iota }_I$ (see (2)).

2.2. Convolutional Codes and ISO Representations

In order to enhance the correcting capabilities of a code against burst errors, one may consider codes where the transmitted block depends on those sent previously. Among these codes, in this paper we focus on convolutional codes. In the next paragraphs, we recap some facts on convolutional codes (e.g., [5], § 2; [1], Ch. 14; and [10,11]). In this case, the entries of the encoder matrix are polynomials, and an $(n,k)$-convolutional code $\mathcal{C}$ is the subspace generated by the image of the linear monomorphism:

$$\begin{array}{cc}\hfill G\left(z\right):{\mathbb{F}}_q{\left[z\right]}^k\hookrightarrow & {\mathbb{F}}_q{\left[z\right]}^n\hfill \\ \hfill u\left(z\right)\mapsto & v\left(z\right)=u\left(z\right)G\left(z\right);\hfill \end{array}$$

that is, $\mathcal{C}=\mathrm{Im}G\left(z\right)$. The words are considered as polynomials and the independent variable represents the delay operator. In this setup, n is called the length and k the dimension of $\mathcal{C}$. The degree, which is denoted by $\delta$, is the highest (polynomial) degree of the $k\times k$ minors of $G\left(z\right)$ or, equivalently, of any encoder matrix. Finally, the free distance, $d_{\mathrm{free}}$ is the minimum among the weights of its non-zero codewords and it is an analogous to the minimum distance of linear codes. The free distance is a code property and indicates the error-correcting capability of a code, since a convolutional code can correct all errors of weight at most e if and only if $d_{\mathrm{free}}>2e$ (see [4], Theorem 3.3).

Occasionally, alternative representations of these codes allows us to operate with them more easily. In this paper, motivated by the origin of these codes, we consider the minimal Input/State/Output representation (see [5,12]), or mISO for short, of an $(n,k)$-convolutional code $\mathcal{C}$, which is defined by the linear system:

$$\left\{\begin{array}{c}{x}_{t+1}=A{x}_t+B{u}_t\hfill \\ y_t=C{x}_t+D{u}_t\hfill \\ v_t=\left(\begin{array}{c}{y}_t\\ u_t\end{array}\right),x_0=0,\hfill \end{array}\right.$$

(4)

where $x_t$, $y_t$, $u_t$ and $v_t$ are column vectors, $A\in {\mathbb{F}}_q^{\delta \times \delta }$, $B\in {\mathbb{F}}_q^{\delta \times k}$, $C\in {\mathbb{F}}_q^{(n-k)\times \delta }$, $D\in {\mathbb{F}}_q^{(n-k)\times k}$ and t denote the time unit. In this characterization, the sequence of vectors $u_t$ represents the information vectors, the sequence of $y_t$ represents the parity vectors and the sequence of $v_t$ represents the code vectors. We can also observe that the system (4) provides us a state space realization of a systematic encoder; that is, the code vectors are built as the concatenation of the parity vectors and the information vectors.

The relationships between properties of a convolutional code and those of the associated mISO representation can be found in ([13], § 2;  [8,12]). In particular, we are only interested in mISO representations that are reachable and observable as linear systems. In terms of the corresponding convolutional code, this means that it is non-catastrophic or, equivalently, that it admits a polynomial parity check matrix.

The following proposition, proved in ([8], Prop. 6.1.1), provides a characterization of codewords.

Proposition 1 (Local Description of Trajectories).

Let $\mathcal{C}$ be an $(n,k)$-convolutional code and consider its mISO representation. Let τ, $\gamma \in {\mathbb{Z}}_{+}$ be positive integers such that $\tau <\gamma$. Assume that the encoder is at state $x_{\tau }$ at time unit $t=\tau$. Then, any sequence ${\left\{\left(\begin{array}{c}{y}_t\\ u_t\end{array}\right)\right\}}_{t\ge 0}$ must satisfy:

$$\begin{array}{cc}\hfill \left(\begin{array}{c}{y}_{\tau }\\ y_{\tau +1}\\ ⋮\\ ⋮\\ y_{\gamma }\end{array}\right)=& \left(\begin{array}{c}C\\ CA\\ ⋮\\ ⋮\\ C{A}^{\gamma -\tau }\end{array}\right)x_{\tau }+\left(\begin{array}{ccccc}D& 0& \dots & \dots & 0\\ CB& D& \dots & \dots & ⋮\\ CAB& CB& \dots & \dots & ⋮\\ ⋮& ⋮& & 0\\ C{A}^{\gamma -\tau -1}B& C{A}^{\gamma -\tau -2}B& \dots & CB& D\end{array}\right)\left(\begin{array}{c}{u}_{\tau }\\ u_{\tau +1}\\ ⋮\\ ⋮\\ u_{\gamma }\end{array}\right).\hfill \end{array}$$

(5)

Moreover, the evolution of the state vector $x_t$ is given over time as:

$$x_t=A^{t-\tau }{x}_{\tau }+\left(\begin{array}{ccc}{A}^{t-\tau -1}B& \dots & B\end{array}\right)\left(\begin{array}{c}{u}_{\tau }\\ ⋮\\ u_{t-1}\end{array}\right);t=\tau +1,\tau +2,\dots ,\gamma +1.$$

(6)

3. The Combined Algorithm

In this section, we will deal with the main goal of the article: to offer a new algorithm resulting from the combination of the one proposed by Rosenthal in ([5], § 4) with the one proposed by Pellikaan in ([6], Algorithm 2.13). Indeed, our proposal consists of two parts. In the first one, Rosenthal’s algorithm is used to reduce the decoding of the convolutional code to the decoding of certain linear codes. Then, the second one applies Pellikaan’s decoding procedure based on error-correcting pairs to each of these codes. We refer the reader to those references for a detailed description and justification of the algorithms, while in this section, we focus on how the two are combined.

3.1. Preparation and Assumptions

For our algorithm to work correctly over an $(n,k)$-convolutional code $\mathcal{C}$, the matrices A, B, C and D corresponding to the mISO representation of $\mathcal{C}$ are assumed to satisfy some properties so that the hypothesis considered by both Pellikaan and Rosenthal are fulfilled.

Let,

$${\left\{\right(\begin{array}{c}{y}_t\\ u_t\end{array}\left)\right\}}_{t=0}^{\tau +T}{\left\{\right(\begin{array}{c}{\hat{y}}_t\\ {\hat{u}}_t\end{array}\left)\right\}}_{t=0}^{\tau +T}$$

denote the transmitted and received sequences respectively where, from now on, $\widehat{}$ will denote received words. Note that we only know $\left\{\right(\begin{array}{c}{\hat{y}}_t\\ {\hat{u}}_t\end{array}\left)\right\}$ and our task is to determine $\left\{\right(\begin{array}{c}{y}_t\\ u_t\end{array}\left)\right\}$.

We suppose that the following assumptions are verified.

Assumption 1.

T, $\Theta \in {\mathbb{Z}}_{+}$ are positive integers with $T>\Theta$.

Assumption 2.

A is invertible and the matrix:

$$\Psi (A,B)=\left(\begin{array}{cccc}B& AB& \dots & A^{T-1}B\end{array}\right)$$

has full row rank δ and its rows form the parity check matrix of an $(n^{\prime },k^{\prime })$-linear code ${\mathcal{C}}^{\prime }$, where $n^{\prime }=kT$ and $k^{\prime }=\delta$. Let $d^{\prime }$ be its minimum distance.

Assumption 3.

$G^{\prime }$ is an encoder for ${\mathcal{C}}^{\prime }$. Moreover, the code ${\mathcal{C}}^{\prime }$ is supposed to admit an error-correcting pair, say $({\mathcal{A}}^{\prime },{\mathcal{B}}^{\prime })$.

Assumption 4.

The matrix:

$$\Phi (A,C)=\left(\begin{array}{c}C\\ CA\\ ⋮\\ C{A}^{\Theta -1}\end{array}\right)$$

has full column rank δ and its columns define the generator matrix of an $(n^{″},k^{″})$-linear code ${\mathcal{C}}^{″}$, where $n^{″}=(n-k)\Theta$ and $k^{″}=\delta$. Let $d^{″}$ be its minimum distance.

Assumption 5.

$G^{″}$ is an encoder for ${\mathcal{C}}^{″}$ and $R^{″}$ is a retraction of $G^{″}$; that is, a map $R^{″}:{\mathbb{F}}_q^{n^{″}}\to {\mathbb{F}}_q^{k^{″}}$ such that, $G^{″}{R}^{″}={Id}_{{\mathbb{F}}_q^{k^{″}}}$. Moreover, the code ${\mathcal{C}}^{″}$ is supposed to admit an error-correcting pair, say $({\mathcal{A}}^{″},{\mathcal{B}}^{″})$.

Assumption 6.

From time unit $t=0$ to time unit $t=\tau -1$, the transmission is error free or, equivalently, has been correctly decoded; that is, ${\widehat{y}}_t=y_t$ and ${\widehat{u}}_t=u_t$ for $0\le t<\tau$.

Assumption 7.

In any time interval of length T, the error produced during the transmission has weight, at most:

$$\lambda :=min\left(⌊\frac{d^{\prime }-1}{2}⌋,⌊\frac{T}{2\Theta }⌋\right)$$

(7)

Let us briefly discuss why these assumptions are reasonable.

The Assumptions 2 and 4 imply that $(A,B)$ forms a controllable pair and $(A,C)$ forms an observable pair and, from ([8], § 5.3) one concludes that (4) forms a minimal state space representation of a non-catastrophic encoder (also see [12], Thm. 5).

Similarly, Assumption 3 (resp. Assumption 5) allows us to apply Pellikaan’s decoding procedure to the linear code ${\mathcal{C}}^{\prime }$ (resp. ${\mathcal{C}}^{″}$).

Since our algorithm is iterative and, as a result from the previous iteration, the Assumption 6 is taken for granted. Note that at the time unit t, the error produced during the transmission is given by $\left(\begin{array}{c}{\widehat{y}}_t-y_t\\ {\widehat{u}}_t-u_t\end{array}\right)$. Finally, observe that the state $x_{\tau }$ can be computed correctly from (4).

3.2. The Algorithm

The Algorithm 1 goes as follows:

Algorithm 1: Decoding.

1: Set $h=0$. 2: If $\tau +T-h\Theta +1<\tau +\Theta$ or $rk\left(\begin{array}{cccc}B& AB& \dots & A^{T-(h+1)\Theta -1}B\end{array}\right)<\delta$, then STOP (decoding unsuccessful). 3: Increase h by 1. 4: 4.1   Compute, $${\widehat{r}}^{″}:=\left(\begin{array}{c}{\widehat{y}}_{\tau +T-h\Theta +1}\\ ⋮\\ {\widehat{y}}_{\tau +T-(h-1)\Theta }\end{array}\right)-\left(\begin{array}{cccc}D& 0& \dots & 0\\ ⋮& & & ⋮\\ C{A}^{\Theta -2}B& C{A}^{\Theta -3}B& \dots & D\end{array}\right)\left(\begin{array}{c}{\widehat{u}}_{\tau +T-h\Theta +1}\\ ⋮\\ {\widehat{u}}_{\tau +T-(h-1)\Theta }\end{array}\right)$$ from received vectors $\left\{\right(\begin{array}{c}{\hat{y}}_t\\ {\hat{u}}_t\end{array}\left)\right\}$. Note that ${\widehat{r}}^{″}$ is a column vector with $n^{″}=(n-k)\Theta$ rows. 4.2   If the morphism $E_{{\widehat{r}}^{″}}:{\mathcal{A}}^{″}\to {\mathrm{Hom}}_{{\mathbb{F}}_q}({\mathcal{B}}^{″},{\mathbb{F}}_q)$ is injective, then go to 2. 4.3   Choose a nonzero element $a\in \mathrm{Ker}{E}_{{\widehat{r}}^{″}}$ and let $J:={\left(a\right)}_0$. 4.4   Compute the syndrome ${\sigma }^{″}\left({\widehat{r}}^{″}\right)$, where ${\sigma }^{″}$ is the syndrome map of ${\mathcal{C}}^{″}$. 4.5   If ${\sigma }_J^{″}\left(x\right)={\sigma }^{″}\left({\widehat{r}}^{″}\right)$ has no or more than one solution, then go to 2. 4.6   Let $r_0^{″}$ be the unique column vector such that ${\sigma }_J^{″}\left(r_0^{″}\right)={\sigma }^{″}\left({\widehat{r}}^{″}\right)$ and let $\omega \left(r_0^{″}\right)$ be its weight. 4.7   If $\omega \left(r_0^{″}\right)>⌊\frac{d^{″}-1}{2}⌋$, then go to 2. 4.8  Compute the state $x_{\tau +T-h\Theta +1}$ with the help of the retraction $R^{″}$ of $G^{″}$ $$x_{\tau +T-h\Theta +1}={\left(R^{″}\right)}^{†}({\widehat{r}}^{″}-{\iota }_J^{″}\left(r_0^{″}\right))$$ and note that it is a column vector with $k^{″}=\delta$ rows. 5:   5.1  Since $\left(\begin{array}{ccc}{A}^{T-h\Theta }B& \dots & B\end{array}\right)$ has full row rank $\delta$, its rows form the parity check matrix of an $(n_h^{\prime },k_h^{\prime })$-linear code ${\mathcal{C}}_h^{\prime }$, where $n_h^{\prime }=k(T-h\Theta )$ and $k_h^{\prime }=\delta$. Let $d_h^{\prime }$ its minimal distance and let $({\mathcal{A}}_h^{\prime },{\mathcal{B}}_h^{\prime })$ be an error-correcting pair for ${\mathcal{C}}_h^{\prime }$. 5.2   Set: $$\widehat{u}:=\left(\begin{array}{c}{\widehat{u}}_{\tau }\\ ⋮\\ {\widehat{u}}_{\tau +T-h\Theta }\end{array}\right)$$   and compute: $$s:=\left(\begin{array}{ccc}{A}^{T-h\Theta }B& \dots & B\end{array}\right)\widehat{u}-x_{\tau +T-h\Theta +1}-A^{T-h\Theta +1}{x}_{\tau }.$$   5.3   If the morphism $E_{h,\widehat{u}}:{\mathcal{A}}_h^{\prime }\to {\mathrm{Hom}}_{{\mathbb{F}}_q}({\mathcal{B}}_h^{\prime },{\mathbb{F}}_q)$ is injective, then go to 2. 5.4   Choose a nonzero element $a\in \mathrm{Ker}{E}_{h,\widehat{u}}$ and let $J:={\left(a\right)}_0$. 5.5   If ${\sigma }_{h,J}^{\prime }\left(x\right)=s$ has no or more than one solution, then go to 2. 5.6   Let $s_0$ be the unique column vector such that ${\sigma }_{h,J}^{\prime }\left(s_0\right)=s$ and let $\omega \left(s_0\right)$ be its weight. 5.7   If $\omega \left(s_0\right)>⌊\frac{d_h^{\prime }-1}{2}⌋$, then go to 2. 5.8   Decode by: $$\left(\begin{array}{c}{u}_{\tau }\\ ⋮\\ u_{\tau +T-h\Theta }\end{array}\right)=\left(\begin{array}{c}{\widehat{u}}_{\tau }\\ ⋮\\ {\widehat{u}}_{\tau +T-h\Theta }\end{array}\right)-{\iota }_{h,J}\left(s_0\right).$$   6: Compute the remaining states; i.e., $x_t$ from time unit $t=\tau +1$ to time unit $t=\tau +T-h\Theta$ using the equation $x_{t+1}=A{x}_t+B{u}_t$. 7: Compute the remaining parity vectors; i.e., $y_t$ from time unit $t=\tau$ to time unit $t=\tau +T-h\Theta$, using the equation $y_t=C{x}_t+D{u}_t$. 8: If the resulting error sequence has weight: $$\sum _{t=\tau }^{\tau +T-h\Theta }\left(\omega ({\widehat{y}}_t-y_t)+\omega ({\widehat{u}}_t-u_t)\right)>\lambda -h+1$$ then go to 2. 9: The time window $t=\tau ,\dots ,\tau +\Theta -1$ has been correctly decoded. 10: If the end of the received sequence is not reached, then replace $\tau$ by $\tau +\Theta$ and return to 1. 11: END (decoding successful).

3.3. Justification

Let us provide some explanation for each step of the algorithm.

First, Step 2 warrantes that we increase h and that the code ${\mathcal{C}}_h^{\prime }$ of 5.1 is well defined and can be decoded by Pellikaan’s algorithm.

The computation of ${\widehat{r}}^{″}$ of step 4 is correct thanks to the identity (5) (also see [5], Equations (4.3) and (4.4)) and, thus, concerns the code ${\mathcal{C}}^{″}$ (see Assumption 4). The other computations of step 4 are the implementation of Pellikaan’s algorithm for the code ${\mathcal{C}}^{″}$ in terms of the error-correcting pair $({\mathcal{A}}^{″},{\mathcal{B}}^{″})$.

Step 5 is related to identity (6) (also see [5], Equation (4.5)) and, thus, to the code ${\mathcal{C}}_h^{\prime }$ (see Assumption 2 and [5], Equation (4.6)). The following parts of step 5 are the implementation of Pellikaan’s algorithm for the code ${\mathcal{C}}_h^{\prime }$ in terms of the error-correcting pair $({\mathcal{A}}_h^{\prime },{\mathcal{B}}_h^{\prime })$.

Steps 6 and 7 are deduced from (4). Finally, step 8 is the translation of the last paragraph of page 11 of [5] while step 9 corresponds to the first one of page 12 of [5].

The next step deals with the successful decoding and proceeding to the next iteration that slides the time window forward. By contrast, the last step considers the case of an unsuccessful decoding that slides the time window backward.

It should be pointed out that the algorithm will produce a correct answer as long as Assumption 7 holds.

3.4. Complexity

Now, let us give some bounds for the complexity of our algorithm.

Recall from ([6], Thm. 2.14) that, since the error-correcting pair is defined over the base field ${\mathbb{F}}_q$, the algorithm proposed by Pellikaan has complexity $\mathcal{O}\left(n^3\right)$, where n is the length of the linear code we are decoding. Hence, the complexity of step 4 is $\mathcal{O}\left({\left(n^{″}\right)}^3\right)=\mathcal{O}\left({((n-k)\Theta )}^3\right)$ and that of step 5 is $\mathcal{O}\left({\left(n_h^{\prime }\right)}^3\right)=\mathcal{O}\left({\left(k(T-h\Theta )\right)}^3\right)$. By computing the sizes of the matrices and applying well-known algorithms (e.g., [14,15]), each matrix computation in the remaining steps has a complexity equal to or less than the complexity of Pellikaan’s algorithm. Thus, the hth iteration of the algorithm has complexity:

$$\mathcal{O}\left(max\{{((n-k)\Theta )}^3,{\left(k(T-h\Theta )\right)}^3\}\right).$$

In the best case, where the first iteration is able to decode $\Theta$ codewords, the computational cost by codeword is:

$$\mathcal{O}\left(\frac{1}{\Theta }max\{{((n-k)\Theta )}^3,{\left(k(T-\Theta )\right)}^3\}\right).$$

(8)

In a worst case scenario and keeping Step 2 in mind, $\lfloor \frac{T}{\Theta }\rfloor$ iterations are required to decode $\Theta$ codewords since it may occur that $T-\lfloor \frac{T}{\Theta }\rfloor \Theta =1$. Then, the computational cost by codeword is bound from above by:

$$\mathcal{O}\left(\frac{T}{\Theta }\frac{1}{\Theta }max\{{((n-k)\Theta )}^3,{\left(k(T-\Theta )\right)}^3\}\right).$$

(9)

3.5. Performance

Let us briefly discuss the error correction capability of our approach. Let us point out that, since we are dealing with non-catastrophic encoders (see Section 3.1), a finite number of channel corruptions can not lead to an infinite sequence of errors after decoding. Furthermore, following ([5], Thm. 3.4), the correct decoding is possible if no more than $\lambda$ errors occur in any time window of length T (see Assumption 7).

The study of performance in terms of BER (bit error rate) and SNR (signal to noise ratio) is a must before implementing any transmission scheme. In fact, such study requires fixing the convolutional code, the channel and the algorithm. Thus, in order to simulate the performance of our algorithm, we have to choose a fixed convolutional as well as a transmission channel (e.g., binary erasure channel (BEC), binary symmetric channel (BSC) and additive white Gaussian noise (AWGN), among others). Future research must be conducted towards this study following the ideas of [16,17].

4. A Case Study

Next, as an illustration, we show that the combined algorithm detailed in Section 3 can be used to decode received messages that have been previously encoded by the convolutional code studied in ([7], § IV; [8], § 6.3). To do this, it must be checked if the code verifies the required hypotheses.

4.1. The Convolutional Code

Thus, let $\alpha$ be a primitive element of ${\mathbb{F}}_q$ and let n, k be positive integers such that $k\ge \frac{n}{2}$. Let $\mathcal{C}$ be the $(n,k)$-convolutional code $\mathcal{C}$ of degree $\delta$ corresponding to the following mISO representation:

$$\left\{\begin{array}{cc}A=\left(a_{ij}\right)\in {\mathbb{F}}_q^{\delta \times \delta }\hfill & \mathrm{where}{a}_{ij}={\alpha }^{ik}\mathrm{for}i=j\mathrm{and}0\mathrm{otherwise},\hfill \\ B=\left(b_{ij}\right)\in {\mathbb{F}}_q^{\delta \times k}\hfill & \mathrm{where}{b}_{ij}={\alpha }^{i(j-1)},\hfill \\ C=\left(c_{ij}\right)\in {\mathbb{F}}_q^{(n-k)\times \delta }\hfill & \mathrm{where}{c}_{ij}={\alpha }^{(i-1)j},\hfill \\ D=\left(d_{ij}\right)\in {\mathbb{F}}_q^{(n-k)\times k}\hfill & \mathrm{where}{d}_{ij}={\alpha }^{(i-1)j}.\hfill \end{array}\right.$$

(10)

There are, indeed, some constraints that $q,\delta ,k,n$ must satisfy in order to fulfill the Assumptions of Section 3.1. We will postpone this issue until Section 4.4.

4.2. The Linear Codes ${\mathcal{C}}_h^{\prime }$

Initially, we study the linear code ${\mathcal{C}}^{\prime }$ whose parity check matrix consists of the rows of (see Assumption 2):

$$H^{\prime }:=\Psi (A,B)=\left(\begin{array}{cccc}B& AB& \dots & A^{T-1}B\end{array}\right)$$

(11)

which explicitly yields:

$$H^{\prime }=\left(\begin{array}{cccc}1& \alpha & \dots & {\alpha }^{k(T-1)+k-1}\\ 1& {\alpha }^2& \dots & {\alpha }^{2k(T-1)+2(k-1)}\\ ⋮& ⋮& & ⋮\\ 1& {\alpha }^{\delta }& \dots & {\alpha }^{\delta k(T-1)+\delta (k-1)}\end{array}\right).$$

(12)

In order to prove that ${\mathcal{C}}^{\prime }$ is GRS, by the facts of Section 2.1, it suffices to show that ${\left({\mathcal{C}}^{\prime }\right)}^{\perp }$ is GRS. Looking at the expression of (12), it is clear that $H^{\prime }\in {\mathbb{F}}_q^{\delta \times kT}$ is the matrix whose $(i,j)$-entry is ${\alpha }^{i(j-1)}$ and thus ${\left({\mathcal{C}}^{\prime }\right)}^{\perp }={GRS}_{\delta }(\mathbf{a},\mathbf{b})$, where $a_j={\alpha }^{j-1}$ and $b_j=1$ for $j=1,\dots ,kT$. Note that ${\mathcal{C}}^{\prime }$ has length $kT$ and dimension $kT-\delta$.

Now, since GRS codes are MDS (see [1], Thm. 5.3.1.(i)), it follows that the minimum distance of ${\mathcal{C}}^{\prime }$ is equal to the Singleton Bound, namely:

$$d^{\prime }=d_{\min }\left({\mathcal{C}}^{\prime }\right)=kT-kT+\delta +1=\delta +1.$$

(13)

Once this code has been studied, we turn to the linear codes ${\mathcal{C}}_h^{\prime }$ defined in step 5.1 of the Algorithm. The same reasoning shows that ${\mathcal{C}}_h^{\prime }$ is GRS as long as it has maximal rank $\delta$. Note that ${\mathcal{C}}_h^{\prime }$, being MDS, has minimum distance equal to $d_h^{\prime }:=n_h^{\prime }-k_h^{\prime }+1=k(T-h\Theta )-\delta +1$.

Finally, (3) would allow us to record explicit expressions for an $⌊\frac{n_h^{\prime }-k_h^{\prime }}{2}⌋$-error-correcting pair $({\mathcal{A}}_h^{\prime },{\mathcal{B}}_h^{\prime })$.

4.3. The Linear Code ${\mathcal{C}}^{″}$

Now we focus on the linear code ${\mathcal{C}}^{″}$ that is generated by the columns of the matrix (see Assumption 4):

$$\Phi (A,C)=\left(\begin{array}{c}C\\ CA\\ ⋮\\ C{A}^{\Theta -1}\end{array}\right)={\left(G^{″}\right)}^{†}.$$

(14)

Upon carrying out the computations, we deduce that the generator matrix of the $\left(\right(n-k)\Theta ,\delta )$-linear code ${\mathcal{C}}^{″}$ is given by the following matrix:

$${\left(G^{″}\right)}^{†}=\left(\begin{array}{cccc}1& 1& \dots & 1\\ \alpha & {\alpha }^2& \dots & {\alpha }^{\delta }\\ ⋮& & & ⋮\\ {\alpha }^{n-k-1}& {\alpha }^{2(n-k-1)}& \dots & {\alpha }^{\delta (n-k-1)}\\ {\alpha }^k& {\alpha }^{2k}& \dots & {\alpha }^{\delta k}\\ {\alpha }^{k+1}& {\alpha }^{2k+2}& \dots & {\alpha }^{\delta k+\delta }\\ ⋮& & & ⋮\\ {\alpha }^{n-k-1+k}& {\alpha }^{2(n-k-1)}& \dots & {\alpha }^{\delta (n-k-1)+\delta k}\\ ⋮& & & ⋮\\ ⋮& & & ⋮\\ {\alpha }^{k(\Theta -1)}& {\alpha }^{2k(\Theta -1)}& \dots & {\alpha }^{\delta k(\Theta -1)}\\ {\alpha }^{k(\Theta -1)+1}& {\alpha }^{2k(\Theta -1)+2}& \dots & {\alpha }^{\delta k(\Theta -1)+\delta }\\ ⋮& & & ⋮\\ {\alpha }^{k(\Theta -1)+n-k-1}& {\alpha }^{2k(\Theta -1)+2(n-k-1)}& \dots & {\alpha }^{\delta k(\Theta -1)+\delta (n-k-1)}\end{array}\right).$$

(15)

Thus, considering $b_j=1$ and:

$$a_j=\left\{\begin{array}{cc}{\alpha }^{j-1}\hfill & \mathrm{if}1\le j\le n-k\hfill \\ {\alpha }^{k+j-1-(n-k)}\hfill & \mathrm{if}n-k+1\le j\le 2(n-k)\hfill \\ ⋮\hfill & ⋮\hfill \\ {\alpha }^{k(\Theta -1)+j-1-(\Theta -1)(n-k)}\hfill & \mathrm{if}(\Theta -1)(n-k)+1\le j\le \Theta (n-k)\hfill \end{array}\right.$$

it follows that ${\mathcal{C}}^{″}={GRS}_{\delta }(\mathbf{a},\mathbf{b})$.

As ${\mathcal{C}}^{″}$ is a GRS, it is also MDS, and its minimum distance is given by the Singleton Bound:

$$d^{″}=d_{\min }\left({\mathcal{C}}^{″}\right)=(n-k)\Theta -\delta +1.$$

(16)

Furthermore, it admits an error-correcting pair $({\mathcal{A}}^{″},{\mathcal{B}}^{″})$ (see (3)).

4.4. Parameters, Assumptions and Complexity

Throughout this section, we have dealt with the convolutional code $\mathcal{C}$ as well as with the linear codes ${\mathcal{C}}^{\prime }$, ${\mathcal{C}}_h^{\prime }$ and ${\mathcal{C}}^{″}$. However, it remains to check whether all the assumptions of Section 3.1 hold. This is achieved using the following choice of parameters:

1. 

$\frac{n}{2}\le k<n$;

2. 

$\delta >\frac{1}{2k-n}(n-k)(2k-n+1)$ if $n\ne 2k$ and $\delta >1$ if $n=2k$;

3. 

$|{\mathbb{F}}_q|=q>\delta k⌈\frac{\delta }{n-k}⌉$; and

4. 

$T:=\delta ⌈\frac{\delta }{n-k}⌉$ and $\Theta :=⌈\frac{\delta }{n-k}⌉$.

The second condition implies that $T>\Theta$, i.e., Assumption 1 is fulfilled.

The first and third conditions imply, by ([13], Cor. 3.2; [8], Thm. 6.3.2; [12], § 3), that the convolutional code $\mathcal{C}$ corresponding to the mISO representation (10) is a non-catastrophic $(n,k)$-convolutional code with degree $\delta$ and free distance:

$$d_{\mathrm{free}}\left(\mathcal{C}\right)\ge \delta +1.$$

(17)

Let us check that Assumption 2 is satisfied. First, from the choice of the parameters one has:

$$\begin{array}{cc}\hfill & k(T-1)+k-1=kT-1=k\delta ⌈\frac{\delta }{n-k}⌉-1<q\hfill \\ \hfill & k(T-1)+k-1=k\delta ⌈\frac{\delta }{n-k}⌉-1\ge {\delta }^2-1\ge \delta ,\hfill \end{array}$$

and, thus, the rank of $H^{\prime }$ is $\delta$ (see (12)). Similarly,

$$\begin{array}{cc}\hfill & k(\Theta -1)+n-k-1<k(T-1)+k-1=kT-1<q\hfill \\ \hfill & k(\Theta -1)+n-k-1=k⌈\frac{\delta }{n-k}⌉-k+(n-k-1)\ge \hfill \\ & k\left(\frac{\delta }{n-k}\right)+(n-2k-1)>k\left(\frac{\delta }{n-k}\right)+\frac{\delta (n-2k)}{n-k}=\delta ,\hfill \end{array}$$

where the last inequality follows from the bound on $\delta$ imposed by the second condition. Hence, the rank of $G^{″}$ is $\delta$ (see (15)) and Assumption 4 is also fulfilled.

Since Section 4.2 and Section 4.3 provide explicit error-correcting pairs for ${\mathcal{C}}^{\prime }$, ${\mathcal{C}}_h^{\prime }$ and ${\mathcal{C}}^{″}$, Assumptions 3 and 5 are true.

Regarding Assumption 7, let us compute $\lambda$ in (7). In fact, from (13) and the choices of T and $\Theta$, one obtains:

$$\lambda :=min\left(⌊\frac{d^{\prime }-1}{2}⌋,⌊\frac{T}{2\Theta }⌋\right)=⌊\frac{\delta }{2}⌋.$$

Finally, we may write down the bounds on the complexity for this situation. Indeed, since $k\ge n-k$ and $T>\Theta$, the best case bound (8) yields:

$$\begin{array}{cc}\hfill \mathcal{O}\left(\frac{1}{\Theta }max\{{((n-k)\Theta )}^3,{\left(k(T-\Theta )\right)}^3\}\right)& =\mathcal{O}\left(\frac{1}{\Theta }{\left(k(T-\Theta )\right)}^3\right)\hfill \\ & =\mathcal{O}\left(\frac{n-k}{\delta }{\left(\frac{k{\delta }^2}{n-k}\right)}^3\right)=\mathcal{O}\left(\frac{k^3{\delta }^5}{{(n-k)}^2}\right).\hfill \end{array}$$

(18)

For the worst case, the bound can be sharpened since $\Theta$ codewords are decoded after $\frac{T}{\Theta }$ iterations. Indeed, the cost per decoded codeword (9) is:

$$\begin{array}{cc}\hfill \mathcal{O}\left(\frac{T}{{\Theta }^2}max\{{((n-k)\Theta )}^3,{\left(k(T-\Theta )\right)}^3\}\right)& =\mathcal{O}\left(\frac{T}{{\Theta }^2}{\left(k(T-\Theta )\right)}^3\right)\hfill \\ & =\mathcal{O}\left((n-k){\left(\frac{k{\delta }^2}{n-k}\right)}^3\right)=\mathcal{O}\left(\frac{k^3{\delta }^6}{{(n-k)}^2}\right).\hfill \end{array}$$

(19)

Remark 1.

Recalling the generalized Singleton bound for convolutional codes and (17), one gets the inequalities:

$$2\lambda \le \delta +1\le d_{\mathrm{free}}\left(\mathcal{C}\right)\le (n-k)\left(⌊\frac{\delta }{k}⌋+1\right)+\delta +1,$$

so that one wonders if our algorithm could be adapted for greater values of λ in Assumption 7 Indeed, one should study how the linear codes ${\mathcal{C}}^{\prime }$, ${\mathcal{C}}_h^{\prime }$ and ${\mathcal{C}}^{″}$ behave when $\mathcal{C}$ is assumed to be maximum distance separable; for instance, for those codes built in [18]. As a second approach, one could replace Pellikaan’s algorithm by the Sudan–Guruswami decoding algorithm (see [1], § 5.4.4). This algorithm, which also applies to generalized Reed–Solomon codes, might correct more than $⌊\frac{d_{\min }-1}{2}⌋$ errors, although its complexity is greater than that of Pellikaan.

Example 1.

As an illustration of parameters satisfying the constraints of Section 4.4, we offer two examples, which are also related to the discussion of ([5], § 5 Variation 2). First, we set $n\ge 2$ and $a\ge 2$ and define $k:=n-1$, $\delta :=(a-1)(n-k)+1=a$. Then, it holds that $T=a^2$, $\Theta =a$ and Algorithm 3.2 will correct errors of weight at most $\lambda =⌊\frac{\delta }{2}⌋=⌊\frac{a}{2}⌋$ in any time window of length $T=a^2$. It is worth noticing that, in this case, $d^{\prime }=\delta +1=a+1$ and $d^{″}=(n-k)\Theta -\delta +1=a-a+1=1$.

The second example deals with n even and $a\ge 2$. Define $k:=\frac{n}{2}$, $\delta :=(a-1)(n-k)+1=(a-1)k+1$. Since $⌈\frac{\delta }{n-k}⌉=a$, it holds that $T=\left(\right(a-1)k+1)a$, $\Theta =a$. Then, the algorithm will correct errors of weight at most $\lambda =⌊\frac{\delta }{2}⌋=⌊\frac{(a-1)k+1}{2}⌋$ in any time window of length T. In this case, $d^{\prime }=\delta +1=(a-1)k+2$ and $d^{″}=(n-k)\Theta -\delta +1=ka-(a-1)k-1+1=k$.

5. Conclusions

We have offered a full and explicit implementation of a hard decoding algorithm for a class of convolutional codes based on algebraic techniques [5,6], as well as an approach to the complexity of the resulting algorithm.

For a given family of codes ([7], § IV; [8]), we have checked that the parameters required for the algorithm can be chosen so that the assumptions are fulfilled. A detailed analysis of the computational complexity has allowed us to give lower and upper bounds for the computational cost per decoded codeword. These bounds are polynomial in the degree of the convolutional code.

Further research must be carried out in, at least, three aspects. First, an appropriate model for the transmission channel (e.g., binary symmetric channel, additive white gaussian noise (AWGN) channel, erasure channel, etc.) must be found so that one can compute the expected complexity, that is, the complexity of the average case (see, for instance, [19]). Second, it must be addressed whether our bounds are valid for other known families of convolutional codes, such as 1-dim MDS (see [18]), maximum distance profile (e.g., [10,20] and references therein) among others. Third, one should persevere in the search for new algebraic decoding algorithms whose complexity is comparable to that of sequential decoding. Some recent progress can be found in [12].