Algebraic Decoding for Doubly Cyclic Convolutional Codes

An iterative decoding algorithm for convolutional codes is presented. It successively processes $N$ consecutive blocks of the received word in order to decode the first block. A bound is presented showing which error configurations can be corrected. The algorithm can be efficiently used on a particular class of convolutional codes, known as doubly cyclic convolutional codes. Due to their highly algebraic structure those codes are well suited for the algorithm and the main step of the procedure can be carried out using Reed-Solomon decoding. Examples illustrate the decoding and a comparison with existing algorithms is being made.


Introduction
The main task of coding theory can be described as designing codes with good error-correcting performance along with an efficient decoding algorithm. For block codes two types of answers are known to this quest. On the one hand, there are algebraic decoding algorithms for the special class of BCH codes, see, e.g., [6,Sec. 5.4], including the more recent list decoding procedures as developed in [21,5], see also [20]. On the other hand, there are graph-based decoding algorithms as introduced by [26]. These are iterative methods and work particularly well for LDPC codes; for an overview see for instance the thesis [25].
For convolutional codes the most prominent decoding algorithms are the Viterbi algorithm [23] and variants thereof. They are all trellis-based algorithms and mainly applicable to codes over small alphabets and not too large degree in order to keep the underlying graph at a manageable size; for an overview see the monographs [9,12]. In the 1970's the first attempts were made in order to construct convolutional codes with some additional underlying algebraic structure in the hope of decoding them algebraically [10,15,16]. Later constructions included BCH convolutional codes [19] as well as specific constructions of cyclic convolutional codes [3,4] and Goppa convolutional codes [14]. In the paper [17], a first step toward an algebraic decoding algorithm for convolutional codes has been made. It is based on an input/state/output description of the code and relies on the controllability matrix being the parity check matrix of an algebraically decodable block code. This makes the algorithm particularly suitable for the BCH codes developed in [19]. In the thesis [22,Sec. 4.2] it is shown that the algorithm also applies to a certain class of 1-dimensional cyclic convolutional codes appearing as a special case in [4]. Finally, in the thesis [24,Sec. 4.3] a decoding algorithm for unit memory convolutional codes is developed which may be turned into an algebraic algorithm if the underlying block codes can be decoded algebraically. We will return to these algorithms at the end of Section 4 when comparing the performance of our algorithm with theirs.
In this paper we will present an algebraic decoding algorithm for a particular class of convolutional codes. It will depend on a chosen parameter N and a certain weight bound d and can correct up to ⌊d/2⌋ errors appearing on any time window of length N . The algorithm is a special version of a decoding algorithm appearing first in [7,Sec. 4.4] and [8]. As opposed to our presentation, the algorithm is cast completely in the setting of input/state/output descriptions in [7,8]. The procedure works sequentially in the sense that N consecutive blocks of the received word are processed in order to decode the first of those blocks. This decoding step is based on the partial decoding of a certain block code. Thereafter the algorithm moves one block further. The details, in a slightly more general version, will be presented in the next section. In Section 3 we will show that the class of doubly cyclic convolutional codes, introduced in [4], is particularly well suited for this algorithm. Indeed, first of all the error parameter d can be made quite large (compared to the length, dimension, and degree of the code), and secondly the partial decoding of the underlying block code can be achieved by the well-known and efficient Reed-Solomon decoding. It should be mentioned that due to the large field size and degree of doubly cyclic codes, Viterbi decoding is not feasible for this particular class of convolutional codes. In the final section we will run some detailed examples and will compare our algorithm to the decoding algorithms mentioned above with respect to error-correcting performance and time complexity.
Let us close the introduction with recalling the basic notions of convolutional coding theory as needed throughout the paper. Let F be a finite field and let F[z] and F[[z]] denote the rings of polynomials and formal power series in z, respectively. Throughout this paper we regard vectors as row vectors, so that in every vector-matrix multiplication the matrix appears on the right. A convolutional code of length n is an where G is a basic matrix in F[z] k×n , i. e. rk G(λ) = k for all λ ∈ F, with F being an algebraic closure of F. We call such a matrix G an encoder, and the number deg(C) := deg(G) := max{deg(M ) | M is a k-minor of G} is said to be the degree of the encoder G or of the code C. For each basic matrix the sum of its row degrees is at least deg(G), where the degree of a polynomial row vector is defined as the maximal degree of its entries. A matrix G ∈ F[z] k×n is said to be reduced if the sum of its row degrees equals deg(G); for the many characterizations of reducedness see, e. g., [1,Main Thm.] or [13,Thm. A.2]. It is well known [1, p. 495] that each convolutional code admits a reduced encoder. The row degrees of a reduced encoder are, up to ordering, uniquely determined by the code and are called the Forney indices of the code or of the encoder, and the maximal Forney index is called the memory of the code. The main example class of convolutional codes in this paper, so called doubly-cyclic convolutional codes, will be introduced in Theorem 3.1.
Besides these algebraic notions the main concept in error-control coding is the weight. The well-known Hamming weight of a vector v = (v 1 , . . . , v n ) ∈ F n is given as wt(v) = #{i | v i = 0} and d(v, w) := wt(v − w) denotes the associated Hamming distance. For a polynomial vector v = N t=0 v t z t ∈ F[z] n , v t ∈ F n , we define its overall Hamming weight as wt(v) = N t=0 wt(v t ). The distance min{wt(v) | v ∈ C, v = 0} of a block code C is denoted by dist(C), while for a convolutional code it is written as d free (C).

A General Decoding Algorithm
We consider a convolutional code C = im G : For the decoding algorithm we need to fix a processing depth N ∈ N and define the block code where, as usual, G j = 0 for j > m and the empty triangular part is filled with zero entries. Notice that due to the basicness of the encoder G, the matrix G 0 , and henceĜ, has full row rank. Besides the processing depth N , the decoding algorithm will also depend on the choice of a step size parameter L ∈ {1, . . . , N } and a weight parameter d : 3), regardless of the value of L. Later on we will see that the error-correcting bound of our decoding algorithm will be given by ⌊d/2⌋ and therefore we will be interested in choosing d as large as possible. However, Algorithm 2.3 below will not depend on choosing d optimal. In the next section, we will present a class of codes along with a specific large weight parameters d satisfying (2.3), and we will show how to carry out the main step of the algorithm for those codes efficiently. Notice that dist(B) = dist(im G 0 ) = 2. By inspecting all 4 codewords in B we see that d = n − 1 is the largest value for which (2.3) is true (actually, wt(v) ≤ n − 1 implies wt(v) ≤ 2). One should also observe that in this case d = d free (C) − 1, which is the maximum possible value for d, see Remark 2.2(b).
We will also need the matrixG ∈ F mk×N n defined as where in the second case the zero matrices on the very right consist of (N −m)n columns. Notice that the matrix Ĝ G ∈ F (N +m)k×N n is a typical block in the sliding generator matrix of the  (b) The free distance of the code is at least d + 1.
Now we are ready to formulate the general steps of the decoding algorithm. The algorithm has been presented first in [7,Sec. 4.4] and [8], where it is given in a more general form and within the context of the tracking problem of control theory. In those papers it is given in terms of an input/state/output representation of the convolutional code.
Let us fix N ∈ N and L, d satisfying (2.3). The following algorithm will, in each cycle, process strings of N consecutive received blocks in order to decode the first L of those blocks with respect to the convolutional code C = im G. In the next cycle the algorithm will move L steps further down the time axis.
] n be a received word. Suppose that for some j ≥ 0 we have computedû t ∈ F k ,v t ∈ F n , t = 0, . . . , jL − 1. We assume thatv is the decoding ofṽ on the time interval [0, jL − 1] and thatû is the associated message string. In the initial step where j = 0 this condition is empty and in Step 1 the vector S is set to zero.
Step 2: Replace j by j + 1 and return to Step 1.
has been sent and the word t≥0ṽ t z t ∈ F[[z]] n has been received.
(1) The data returned by Algorithm 2.3 satisfyv := t≥0v t z t = ( t≥0û t z t )G, thusv is a codeword in C with associated message t≥0û t z t .
(2) Let L and d satisfy (2.3). If the transmission errors satisfy Notice that, due to Remark 2.2(a), for any received wordṽ ∈ F[[z]] n there exists at most one codeword v ∈ C satisfying (2.6).
Proof: (1) Assume that for some j ≥ 0 we have already computed the dataû t ,v t , t = 0, . . . , jL − 1 and that which, for j = 0, is an empty assumption. The next step of the algorithm produces In either case, we derivev jL+t = m i=0û jL+t−i G i for t = 0, . . . , N − 1 and together with (2.7) this shows that jL+N −1 t=0v . In particular, (2.7) is true for j + 1 instead of j (recall that the algorithm only returns v jL , . . . , v (j+1)L−1 ). This completes the proof of (1).
(2) Suppose that for some fixed j ≥ 0 the algorithm correctly returnedv for the data in Step 1 of the algorithm. By (2.4) we have But then (2.5) yields that v jL+t =v jL+t for t = 0, . . . , L − 1. Finally, the uniqueness of the associated message sequence (or the full row rank ofĜ) implies u jL+t =û jL+t for t = 0, . . . , L − 1.
2 Notice that the algorithm will, in each cycle, decode a string of L consecutive codeword blocks. The most interesting case will be L = 1, which will lead to a possibly larger d satisfying (2.3) and thus to a larger amount of errors that can be corrected. In the next section we will concentrate on that case.

Partial Decoding of the Block Code B
The main step of Algorithm 2.3 is the partial decoding with respect to the block code B from (2.2). In this section we will show how to carry out this step efficiently for a particular class of convolutional codes, which were designed in [4]. For those codes the decoding step essentially amounts to decoding certain Reed-Solomon block codes. The codes can be defined as follows.
Let F = F q be a field with q elements and primitive element α.
. . , f n−1 ) be the canonical vector space isomorphism between A and F n . Fix k ∈ {0, . . . , n−1} and consider the F-algebra automorphism σ : A −→ A defined by σ(x) = α k x. It is easy to see that this does indeed define an F-algebra automorphism on A. The following has been shown in [ k×n is basic and reduced with all Forney indices equal to m. In particular, m is the memory of the code.
is a Reed-Solomon code of dimension (j+1)k with generator polynomial Let us briefly comment on the notion of cyclicity. The convolutional code C is a cyclic convolutional code in the sense of [3]. Indeed, it can be shown that C may be identified with the left ideal generated by the polynomial g := m j=0 z j σ j (f ) in the skew-polynomial ring A[z; σ], see also [4, p. 165]. Due to the additional cyclic structure of the block codes B j these codes have been named doubly cyclic in [4]. The description as left ideals in A[z; σ], however, is not needed for this paper. It is worth mentioning that for k = 1, part (2) of the theorem above shows that the codes satisfy the generalized Singleton bound for convolutional codes [18] and thus are MDS codes. In [4, p. 162] it has been shown that for k = 2 the codes attain the Griesmer bound. Thus, the codes have the best possible distance among all codes of the same length, dimension, degree, and field size; for the Griesmer bound see [9,Sec. 3.5] for the binary case and [2,Thm. 3.4] for the general case.
We will consider the decoding algorithm of the previous section with processing depth N := m + 1. Thus, Due to the full row rank of the matrices in (3.1) this code has the following property.
. As a consequence, (2.3) turns into the following property.
It is worth mentioning that in concrete examples, d as in (3.4) might not be the largest value satisfying (3.3). Indeed, for F = F 7 , n = 6, k = 2, and m = 2 one has d 0 + d 1 + d 2 − 1 = 8, but using some weight-computing routines one can show that the largest d satisfying (3.3) is 10. However, Algorithm 3.3 presented below will be able to correct ⌊d/2⌋ errors, where d is as in (3.4). Therefore we will not be concerned with optimizing the value of d. Notice also that Let us now turn to Algorithm 2.3. The main part in Step 1) consists of achieving the following task: given a received vectorṽ := (ṽ 0 , . . . ,ṽ m ) ∈ F (m+1)n satisfying d(ṽ, B) ≤ ⌊d/2⌋, return a vector (v 0 , . . . ,v L−1 ) for which there exists an extensionv := (v 0 , . . . ,v m ) ∈ B satisfying d(v,ṽ) ≤ ⌊d/2⌋. In the following algorithm we will carry this out for step size L = 1. Recall from Remark 3.2 that the parameter d from (2.3) can be made largest for L = 1 and therefore this will allow us to correct the largest amount of errors.
Throughout the rest of the paper, the phrase Reed-Solomon decoding will refer to any of the algebraic decoding algorithms for Reed-Solomon codes that correct up to t errors, where t is the error-correcting bound of the code. If such decoding is not possible, the algorithm returns an error message. Step 1: l := l − 1.
In the next theorem we will see that Case a) or b) will only be invoked if no codeword v ∈ B satisfies d(ṽ, v) ≤ ⌊d/2⌋. When calling Algorithm 3.3 in Step 1) of Algorithm 2.3 this amounts to the fact that no convolutional codeword v ∈ C satisfies the familiar error assumption (2.6). Of course, if d(ṽ, B) > ⌊d/2⌋, there are various options of how to proceed. The easiest and cheapest solution would be to simply return any codeword w 0 =x 0 G 0 along with its messagex 0 . The strategy outlined in Algorithm 3.3 requires more effort and is designed to result in a codeword that is more likely to be close (or even closest) toṽ. Indeed, notice that, by construction, the wordsw i are codewords in B i close to the corresponding blockṽ i . However, this does not guarantee that the chosen codeword will be closest toṽ. We would also like to point out that for the list decoding, see [21,5,20], used in Cases a) and b) one might have to increase successively the list size in order to have a nonempty return. If more than one codeword y l+1 is returned one could even use all of them and extend them in the described way. Finally it is worth mentioning that in Step 2) of the algorithm one could also replace Reed-Solomon decoding by list decoding in order to produce a bigger pool of codewords and enhance the chances of early success in Step 3. Step 2 is not executed at all or the inequality in Step 3 is not satisfied. In Part 1) and 2) below we will show that in both cases we obtain that is, the sent codeword and the received word satisfy the analogous error assumption on the time interval [0, m − 1]. This will allow us to argue inductively. In Part 3) we will show that there exists l for which the algorithm will return a result w Going through all four cases of d (m) and d m being even or odd shows that 3) Suppose now that the algorithm proceeded to Step 2 for the value l. By the preceding discussion, see (3.7), we then have d (v 0 , . . . , v l ), (ṽ 0 , . . . ,ṽ l ) ≤ ⌊d (l) /2⌋. Since this is the error-correcting bound of the code B 0 , decoding ofṽ 0 will take place and will result in w (0) 0 = v 0 . This word will indeed be returned in Step 3 of the algorithm. This completes the proof. 2 Observe that Algorithm 3.3 might return a codeword w (l) 0 in some cycle of Step 3) even if d(ṽ, B) > ⌊d/2⌋. The way the algorithm is formulated this potential decoding error will not be detected. However, the overall Algorithm 2.3 might detect this situation by checking whether the received wordṽ and the decoded wordv ∈ C satisfy d (v j , . . . ,v j+m ), (ṽ j , . . . ,ṽ j+m ) ≤ ⌊d/2⌋ for all j ∈ N 0 , see (2.6). One could, of course, extend Algorithm 3.3 by using the strategy of Case a) in order to extend a partial codeword w (l) to full codewords and checking whether one of those is within ⌊d/2⌋ ofṽ. But, as mentioned earlier, there is no guarantee that this strategy will find the closest codeword.

Examples and Comparison to Other Decoding Algorithms
We will first give some examples illustrating the algorithm. Thereafter, we will compare the algorithm to other existing algorithms with respect to error-correcting capability and complexity.
Recall the data from Theorem 3.1.
We will close the paper with comparing the error-correcting capability and time complexity of our algorithm with existing algorithms handling codes of comparable size. In order to do so, let us first summarize the performance of our algorithm. It is known [20, p. 247] that Reed-Solomon decoding of an [n, k] code has a time complexity of O n(log 2 n) 2 , counting operations in the field F q , where q ≥ n + 1. Using list decoding this complexity will grow by the factor l, where l is the size of the list of codewords produced by the algorithm [20, p. 255]. At each cycle of Step 1) Algorithm 2.3 essentially consists of invoking at most m + 1 ≤ n times Reed-Solomon (or list) decoding of a Reed-Solomon code of length n (and dimension jk, j = 1, . . . , m + 1) and thus has a time complexity of O (m + 1)n(log 2 n) 2 of operations in the field F q = F n+1 . It can correct up to ⌊d/2⌋ errors occurring on any string v j(m+1) , . . . , v (j+1)(m+1)−1 , j ∈ N 0 , of m + 1 consecutive codeword blocks, and where d is as in (3.5).
Let us now turn to the decoding algorithms mentioned in the introduction.
1) First of all, since Algorithm 2.3/3.3 applies to a convolutional code C ⊆ F q [z] n of degree km, see Theorem 3.1, and where the field size is q = n + 1, Viterbi decoding for this particular convolutional code is, in general, not feasible due to the high state space cardinality (n + 1) km .
2) Let us consider an [n, k] Reed-Solomon block code, like B 0 , for the encoding/decoding of the data stream v 0 , v 1 , v 2 , . . .. Hence, each block v j is encoded/decoded independently. This requires a time complexity of O n(log 2 n) 2 for the decoding of each block and can correct up to ⌊(n − k)/2⌋ errors on any block, which means up to (m + 1)⌊(n − k)/2⌋ errors on a string of m + 1 consecutive blocks. While this is, in general, larger than ⌊d/2⌋, it only applies if no more than ⌊(n − k)/2⌋ errors appear on a single block. For instance, none of the coefficients of the received wordṽ in Example 4.1 could have been correctly decoded because eachṽ j is more than one error apart from the block code B 0 .
3) Suppose now that we use a (generalized) Reed-Solomon code of the size of B, that is, an [(m + 1)n, (m + 1)k] RS code, in order to encode/decode every string of m + 1 consecutive blocks v j(m+1) , . . . , v (j+1)(m+1)−1 , j ∈ N 0 independently. This way we could correct up to ⌊(m + 1)(n − k)/2⌋ errors on any such string. But this enhanced error-correcting capability comes with a significantly higher time complexity. Indeed, the complexity goes up to O (m + 1)n, (log 2 (m + 1)n) 2 , and this is counting operations in a much larger field with at least (m + 1)n elements. 4) In this part, we will compare our algorithm with a decoding algorithm designed for unit memory convolutional codes in the thesis [24,Sec. 4.3]. Consider a code with generator matrix G 0 + G 1 z, where G 0 , G 1 ∈ F k×n . Suppose G 0 , G 1 generate block codes with distances δ 0 , δ 1 , respectively. Then the algorithm in [24,Sec. 4.3] can correctly recover the sent codeword provided that a) no more than a total of t := ⌊(δ 0 + δ 1 − 1)/2⌋ errors occurred during the transmission, b) the degree of the sent codeword (or an upper bound thereof) is known, and c) the block codes generated by G 0 , G 1 can be decoded effectively. Applying this to the code in Theorem 3.1 with memory m = 1, we obtain δ 0 = δ 1 = n − k + 1, and therefore the algorithm in [24] can correct up to a total of t = n − k errors occurring during the whole transmission. It is based on decoding the Reed-Solomon codes generated by G 0 , G 1 and thus has a running time of O n(log 2 n) 2 for the decoding of each codeword block. In contrast, Algorithm 2.3/3.3 can correct up to t ′ = ⌊n − k − k−1 2 ⌋ errors occurring on each string of 2 consecutive codeword blocks, see (3.5), and the running time is essentially the same. Notice that for k = 1 we have t ′ = t, making our algorithm significantly more suitable for this class of codes than the algorithm proposed in [24]. As for general dimension k, it is easy to see that 2t ′ ≥ t (due to k ≤ n/2, see Theorem 3.1) and therefore our algorithm corrects, on each string of 4 consecutive blocks, at least as many errors as the total amount corrected by [24] -as long as no more than t ′ errors happened on each half of that string. We would also like to point out that the algorithm in [24] needs the whole received word in order to perform decoding, while our algorithm is iterative in the sense that it starts decoding as soon as the first 2 blocks have been received. Of course, the algorithm in [24] is applicable to any convolutional code as long as it has unit memory, whereas our algorithm depends on the weight property described in (3.3), (3.4) and is specifically designed for the codes of Theorem 3.1, but requires a weaker assumption on the memory. 5) Finally, it remains to compare Algorithm 2.3/3.3 with an algebraic decoding algorithm developed for convolutional codes in [17]. That algorithm is based on an input/state/output description of the code in question, and its performance may be summarized as follows (after adjusting to row vector notation): Suppose the k-dimensional code C = im G ⊆ F[z] n of degree δ has i/s/o description where (u t , y t ) ∈ F k+(n−k) is the sequence of codeword coefficients, x t ∈ F δ is the state sequence, and (A, B, C, D) ∈ F δ×δ × F k×δ × F δ×(n−k) × F k×(n−k) . Suppose Θ ∈ N is such that the matrix (C, AC, . . . , A Θ−1 C) has full row rank and that T > Θ and d 1 ∈ N are such that the matrix has full column rank and ker M := {v ∈ F T k | vM = 0} is a block code of distance at least d 1 .
Then the decoding algorithm in [17] will return the sent codeword if at most λ := min ⌊(d 1 − 1)/2⌋, ⌊T /(2Θ)⌋ (4.3) errors occurred on any time window [j, j + T − 1], j ∈ N 0 , that is, if any string of T consecutive codeword blocks does not contain more than λ errors. In the sequel we will show that Algorithm 2.3/3.3 is better suited for decoding our particular class of codes than the algorithm in [17]. Indeed, we will show that for our class of codes λ ≤ ⌊m/2⌋ and T ≤ m + 1. Comparing this to (3.5) shows that Algorithm 2.3/3.3 can correct significantly more errors on intervals of length m + 1. Indeed, using that m ≤ n/k − 1 it is not hard to see that ⌊d/2⌋ ≥ m, so that our algorithm can correct at least twice as many errors.
Let us now turn to the details. Recall the data given right before Theorem 3.1 and fix the parameters and the encoder G as in that theorem. Then the code C = im G has degree δ = mk and therefore, in order for M in (4.2) to have full column rank we need T ≥ m and for ker M to be a nontrivial code we even need T ≥ m+1. Write G = [Q, P ], where Q ∈ F[z] k×k . We first note that the matrix Q is upper triangular. Indeed, the polynomial f ∈ F[x] given in Theorem 3.1 has degree n − k and thus deg(x l f ) ≤ n − 1 for all l = 0, . . . , k − 1. As a consequence, we do not have to reduce modulo x n − 1 when computing in the quotient ring A. Since x l | (x l f ), we see that the first l entries of the vector v(x l f ) ∈ F n are zero while the (l + 1)-st entry is nonzero (since f has nonzero constant term). But then the same is true for v σ j (x l f ) because for any polynomial g ∈ A we have σ(g) = g(α k x) and no reduction modulo x n − 1 is needed. All this shows that the matrix Q is upper triangular and that the diagonal entries have degree m. With the aid of Theorem 3.1(1) this yields that Q −1 P is a proper rational matrix. Now we may use the controller canonical form of Q −1 P in order to get an i/s/o representation of the code. Using the method outlined in [11, Sec. 6.4.1] (and transposing everything for row vector notation) shows that the matrix A ∈ F mk×mk is upper block triangular with diagonal blocks of size m × m and B ∈ F k×mk is upper block triangular with diagonal blocks of size 1 × m. Thus, collecting the last rows of each block in the matrix M in (4.2) results in a submatrix M ′ ∈ F T ×mk in which the first (k − 1)m columns are zero and thus rk M ′ ≤ m. As a consequence, since T ≥ m + 1 there exists a nonzero vector v ∈ F T k of weight at most m + 1 such that vM = 0. Thus, d 1 ≤ dist(ker M ) ≤ m + 1 and the error correcting bound in (4.3) satisfies λ ≤ ⌊m/2⌋. Using some more detailed considerations one can show that, likewise, every other input/output partition of the codewords (that is, permuting the columns of G before splitting the matrix into [Q, P ]) along with an according i/s/o representation leads to the same error-correcting bound λ ≤ ⌊m/2⌋. Summarizing, we may conclude that Algorithm 2.3/3.3 is better suited for decoding the class of codes defined in Theorem 3.1 than the algorithm in [17].