Trellis-Based Check Node Processing for Low-Complexity Nonbinary LP Decoding

# Trellis-Based Check Node Processing for Low-Complexity Nonbinary LP Decoding

Mayur Punekar and Mark F. Flanagan
Claude Shannon Institute,
University College Dublin, Belfield, Dublin 4, Ireland.
{mayur.punekar, mark.flanagan}@ieee.org
###### Abstract

Linear Programming (LP) decoding is emerging as an attractive alternative to decode Low-Density Parity-Check (LDPC) codes. However, the earliest LP decoders proposed for binary and nonbinary LDPC codes are not suitable for use at moderate and large code lengths. To overcome this problem, Vontobel et al. developed an iterative Low-Complexity LP (LCLP) decoding algorithm for binary LDPC codes. The variable and check node calculations of binary LCLP decoding algorithm are related to those of binary Belief Propagation (BP). The present authors generalized this work to derive an iterative LCLP decoding algorithm for nonbinary linear codes. Contrary to binary LCLP, the variable and check node calculations of this algorithm are in general different from that of nonbinary BP. The overall complexity of nonbinary LCLP decoding is linear in block length; however the complexity of its check node calculations is exponential in the check node degree. In this paper, we propose a modified BCJR algorithm for efficient check node processing in the nonbinary LCLP decoding algorithm. The proposed algorithm has complexity linear in the check node degree. We also introduce an alternative state metric to improve the run time of the proposed algorithm. Simulation results are presented for and nonbinary LDPC codes over .

## I Introduction

Binary and nonbinary LDPC codes [1] have attracted much attention in the research community in the past decade. LDPC codes are generally decoded by the iterative BP algorithm which performs remarkably well at moderate SNR levels. Due to their capacity achieving performance, LDPC codes are used in many current communications systems. They are also a promising candidate for future high data rate communication systems as well as for memory applications. However, BP suffers from a so called error floor problem at high SNR. Also, the heuristic nature of BP makes it difficult to analyze, and simulations are too time consuming for the prediction of the error floor.

In recent years, the new approach of LP decoding is emerging as an attractive alternative to the BP decoding. LP decoding for binary LDPC codes was proposed by Feldman et al. [2]. In LP decoding, the maximum likelihood decoding problem is modeled as an LP problem. In contrast to BP decoding, LP decoding relies on a well studied branch of mathematics which provides a basis for better understanding of the decoding algorithms. The work of [4] extended the LP decoding framework of Feldman et al. to nonbinary linear codes. Binary and nonbinary LP decoding algorithms rely on standard LP solvers based on simplex or interior point methods. However, the time complexity of these solvers is known to be exponential in number of variables, which limits the use of LP decoding to codes of small block length. To decode longer codes, a specialized low complexity LP decoding algorithm is necessary. Such a low-complexity algorithm for binary LDPC codes was proposed by Vontobel et al. in [3]. The present authors, in [5], extended the binary LCLP decoding algorithm [3] to nonbinary codes. The complexity of the proposed nonbinary LCLP decoding algorithm is linear in the block length. As opposed to binary LCLP decoding, nonbinary LCLP decoding is not directly related to nonbinary BP. Due to this, the complexity of the check node calculations of nonbinary LCLP decoding is exponential in the maximum check node degree. In this paper, we propose a modified BCJR algorithm for the check node processing of nonbinary LCLP decoding. The proposed algorithm has complexity linear in the check node degree and allows for efficient implementation of nonbinary LCLP decoding. We also propose an alternative state metric which can be used for faster check node processing.

This paper is organized as follows. Notation and background information is given in Section II. Section III reviews the nonbinary LCLP decoding algorithm from [5]. Section IV contains the modified BCJR algorithm for check node processing and also explains the alternative state metric. Section V presents the simulation results, and Section VI concludes the paper.

## Ii Notation and Background

Let be a finite ring with elements with as its additive identity. We define . Let be a linear code of length over the ring , defined by , where is a parity-check matrix with entries from . is the rate of code . Hence, the code is an linear code over . The row indices and column indices of are denoted by the sets and respectively. The -th row of is denoted by and the -th column of is denoted by . supp denotes the support of the vector . For each , let and for each , let . Also let and . We define the set . Moreover for each we define the local Single Parity Check (SPC) code

 Cj=⎧⎨⎩(bi)i∈Ij:∑i∈Ijbi⋅Hj,i=0⎫⎬⎭

For each , denotes the repetition code of the appropriate length and indexing. We also use variables and for all , ; also for , and similarly for , .

We use the following mapping given in [4],

 ξ:R→{0,1}q−1⊂Rq−1

by

 ξ(α)=x=(x(ρ))ρ∈R−

such that, for each

 x(ρ)={1,ifρ=α0,otherwise

We extend this mapping to define

where,

 Ξ(c)=(ξ(c1),…,ξ(ct)),∀c∈Rt,t∈Z+.

For , we define the function and its inverse We also use the soft-minimum operator introduced in [3]. For any , , the soft-minimum operator is defined as

 minl(κ){zl}≜−1κlog(∑le−κzl)=−ψ−1(∑lψ(−zl))

where with equality attained in the limit as .

We assume transmission over a -ary input memoryless channel and also assume a corrupted codeword has been received. Here, the channel output symbols are denoted by . Based on this, we define a vector where, for each , ,

 λ(α)=log(p(y|0)p(y|α)).

Here denotes the channel output probability (density) conditioned on the channel input.

## Iii Low Complexity LP Decoding of Nonbinary Linear Codes

To develop a low complexity LP solver for nonbinary linear codes, the present authors in [5] proposed a primal LP formulation which is equivalent to the original LP formulation proposed in [4]. This primal LP formulation has an advantage that, it has one-to-one corresponding with the Forney-style factor graph of the code and can be used to derive a suitable dual LP (see section IV in [5]). The dual LP is then “softened” by using the “soft-min” operator which is used to derive the update equations given in Lemma 6.1 in [5]. The softened dual LP is given below.

 SDNBLPD: max. ∑i∈I^ϕi+∑j∈J^θj Subject to ^ϕi ≤ ^θj ≤ ^ui,j = −^vj,i((i,j)∈E), ^ui,0 = −^fi(i∈I), ^fi = λi(i∈I).

The update equation can be used to update the dual variable related to an edge while all other edge variables are held constant. The updated value of the is given by

 ¯u(α)i,j=12((Vi,¯α−Vi,α)−(Cj,¯α−Cj,α))

where,

 Vi,¯α≜−mina∈Aiaj≠α(κ)⟨−^ui,Ξ(a)⟩, Vi,α≜−mina∈Aiaj=α(κ)⟨−~ui,Ξ(~a)⟩, Cj,¯α≜−minb∈Cjbi≠α(κ)⟨−^vj,Ξ(b)⟩, Cj,α≜−minb∈Cjbi=α(κ)⟨−~vj,Ξ(~b)⟩.

Here the vector is the vectors where the subvector is excluded. Similarly vector is obtained by excluding the subvector from . Vector is same as where the -th position is omitted and vector is obtained by excluding the -th position from . Now by updating all the edges with some schedule (e.g. circular), the low-complexity LP decoding algorithm converges to the maximum of the SDNBLPD. (see Lemma 6.2 in [5]). The overall complexity of this algorithm is linear in the block length.

The terms are related to the variable node (VN) and check node (CN) respectively. In the binary case, these terms can be efficiently calculated with the VN and CN calculations of the binary Sum-Product (SP) algorithm respectively [3]. However, for nonbinary codes, the calculation of is not related to the VN and CN calculations of the nonbinary SP algorithm [5]. Hence, the CN calculations are carried out by processing exhaustively all of the possible codewords of the SPC code . Consequently, the complexity of calculating (i.e of CN calculation) is in exponential in the maximum check-node degree .

## Iv Modified BCJR algorithm for Check Node calculation of the Low Complexity LP Decoding

In [5], the authors suggested that the equations for and can be rewritten as follows:

 ψ(Cj,¯α)=∑b∈Cjbi≠αψ(⟨^vj,Ξ(b)⟩) (1) ψ(Cj,α)=∑b∈Cjbi=αψ(⟨~vj,Ξ(~b)⟩) (2)

It may be observed from the above equations that the calculation of the is in the form of the marginalization of a product of functions. Hence it is possible to compute with the help of a trellis based variant of the SP algorithm (i.e. BCJR-type algorithm). One possibility is to use the trellis of the binary nonlinear code . However, due to nonlinear nature of this binary code, the state complexity at the center of its trellis would be exponential in . Here state merging is also not possible. Hence there is no complexity advantage when we use the trellis of the binary nonlinear code .

However if the trellis for the nonbinary SPC code is used, then the state complexity at each trellis step is and is independent of . The branch complexity of this trellis is . In the following, we prove that the marginals and can be efficiently calculated with some modifications to the BCJR algorithm which uses the trellis of the nonbinary code . For this purpose we define the following for the trellis of the SPC code :

1. The set of all states at time

2. represents a branch in the trellis which is related to the symbol .

3. Since we have trellis for SPC code, each state represents the sum of all symbols from to .

4. We define

 σ(i,j)=r=j∑r=ibr,b∈Cj.
5. Branch metric for each is .

6. State metric for forward recursion,

 μi(s)=∑(b0,⋯,bi−1)σ(0,i−1)=si−1∏t=0g(bt),s∈Si,i∈Ij (3) with μ0(0)=1,μ0(α)=0,∀α∈R−.

and state metric for backward recursion,

 νi(s)=∑(bi,⋯,bdj−1)σ(i,dj−1)=sdj−1∏t=ig(bt),s∈Si,i∈Ij (4) with νdj(0)=1,νdj(α)=0,∀α∈R−.
###### Lemma IV.1

and can be efficiently computed on the trellis of the nonbinary code as follows,

 ψ(Cj,¯α)=∑(s,s′)∈(Si,Si+1)s′−s≠αμi(s)⋅νi+1(s′)⋅g(s′−s) (5) ψ(Cj,α)=∑(s,s′)∈(Si,Si+1)s′−s=αμi(s)⋅νi+1(s′) (6)

where state metrics and are calculated recursively from previous state metrics via

 μi(s) =∑bi−1∈Rμi−1(s−bi−1)⋅g(bi−1), νi(s) =∑bi∈Rνi+1(s−bi)⋅g(bi).
{proof}

First we prove that the state metrics can be computed recursively. The following may be observed from the definition of ,

 μi(s)=∑(b0,⋯,bi−1)σ(0,i−1)=si−1∏t=0g(bt) =∑(b0,⋯,bi−1)σ(0,i−2)+bi−1=s(i−2∏t=0g(bt))⋅g(bi−1) =∑bi−1∈R⎛⎜ ⎜ ⎜ ⎜⎝∑(b0,⋯,bi−2)σ(0,i−2)=s−bi−1i−2∏t=0g(bt)⎞⎟ ⎟ ⎟ ⎟⎠⋅g(bi−1) =∑bi−1∈Rμi−1(s−bi−1)⋅g(bi−1)

Hence can be calculated recursively from the previous state metrics. Similarly, we can prove that the can be calculated from previous state metrics.

Now we prove the other part of the lemma. For ease of exposition we assume in the following.

 ψ(Cj,¯α) =∑b∈Cjbi≠αψ(⟨^vj,Ξ(b)⟩) =∑b∈Cjbi≠αψ⎛⎝dj−1∑t=0(⟨^vj,t,ξ(bt)⟩)⎞⎠ =∑b∈Cjbi≠α⎛⎝dj−1∏t=0ψ(⟨^vj,t,ξ(bt)⟩)⎞⎠
 ⇒ψ(Cj,¯α)=∑b∈Cjbi≠α⎛⎝dj−1∏t=0g(bt))⎞⎠ (7)

The right-hand side of (5) is,

 ∑(s,s′)∈(Si,Si+1)s′−s≠αμi(s)⋅νi+1(s′)⋅g(s′−s) =∑(s,s′)∈(Si,Si+1)s′−s≠α⎛⎜ ⎜ ⎜⎝∑(b0,⋯,bi−1)σ(0,i−1)=si−1∏t=0g(bt)⎞⎟ ⎟ ⎟⎠ =∑(s,s′)∈(Si,Si+1)s′−s≠α∑(b0,⋯,bi−1,bi+1,⋯,bdj−1)σ(0,i−1)=s,σ(i+1,dj−1)=s′ ⎛⎝i−1∏t=0g(bt)⋅dj−1∏t=i+1g(bt)⎞⎠⋅g(bi)
 ⇒∑(s,s′)∈(Si,Si+1)s′−s≠α μi(s)⋅νi+1(s′)⋅g(s′−s) =∑b∈Cjbi≠α⎛⎝dj−1∏t=0g(bt)⎞⎠ (8)

Using (8) in (7) we get (5). Equation (6) can be proved in a similar manner.

The overall algorithm works in two phases: in the first phase, the forward and backward state metrics are calculated and stored; in the second phase the marginals and are computed with Lemma IV.1 where the state metrics computed in first phase are utilized. It may be observed that the aforementioned algorithm is essentially the same as the BCJR algorithm except for the second phase where marginals are calculated.

The calculations of the Lemma IV.1 can be visualized with the help of the trellis diagram. Figures 2 and 2 shows the trellis for the nonbinary SPC code of length which is defined over . to represent the symbols, and states are represented by , where indicates the symbol after which the state occurs and represents the sum of the symbols from to . The dotted branches in Figure 2 represents the transitions related to the symbol . The state pairs which are connected by these branches are used for the calculation of the . Similarly, the dotted branches in Figure 2 represent transitions related to the symbol . Here the metrics of the corresponding state pairs are used for the calculation for the .

### Iv-a Alternative State Metric for Faster Calculation of Cj,¯α

The forward state metric as defined in (3) needs to be computed for the calculation of and can be reused for the calculation of . In (5) the algorithm needs to go through all branches for the calculation of . If the proposed algorithm is implemented in hardware or on multicore architectures, then the computation time for can be reduced by parallelizing its calculation. One possibility to parallelize calculation of is to define a new forward state metric , which can be computed in parallel with in the first phase and reduces the calculations required during the second phase of the algorithm. For this we define an alternative forward state metric as follows,

 ¯μi(s,α)=∑(b0,⋯,bi−1)σ(0,i−1)=s,bi−1≠αi−1∏t=0g(bt),s∈Si,i∈Ij,α∈R− (9)

It should be noted that due to the condition , cannot be calculated recursively from ; instead it is calculated together with from as follows,

 ¯μi(s,α)=∑bi∈R∖{α}μi−1(s−bi)⋅g(bi)

With the help of the alternative forward state metric given in equation (9), the expression (5) of Lemma IV.1 can be rewritten as

 ψ(Cj,¯α)=∑s′∈Si+1¯μi+1(s′,α)⋅νi+1(s′) (10)

The forward state metric requires the calculation and storage of an additional values for each state during the first phase. Hence the storage requirement for the calculation of with (10) increases by a factor of . However, all additional state metric values can be calculated in parallel with which does not effect the run time of the first phase of the algorithm. Also, the second phase of the algorithm needs to go through only states instead of branches, hence the overall run time for computing is reduced with the state metric .

### Iv-B Calculation of Marginals with κ→∞

In Lemma IV.1, is assumed to be finite. However, for many practical applications we are interested in . According to Lemma 6.3 of [5], for we again need to calculate to update the corresponding variables. However, the marginals and are here obtained as the limit of equation (2) and (1) respectively as , i.e.,

 Cj,α≜−minb∈Cjbi=α⟨−~vj,Ξ(~b)⟩,Cj,¯α≜−minb∈Cjbi≠α⟨−^vj,Ξ(b)⟩ (11)

Thus and can be obtained by replacing all “product” operations with “sum” operations and similarly by replacing all “sum” operations with “min” operations in (2) and (1) (marginals with finite ). In (2) and (1) the marginalization is performed in the sum-product semiring. However for the marginalization is performed in the min-sum semiring and hence the marginals of (11) can be computed with a trellis based variant of the min-sum algorithm. If we redefine the branch metric as and replace all “product” operations with “sum” operations and similarly replace all “sum” operations with “min” operations in equation (3), (4), (6), (9) and (10) then the resulting equations can be used on the trellis of the nonbinary SPC code to compute the marginals of (11). This trellis based variant of the min-sum algorithm is related to the Viterbi algorithm.

## V Results

This section presents simulation results for low complexity LP decoding which uses the trellis based check node calculations described above. We consider for all simulations. We use the binary and MacKay LDPC codes, but with parity-check matrix entries taken from instead of . These LDPC codes are -regular codes; hence there are nonzero entries in each row of their parity-check matrix. We set the second and third nonzero entry in each row to , and all other nonzero entries are set to 1. Furthermore, we assume transmission over the AWGN channel where nonbinary symbols are directly mapped to quaternary phase-shift keying (QPSK) signals. We simulate up to frame errors per simulation point.

The error-correcting performance of the and LDPC code is shown in Figure 3 where the frame error rate (FER) of the LCLP decoding algorithm is compared with that of the min-sum (MS) algorithm. The MS algorithm also uses the trellis of the nonbinary SPC code for check node processing. The maximum number of iterations is set to for both decoding algorithms. For the code, the FER of low complexity LP decoding is within dB from that of MS algorithm and for code, it is within dB. These results are comparable to that of the binary LCLP decoding algorithm of [3]. Finally, it is important to note that these LDPC codes are significantly longer then the quaternary (80, 48) LDPC code tested in [5].

## Vi Conclusion

In this paper, we proposed a modified BCJR algorithm for efficient check node processing in the nonbinary LCLP decoding algorithm. The proposed algorithm has complexity linear in the check node degree. We also proposed an alternative state metric which can be used to reduce the run time of the proposed algorithm.

## Vii Acknowledgments

The authors would like to thank P. O. Vontobel for many helpful suggestions and comments. This work was supported in part by the Claude Shannon Institute, UCD, Ireland.

## References

• [1] M. C. Davey and D. J. C. MacKay, “Low density parity check codes over ,” IEEE Communication Letters, vol. 2, no. 6, pp. 165–167, June 1998.
• [2] J. Feldman, M. J. Wainwright and D. R. Karger, “Using linear programming to decode binary linear codes,” IEEE Transactions on Information Theory, vol. 51, no. 3, pp. 954–972, March 2005.
• [3] P. O. Vontobel and R. Koetter, “Towards low-complexity linear-programming decoding,” in Proc. of 4th International Conference on Turbo Codes and Related Topics, Munich, Germany, April 3–7, 2006.
• [4] M. F. Flanagan, V. Skachek, E. Byrne, and M. Greferath, “Linear-Programming Decoding of Nonbinary Linear Codes,” IEEE Transactions on Information Theory, vol. 55, no. 9, pp. 4134–4154, September 2009.
• [5] M. Punekar and M. F. Flanagan, “Low Complexity LP Decoding of Nonbinary Linear Codes,” The Forty-Eighth Annual Allerton Conference on Communication, Control, and Computing, September 29 – October 1, 2010.
You are adding the first comment!
How to quickly get a good reply:
• Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
• Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
• Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters