High-rate systematic recursive convolutional encoders: minimal trellis and code search

Abstract

We consider high-rate systematic recursive convolutional encoders to be adopted as constituent encoders in turbo schemes. Douillard and Berrou showed that, despite its complexity, the construction of high-rate turbo codes by means of high-rate constituent encoders is advantageous over the construction based on puncturing rate-1/2 constituent encoders. To reduce the decoding complexity of high-rate codes, we introduce the construction of the minimal trellis for a systematic recursive convolutional encoding matrix. A code search is conducted and examples are provided which indicate that a more finely grained decoding complexity-error performance trade-off is obtained.

1 Introduction

The typical turbo code configuration is the parallel concatenation of two systematic recursive constituent convolutional encoders of rate 1/2 connected via an interleaver, resulting in a code of rate 1/3. However, higher rate turbo codes may be useful in modern wireless, magnetic recording and fiber optics applications[1]. The usual approach to increase the overall rate is to puncture selected bits of the turbo codeword[2]. An alternative is to use high-rate constituent encoders[1, 3, 4] what, according to[3], offers several advantages, such as better convergence of the iterative process, higher throughput, reduced latency, and robustness of the decoder. If puncturing is still needed to achieve a required rate, fewer bits have to be discarded when compared to the conventional rate-1/2 constituent encoders, resulting in less degradation of the correcting capability of the constituent code[3].

In[1], a class of systematic recursive convolutional encoders restricted to be of rate k/(k + 1) is proposed. The codes are optimized in terms of the pairs (d _i ,N _i ), where d _i is the minimum weight of codewords generated by input sequences of weight i and N _i are their multiplicities, and thus suited to be used as constituent encoders of turbo codes[5]. Good systematic recursive encoding matrices with increasing values of encoder memory sizes for a fixed code rate are listed. Turbo codes constructed with the family of constituent encoders given in[1] are shown to outperform some high-rate turbo codes obtained by puncturing a rate-1/2 constituent encoder.

One major drawback of high-rate constituent encoders is the decoding complexity since it increases exponentially with k and with the constraint length for various decoding algorithms. With the motivation of proposing a class of turbo codes with low complexity, high-rate constituent encoders, Daneshgaran et al.[4] constructed recursive constituent encoders of rate k/(k + 1) by puncturing a rate-1/2 recursive mother encoder. However, a reduction in decoding complexity is obtained at the expense of a reduced spectrum (d _i ,N _i ) when compared to that of the best recursive encoder of rate k/(k + 1)[1].

An alternative to reduce the decoding complexity is to consider trellis representations for the constituent codes other than the conventional trellis usually adopted. For nonrecursive convolutional encodes, there is a trellis structure, the minimal trellis[6], which represents the coded sequences minimally under various complexity measures. The interest on the minimal trellis representation comes from its good error performance versus decoding complexity trade-off[7–10] and its potential power consumption and hardware utilization reductions[11]. However, the minimal trellis construction presented in[6] cannot be readily applied to turbo codes. The reason is that the mapping between information bits and coded bits produced by the minimal trellis corresponds to nonrecursive convolutional encoders, while systematic, recursive mappings are required in turbo coding. This article presents a method which can fill this gap.

In this article, we introduce the construction of the minimal trellis for a systematic recursive convolutional encoding matrix, the encoding required for the constituent codes of a turbo code. Our goal is to reduce the decoding complexity of a turbo decoder operating with high-rate constituent encoders. We also conduct a code search to show that a more finely grained decoding complexity-error performance trade-off is achieved with our approach. We tabulate several new encoding matrices with a larger variety of complexities than those in[1], as well as code rates other than k/(k + 1). The proposed minimal trellis can be constructed for systematic recursive convolutional encoders of any rate. Thus, our approach is more general than that in[1], while allowing that a distance spectrum (d _i ,N _i ) better than that of the punctured codes in[4] can be achieved.

The rest of this article is organized as follows. In Section 2, we introduce some basic definitions and notations. Section 3 introduces the minimal trellis construction for a systematic recursive convolutional encoding matrix. In Section 4, we present search code results. Section 5 concludes the article.

2 Preliminaries

Consider a convolutional code C(n,k,ν), where ν, k and n are the overall constraint length, the number of binary inputs and binary outputs, respectively, while the code rate is R = k/n. Every convolutional code can be represented by a semi-infinite trellis which (apart from a short transient in its beginning) is periodic, the shortest period being a trellis module. The conventional trellis module Φ _conv consists of a single trellis section with 2^ν initial states and 2^ν final states; each initial state is connected by 2^kdirected branches to final states, and each branch is labeled with n bits.

The minimal trellis module, Φ _min , for nonrecursive convolutional codes was developed in[6]. Such a structure has n sections,$2^{{\tilde{\nu }}_t}$ states at depth t,$2^{{\tilde{b}}_t}$ branches emanating from each state at depth t, and one bit labeling each branch, for 0 ≤ t ≤ n −1. The trellis complexity of the module Φ, TC(Φ), defined in[6] captures the complexity of trellis-based decoding algorithms[12]. It is shown in[6] that$\mathit{\text{TC}}\left({\mathrm{\Phi }}_{\mathit{\text{conv}}}\right)=\frac{n}{k}{2}^{\nu +k}$ and$\mathit{\text{TC}}\left({\mathrm{\Phi }}_{\min }\right)=\frac{1}{k}\sum _{t=0}^{n-1}{2}^{{\tilde{\nu }}_t+\widetilde{b_t}}$ symbols per bit. The state and the branch complexity profiles of the minimal trellis are denoted by$\stackrel{\mathit{~}}{\mathit{\nu }}=({\tilde{\nu }}_0,\dots ,{\tilde{\nu }}_{n-1})$ and$\stackrel{\mathit{~}}{\mathit{b}}=({\tilde{b}}_0,\dots ,{\tilde{b}}_{n-1})$, respectively. It has been shown in[6] that for many nonrecursive convolutional codes the trellis complexity TC(Φ _min ) of the minimal trellis module is considerably smaller than the trellis complexity TC(Φ _conv ) of the conventional trellis module.

A generator matrix G(D) of a convolutional code C(n,k,ν) is a full-rank k × n polynomial (in D) matrix that encodes/generates C, i.e., is realizable by a linear sequential circuit (called an encoder for C)[13]. Let G(0) denote the binary matrix obtained when substituting D with 0 in the matrix G(D). If G(0) is full-rank, then G(D) is called an encoding matrix and is of particular interest. Two generator (encoding) matrices G(D) and G^′(D) are equivalent if they generate the same code or, equivalently, if and only if there exists a k × k nonsingular polynomial matrix T(D) such that G(D) = T(D)G^′(D). A generator matrix G(D) is called basic if it is polynomial and it has a polynomial right inverse n × k matrix G⁻¹(D). A basic encoding matrix G(D) has a Smith form decomposition ([13], p. 44), ([14], Theorem 4.6)

$$G\left(D\right)=A\left(D\right){\mathrm{\Gamma }}^{\prime }\left(D\right)B\left(D\right),$$

(1)

where the non-zero elements of Γ^′(D) are called the invariant factors of G(D), the k × k matrix A(D) and the n × n matrix B(D) are both polynomial with unit determinants. Let ν _i be the constraint length for the ith input of a polynomial generator matrix G(D), defined as ν _i = max_1≤j≤n{degG_i,j(D)}. Then the overall constraint length (already mentioned) is given by ν = ν₁ + ⋯ + ν _k . Define also the memory m of G(D) as m = max_1≤i≤k{ν _i }. A basic generator matrix G(D) is called minimal-basic if the overall constraint length ν is minimal over all equivalent basic encoding matrices.

A generator matrix G(D) can be decomposed as G(D) = G₀ + G₁D + ⋯ + G _m D^m, where G _i , for i = 0,…,m are the k × n (scalar) generator submatrices. The scalar generator matrix G _scalar is given by[6]

$$G_{\mathit{\text{scalar}}}=\left[\begin{array}{cccc}{G}_0& G_1& \cdots & G_m\\ G_0& G_1& \cdots & G_m\\ \ddots & \ddots \end{array}\right].$$

(2)

The “matrix module” is the matrix$Ĝ$ defined as[6]

$$Ĝ=\left[\begin{array}{l}{G}_m\\ ⋮\\ G_0\end{array}\right].$$

(3)

The generator matrix G(D) is said to be in the left–right (LR) (or minimal span or trelis oriented) form, if no column of G _scalar contains more than one underlined entry (the Leftmost nonzero entry in its row), or more than one overlined entry (the Rightmost nonzero entry in its row). If G(D) is in LR form, then it produces the minimal trellis for the code[6].

Next, we introduce a method to construct the minimal trellis for systematic recursive convolutional encoding matrices.

3 Construction of the minimal trellis for systematic recursive encoding matrices

The construction of the “minimal” trellis for the systematic recursive convolutional encoding matrix G_sys(D) involves two main steps. First, we find the minimal trellis of an equivalent nonsystematic nonrecursive minimal-basic generator matrix in LR form. Then, the mapping between the information bits and coded bits in this trellis is changed in order to construct a systematic minimal trellis. The complete algorithm is summarized in the end of this section.

3.1 Minimal trellis for an equivalent encoder

Let G_sys(D) be a systematic recursive encoding matrix for a rate R = k/n convolutional code and let q(D) be the least common multiple of all denominators of the entries in G_sys(D). We construct a nonsystematic nonrecursive basic encoding matrix, denoted by G _b (D), equivalent to G_sys(D), as follows ([13], p. 44), ([14], Theorem 4.6):

• Find the Smith form decomposition of the polynomial matrix q(D)G_sys(D):

  $$q\left(D\right)G_{\text{sys}}\left(D\right)=A\left(D\right){\mathrm{\Gamma }}^{\prime }\left(D\right)B\left(D\right),$$

  (4)

  where the non-zero elements of Γ^′(D) are called the invariant factors of q(D) G_sys(D), the k × k matrix A(D) and the n × n matrix B(D) are both polynomial with unit determinants. Thus, the invariant factor decomposition of G_sys(D) is

  $$G_{\text{sys}}\left(D\right)=A\left(D\right)\mathrm{\Gamma }\left(D\right)B\left(D\right),$$

  (5)

  where Γ(D) = Γ^′(D)/q(D).

• Form the desired encoding matrix G _b (D) as the k × n submatrix of B(D) in (5) consisting of the first k rows.

We can then perform a sequence of row operations on G _b (D) to construct a nonsystematic nonrecursive minimal-basic encoding matrix G(D) in LR form.

Example 1

Consider the (n k ν) = (4,3,3) systematic recursive encoding matrix[1, Table IV]

$$G_{\text{sys}}\left(D\right)=\left(\begin{array}{cccc}1& 0& 0& \frac{1+D+D^3}{1+D^3}\\ 0& 1& 0& \frac{1+D^2+D^3}{1+D^3}\\ 0& 0& 1& \frac{1+D+D^2+D^3}{1+D^3}\end{array}\right).$$

(6)

The invariant factor decomposition of G_sys(D) is given by

$$\begin{array}{l}{G}_{\text{sys}}\left(D\right)=\left(\begin{array}{lcr}1& 0& 0\\ D^2+D^4+D^5& 1& 1\\ D^2+D^3+D^4+D^5& 1& 0\end{array}\right)\left(\begin{array}{cccc}\frac{1}{1+D^3}& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\end{array}\right)\\ \left(\begin{array}{cccc}1+D^3& 0& 0& 1+D+D^3\\ D^2+D^3+D^4+D^5& 0& 1& 1+D+D^4+D^5\\ D^3& 1& 1& D+D^3\\ D^2& 0& 0& 1+D^2\end{array}\right).\end{array}$$

(7)

The basic encoding matrix G _b (D) equivalent to G_sys(D) is readily obtained from (7). Using the greedy-algorithm[15] we turn G_b(D) into the LR form, or equivalently, into the minimal-span form[15, Theorem6.11], resulting in the following generator matrix

$$G\left(D\right)=\left(\begin{array}{cccc}1& 1& 1& 1\\ 0& 1+D& D& 1\\ D+D^2& D+D^2& 1& 1+D\end{array}\right)$$

(8)

with overall constraint length ν = 3. The trellis complexity of the conventional module for G_sys(D) is TC(Φ _conv ) = 85. 33 symbols per bit.

The minimal trellis module for the convolutional code with G(D) given in (8), constructed with the method presented in[6], is shown in Figure1. It has state and branch complexity profiles given by$\stackrel{\mathit{~}}{\mathit{\nu }}=(3,4,4,4)$ and$\stackrel{\mathit{~}}{\mathit{b}}=(1,1,1,0)$, respectively. Thus, the trellis complexity of the minimal trellis is TC(Φ _min ) = 32 symbols per bit. In the first three trellis sections, the upper (resp. lower) branches correspond to information bit “0” (resp. “1”), i.e., the standard convention[6]. The solid branches represent “0” codeword bits and the dashed branches represent “1” codeword bits. The mapping between information bits and coded bits in Figure1 is not systematic, so this trellis does not represent the same encoder as G_sys(D). The construction of a minimal trellis for systematic recursive encoders is discussed in the next section.

Figure 1

Minimal trellis module for the ( n ,k,ν) = (4,3,3) convolutional code with G(D) given in ( 8). The solid/blue branches represent “0” codeword bits and the dashed/red branches represent “1” codeword bits. In the first three transitions, the upper (resp. lower) branches correspond to information bit “0” (resp. “1”), i.e., the standard convention.

3.2 Minimal trellis for systematic recursive encoders

Originally, minimal trellises have been constructed for codes, not for matrices (or encoders). However, the convention that the upper branches refer to the information bit 0 and the lower branches refer to the information bit 1 yields a particular encoding which, in general, is not systematic. We note that the association of solid/dashed branches with codeword bits can not be changed, as any change in this regard would result in a trellis which would no longer represent the convolutional code. However, by enforcing a different convention on the association of the branches to the information bits, only a different encoding for the same code is obtained.

Since in the systematic part the information bit and the coded bit must have the same value, all we need to do is to change, in the information sections of the minimal trellis, the standard convention to that where solid branches refer to the information bit 0 and the dashed branches refer to the information bit 1. Let us refer to this convention as the systematic convention. Getting back to the minimal trellis in Figure1, for the nonsystematic nonrecursive convolutional encoding matrix G(D) given in (8), we only need to adopt the systematic convention in the first three sections to turn this minimal trellis into a systematic trellis.

It remains to show that the minimal trellis in Figure1 with the systematic convention is the minimal trellis for the systematic recursive convolutional encoding matrix G_sys(D) in (6). We note that the generator matrices G(D) given in (8) and G_sys(D) in (6) are equivalent in the sense that both generate the same code. Therefore, except for the edge convention, the two trellises are exactly the same. Assuming that the information bits at the input of the encoder associated with G_sys(D) and the information bits associated with the minimal trellis in Figure1 occupy the same positions, the systematic convention is unique. Consequently, the trellis in Figure1 with the systematic convention in the first three sections is the minimal trellis for the systematic recursive convolutional encoding matrix G_sys(D) in (6).

The complete algorithm for the construction of the minimal trellis for a systematic recursive encoding matrix is summarized as:

• 1. From G _sys(D), use the Smith form decomposition procedure to obtain the basic nonsystematic nonrecursive encoding matrix G _b (D);

• 2. If G _b(D) does not have the LR property, then apply the greedy algorithm described in [15] to turn it into a LR form. Denote the new generator matrix by G(D). Else set G(D) ← G _b(D);

• 3. Construct the minimal trellis module for G(D) with the method presented in [6];

• 4. Adopt the systematic convention on the minimal trellis module obtained in the previous step. The resulting trellis is the desired systematic trellis.

Example 2

Consider the following systematic recursive (n,k,ν) = (5,4,3) encoder matrix from[1, TableIV] with TC(Φ _conv ) = 160 symbols per bit

$$G_{\text{sys}}(D)=\left(\begin{array}{ccccc}1& 0& 0& 0& \frac{1+D+D^2+D^3}{1+D+D^3}\\ 0& 1& 0& 0& \frac{1+D+D^2}{1+D+D^3}\\ 0& 0& 1& 0& \frac{1+D^2+D^3}{1+D+D^3}\\ 0& 0& 0& 1& \frac{1+D^3}{1+D+D^3}\end{array}\right).$$

Using the procedure described in Section 3 we construct the “minimal” trellis shown in Figure2. This module has state and branch complexity profiles given by$\stackrel{\mathit{~}}{\mathit{\nu }}=(3,4,4,4,4)$ and$\stackrel{\mathit{~}}{\mathit{b}}=(1,1,1,1,0)$, respectively. Thus, TC(Φ _min ) = 32 symbols per bit.

Figure 2

Minimal trellis module for the ( n , k , ν ) = (5,4,3) systematic recursive encoder. Solid/blue branches represent “0” codeword bits while dashed/red branches represent “1” codeword bits. The same convention (i.e., the systematic convention) applies to the first four trellis sections.

4 New codes

Graell i Amat et al.[1] tabulated good k × (k + 1) encoding matrices G_sys(D) to be used as component encoders of parallel concatenated turbo codes. We search for good (with respect to the pair (d _i ,N _i ) constituent systematic recursive convolutional encoder matrices with a larger variety of complexities compared to those listed in[1]. The main idea is to propose templates with polynomial generator matrix G(D) in trellis-oriented form[6, 7] with fixed TC(Φ _min ). This can be done by placing the leading (underlined) and trailing (overlined) 1’s of each row of the “matrix module” in specific positions, leaving the other positions free to assume any binary value.

Example 3

The following “matrix module”

$$\left(\begin{array}{cccc}\overline{1}& 0& 0& 0\\ \ast & \ast & \ast & \overline{1}\\ \ast & \overline{1}& 0& 0\\ \underset{\_}{1}& \ast & \ast & \ast \\ 0& \underset{\_}{1}& \ast & \ast \\ 0& 0& \underset{\_}{1}& \ast \end{array}\right)$$

is associated with an ensemble of nonsystematic nonrecursive convolutional codes of rate 3/4 and trellis complexity of the minimal trellis module TC(Φ _min ) = 21. 33 symbols per bit.

Remark

In our code search we enforce that the positions of the underlined 1’s are in the first k columns of the matrix module in order to assure that the information bits of the corresponding minimal trellis are in the first k sections. □

By varying the free positions (marked with an “*”) in this matrix, several polynomial generator matrices G(D) are produced. For each matrix G(D) in this ensemble, we apply Steps (3) and (4) of the algorithm, i.e., we construct the minimal trellis module for G(D) and adopt the systematic convention to the information sections, and then calculate the pairs (d _i ,N _i ), for i = 2,…,6. The dominant term, d₂, is called the effective free distance of the turbo code[16].

Codes of rate R = 2/4,3/4,3/5,4/5 are listed in Table1, which indicates the relationship between TC(Φ _min ) and the error performance expressed in terms of the pairs (d _i ,N _i ). The matrix G(D) shown in the table together with the systematic convention is used to construct the minimal trellis that attains the corresponding (d _i ,N _i ), i = 2,…,6. The existing codes taken from[1] are also indicated in Table1. Their (minimal) trellis complexity, shown in the table, was obtained by applying the complete algorithm of Section 3.2 to their respective systematic recursive encoding matrices. For example, the matrices G _sys (D) listed in[1, Table IV] for R = 3/4 yield TC(Φ _min ) = 10. 67 (for ν = 2), TC(Φ _min ) = 32 (for ν = 3) and TC(Φ _min ) = 64 (for ν = 4). New codes with a variety of trellis complexities are found with our code search procedure. The effective free distance and/or multiplicity of the code are gradually improved as more complex codes are sought.

Table 1 Minimal trellis complexity-performance trade-off for R = 2/4,3/4,3/5,4/5

5 Conclusions

We present a method to construct the minimal trellis for a recursive systematic convolutional encoding matrix. Such a trellis minimizes the trellis complexity measure introduced by McEliece and Lin[6], which applies to trellis-based decoding algorithms. As a contribution of this work, several new convolutional encoding matrices having an equivalent systematic recursive encoding matrix, optimized for turbo codes, are tabulated. They provide a wide range of performance-complexity trade-offs, to serve several practical applications.

Endnotes

^aThis work was presented in part at the IEEE International Symposium on Information Theory (ISIT 2011), Saint Petersburg, Russia, July 2011.