Improved progressive edge-growth algorithm for fast encodable LDPC codes

Abstract

The progressive edge-growth (PEG) algorithm is known to construct low-density parity-check (LDPC) codes at finite code lengths with large girths by establishing edges between symbol and check nodes in an edge-by-edge manner. The linear-encoding PEG (LPEG) algorithm, a simple variation of the PEG algorithm, can be applied to generate linear time encodable LDPC codes whose m parity bits p₁, p₂, ..., p _m are computed recursively in m steps. In this article, we propose modifications of the LPEG algorithm to construct LDPC codes whose number of encoding steps is independent of the code length. The maximum degree of the symbol nodes in the Tanner graph is denoted by $d_s^{\mathsf{\text{max}}}$; The m parity bits of the proposed LDPC codes are divided into $d_s^{\mathsf{\text{max}}}$ subgroups and can be computed in only $d_s^{\mathsf{\text{max}}}$ steps. Since $d_s^{\mathsf{\text{max}}}\ll m$, the number of encoding steps can be significantly reduced. It has also been proved that the PEG codes and the codes proposed in this article have similar lower bound on girth. Simulation results showed that the proposed codes perform very well over the AWGN channel with an iterative decoding.

1 Introduction

Low-density parity-check (LDPC) codes, which were first proposed in the early 1960's [1] and re-discovered in 1996 [2], have recently attracted much attention due to their capacity-approaching performance and low decoding complexity. Since their re-discovery, there are many methods such as the message-passing decoding and the linear program decoding [3, 4] that have been proposed for the decoding algorithm. Also many other methods have been proposed for the construction algorithm [5–8]. Among the existing methods, the most successful approach for the construction of LDPC codes is the progressive-edge-growth (PEG) algorithm [5, 6]. The PEG construction builds up a Tanner graph, equivalent to a parity-check matrix, for an LDPC code in an edge-by-edge manner and maximizes the local girth at symbol nodes in a greedy algorithm. It is simple and flexible in that it can be applied in constructing codes of arbitrary length and rate. In addition, the PEG algorithm can be modified to construct linear time encodable LDPC codes. In this article, this modified algorithm is referred to as linear-encoding PEG (LPEG) algorithm. Initially, the parity-check matrix was used in decoding process for LDPC codes. But it can also be used for the encoding of LDPC codes [9]. LDPC codes with m parity bits constructed by the LPEG algorithm can be encoded with the parity-check matrix in m recursive steps [6]. Therefore, for a given code rate R, the number of encoding steps of LPEG codes grows linearly with the code length n = m/(1-R).

The objective of this article is to reduce the number of encoding steps of the LPEG codes with negligible performance loss. To reduce the number of encoding steps, we modified the LPEG algorithm to obtain two new algorithms which are referred to as fast-encoding PEG (FPEG) algorithm and modified FPEG (MFPEG) algorithm, respectively. $d_s^{\mathsf{\text{max}}}$ is used to denote the maximum degree of symbol nodes. The number of encoding steps of the FPEG codes grows linearly with $d_s^{\mathsf{\text{max}}}$, but not the code length n. The number of encoding steps of the MFPEG codes grows linearly with $\left(d_s^{\mathsf{\text{max}}}+⌊\frac{m}{d_s^{\mathsf{\text{max}}}}⌋-1\right)$. Since $d_s^{\mathsf{\text{max}}}$ is much smaller than m, the number of encoding steps of FPEG codes or MFEPG codes is lower than that of the LPEG codes. Moreover, to ensure that there is negligible performance loss, we proved that the PEG codes and our codes had similar lower bound on girth. This was confirmed by providing examples of the proposed codes and comparing their performance with that of the multiple serially concatenated multiple parity-check (M-SC-MPC) code, which is a class of LDPC codes of efficient encoding [10].

The remainder of this article is organized as follows. Section 2 reviews the PEG algorithm and the LPEG algorithm. Section 3 proposes the FPEG algorithm and the MFPEG algorithm. A lower bound on the girth of the FPEG algorithm is also derived in this section. Section 4 presents two examples of FPEG codes and MFPEG codes and demonstrates their performances. Finally, Section 5 concludes the article.

2 Preliminary

2.1 Progressive edge-growth algorithm

An LDPC code is a linear block code defined by a sparse parity-check matrix H having dimension m × n. A bipartite graph with m check nodes in one class and n symbol nodes in the other can be created using H as the integer-valued incidence matrix for the two classes. Such a graph is also called a Tanner graph [11]. Let V _c = {c₀, c₁, ..., c _{m - 1}} denote the set of check nodes and V _s = {s₀, s₁, ..., s _{n- 1}} denote the set of symbol nodes. E is the set of edges such that E ⊆ V _c × V _s , with edge (c _i , s _j ) ∈ E if and only if h _i,j ≠ 0, where h _i,j denotes the entry of H at the i th row and j th column, 0 ≤ i ≤ m - 1, 0 ≤ j ≤ n - 1. The PEG algorithm for constructing a Tanner graph with n symbol nodes and m check nodes is described in Algorithm 1. In this algorithm, both symbol nodes and check nodes are ordered according to their degrees in a nondecreasing order. $d_{s_j}$ is the degree of symbol node $s_j,N_{s_j}^l$, and ${\bar{N}}_{s_j}^l$ denote the set of all check nodes reached by a tree spreading from symbol node s _j with in depth l, and its complement, respectively [6]. It was proved that [4] the PEG algorithm constructs Tanner graphs having a large girth and the lower bound on the girth was proved to be

Algorithm 1. PEG algorithm

1:   for j = 0 to n - 1 do

2:      for k = 0 to $d_{s_j}-1$do

3:         if k = 0 then

            $E_{s_j}^0$ ← edge (c _i , s _j ), where $E_{s_j}^0$ is the first edge incident to s _j and c _i is a check node such that it has the lowest check-node degree under the current graph setting $E_{s_0}\cup E_{s_1}\cup \cdots \cup E_{s_{j-1}}$.

4:         else

               expand a subgraph from s _j up to depth l under the current graph setting such that the cardinality of $N_{s_j}^l$ stops increasing but is less than m, or ${\bar{N}}_{s_j}^{l+1}\ne \varnothing$ but ${\bar{N}}_{s_j}^{l+1}\ne \varnothing$, then $E_{s_j}^k\leftarrow \mathsf{\text{edge}}\left(c_i,s_j\right)$, where $E_{s_j}^k$ is the k th edge incident on s _j and c _i is a check node picked from ${\bar{N}}_{s_j}^l$ having the lowest check-node degree.

5:            end if

6:         end for

7:      end for

$$g_P\ge 2\left(⌊\frac{\mathsf{\text{log}}\left(m{d}_c^{\mathsf{\text{max}}}-\frac{m{d}_c^{\mathsf{\text{max}}}}{d_s^{\mathsf{\text{max}}}}-m+1\right)}{\mathsf{\text{log}}\left[\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)\right]}-1⌋+2\right),$$

(1)

where $d_c^{\mathsf{\text{max}}}$ and $d_s^{\mathsf{\text{max}}}$ were the maximum degrees of the check nodes and symbol nodes, respectively.

2.2 Linear-encoding PEG algorithm

It is stated [12] (Corollary 4) that if a parity-check matrix H can be transformed into an upper or lower triangular matrix by row and column permutations, the corresponding LDPC code can be encoded in linear number of steps. Obviously, the PEG algorithm can also be tailored to construct a parity-check matrix H having upper triangular structure. The code word C and the parity-check matrix H are partitioned into C = [p, d] and H = [H^p, H^d], respectively, such that

$$\left[H^p,H^d\right]C^T=0,$$

(2)

where the m × m component $H^p=h_{i,j}^p$ of the parity-check matrix is forced to have the upper

triangular form

$$H^p=\left(\begin{array}{ccccc}\hfill 1\hfill & \hfill h_{1,2}^p\hfill & \hfill \cdots \hfill & \hfill \cdots \hfill & \hfill h_{1,m}^p\hfill \\ \hfill 0\hfill & \hfill 1\hfill \\ \hfill ⋮\hfill & \hfill ⋮\hfill & \hfill \ddots \hfill & \hfill ⋮\hfill & \hfill ⋮\hfill \\ \hfill 0\hfill & \hfill 1\hfill & \hfill h_{m-1,m}^p\hfill \\ \hfill 0\hfill & \hfill \cdots \hfill & \hfill 0\hfill & \hfill 0\hfill & \hfill 1\hfill \end{array}\right)$$

(3)

in which h _ij = 1 for i = j. Hence, the parity bits p = [p_l, p₂, ..., p _m ] can be computed according to

$$p_i=\left(\sum _{j=i+1}^m{h}_{i,j}^p{p}_j\oplus \sum _{j=1}^{n-m}{h}_{i,j}^d{d}_j\right)$$

(4)

where d = {d _i } is the systematic part of the code, $H^d=\left\{h_{i,j}^d\right\}$ is the m × (n-m) component of the partitioned parity-check matrix H and ⊕ represents the summation over binary field, i.e., an XOR operation. From Equation (4), the m parity bits can be computed from p _m to p₁ serially in m steps. Therefore, the number of encoding steps is

$$T_L=m.$$

(5)

Accordingly, the symbol node set V _s in the Tanner graph is partitioned into redundant subset $V_s^p$ and the information subset $V_s^d$, which contain the first m symbol nodes and the other n - m symbol nodes, respectively. The edges of the symbol nodes are then established by means of the LPEG algorithm which constructs an upper triangular pattern. As the procedure of establishing the edges of n - m information bits follows the construction of edges of $V_s^p$ and is exactly the same as the PEG algorithm described in Algorithm 1, only the LPEG algorithm for constructing edges of $V_s^p$ is shown in Algorithm 2.

Algorithm 2. LPEG algorithm for Establishing Edges of $V_s^p$

1:for j = 0 to m - 1 do

2:      for k= 0 to $d_{s_j}-1$do

3:         if k = 0 then

            $E_{s_j}^0\leftarrow \mathsf{\text{edge}}\left(c_j,s_j\right)$, where $E_{s_j}^0$ is the first edge incident to s _j . This edge corresponds to the "1" in the diagonal line of matrix H^p.

4:         else

            expand a subgraph from s _j up to depth l under the current graph setting such that ${\bar{N}}_{s_j}^l\cap \left\{c_0,c_1,\dots ,c_{j-1}\right\}\ne \varnothing$ but ${\bar{N}}_{s_j}^{l+1}\cap \left\{c_0,c_1,\dots ,c_{j-1}\right\}=\varnothing$, or the cardinality of $N_{s_j}^l$ stops increasing, then $E_{s_j}^k\leftarrow \mathsf{\text{edge}}\left(c_i,s_j\right)$, where $E_{s_j}^k$ is the k th edge incident to s _j and c _i is a check node picked from the set ${\bar{N}}_{s_j}^l\cap \left\{c_0,c_1,\dots ,c_{j-1}\right\}$ having the lowest check-node degree.

5:         end if

6:      end for

7:   end for

Note that the first column of H^pcorresponds to a degree-1 symbol node and the fraction of degree-1 symbol node is 1/n. It was proved that the Tanner graph of an upper or lower triangular parity-check matrix could be equivalently transformed into a pseudo-tree and the corresponding LDPC codes could also be encoded in a linear number of steps by the label-and-decide algorithm [12].

2.3 M-SC-MPC codes

Let n _i , ki, and r _i denote the code length, information length and parity-check length of the i th component MPC code, respectively. The encoder of each component MPC code can be implemented as r _i SPC encoders as shown in Figure 1[10]. The matrix cells of the i th encoder are filled in column-wise order from top left to bottom right. The first r _i - s _i cells, with s _i = k mod r _i , are unused. When the j th row is filled, j = 1, ..., r _i , the parity bit p _j is calculated by XORing the elements of the row, and its value is stored in the last column, at the same row. Each component MPC code can be seen as a shortened version of a binary cyclic code with length $N_i=⌈\frac{n_i}{r_i}⌉\cdot r_i\ge n_i$. We obtain a valid parity-check matrix H _i for the i th component code, consisting of a row of $⌈\frac{n_i}{r_i}⌉$ identity matrix with size r _i × r _i . As the i th component code has length n _i , the cyclic code must be shortened. This implied eliminating the first N _i - n _i columns of H _i . H _i forms a block-row of the parity-check matrix H of the serially concatenated code. Consequently, H was in the lower triangular form, consisting of identity matrices and zero matrices. The serially concatenated code has information length k, parity-check length $m={\sum }_{i=1}^M{r}_i$ and code length n = k + m.

Figure 1

Structure of M-SC-MPC encoder. The encoder of each component MPC code can be implemented as r _i SPC encoders.

3 FPEG algorithm and MFPEG algorithm

In general, an ensemble of Tanner graphs is defined through degree distribution pairs. In the case of the symbol nodes, the degree distribution, from the edge perspective, is given by

$$\psi \left(x\right)=\sum _{i\ge 1}^{d_s^{\mathsf{\text{max}}}}{\psi }_i{x}^i,$$

(6)

where ψ _i is the fraction of Tanner graph edges which emanate from degree-i symbol nodes. The fraction of degree-i symbol nodes, from the node perspective, is given by

$${\lambda }_i=\frac{{\psi }_i/i}{{\sum }_j{\psi }_j/j}.$$

(7)

Similarly, in the case of the check nodes, the degree distribution, from the edge perspective, is given by

$$\phi \left(x\right)=\sum _{i\ge 1}^{d_c^{\mathsf{\text{max}}}}{\phi }_i{x}^i,$$

(8)

where φ _i is the fraction of Tanner graph edges which emanate from degree-i check nodes. The fraction of degree-i check nodes, from the node perspective, is given by

$${\rho }_i=\frac{{\phi }_i/i}{{\sum }_j{\phi }_j/j}.$$

(9)

In the following section, we introduce an FPEG algorithm and an MFPEG algorithm used to construct an upper triangular parity-check matrix.

3.1 FPEG algorithm

Example 1: Consider the parity-check matrix in (10),

$$\begin{array}{c}H=\left[H^p,H^d\right]=\left(\begin{array}{c}\hfill H_1\hfill \\ \hfill H_2\hfill \\ \hfill H_3\hfill \end{array}\right)\\ =\left(\begin{array}{c}\hfill 100110101010\hfill \\ \hfill \frac{011001010101}{001010111000}\hfill \\ \hfill \frac{000101000111}{000010110100}\hfill \\ \hfill 000001001011\hfill \end{array}\right).\end{array}$$

(10)

This is a rate R = 0.5 and length n = 12 parity-check matrix that corresponds to an LDPC code C = [p₁, p₂, ..., p₆, d₁, d₂, ..., d₆], where d₁, d₂, ..., d₆ are the information bits and p₁, p₂, ..., p₆ are the parity bits. This is by no means a good LDPC code but it is an example. The parity-check matrix H in (10) can be divided into three 2 × 12 submatrices H₁, H₂ and H₃. In each submatrix H _i , the rows do not have '1's in the same column. Then, the encoding of C includes the following three steps:

Step 1 Given the submatrix H₃ and the information bits d₁, d₂, ..., d₆, compute the parity bits p₅, p₆ by the parity-check equations

$$\begin{array}{c}{p}_5=d_1\oplus d_2\oplus d_4,\\ p_6=d_3\oplus d_5\oplus d_6.\end{array}$$

(11)

Step 2 Given the submatrix H₂ and the information bits d₁, d₂, ..., d₆ and parity bits p₅, p₆, compute the check bits p₃, p₄ by the parity-check equations

$$\begin{array}{c}{p}_3=d_1\oplus d_2\oplus d_3\oplus p_5,\\ p_4=d_4\oplus d_5\oplus d_6\oplus p_6.\end{array}$$

(12)

Step 3 Given the submatrix H₁ and the information bits d₁, d₂, ..., d₆ and check bits p₃, p₄, p₅, p₆, compute the parity bits p₁, p₂ by the parity-check equations

$$\begin{array}{c}{p}_1=d_1\oplus d_3\oplus d_5\oplus p_4\oplus p_5,\\ p_2=d_2\oplus d_4\oplus d_6\oplus p_3\oplus p_6.\end{array}$$

(13)

It is easy to see that, in general, the number of encoding steps equals the number of submatrices, M. The parity-check matrix H should satisfy the following three conditions:

• (A) The parity-check matrix H should contain an upper triangular pattern.

• (B) The r _i rows in each submatrix H _i should not have '1's in the same column.

• (C) The number of submatrices should not be smaller than the maximum symbol-node degree $\left(M=d_s^{\mathsf{\text{max}}}\right)$.

Condition (A) guarantees that the corresponding codes are linear time encodable [12]. Condition (B) guarantees that the r _i parity-check equations in submatrix H _i can be used to generate r _i parity bits simultaneously [10, 13, 14] while condition (C) is a necessary condition for condition (B). Observing these three conditions, the Tanner graph of the parity-check matrix H can be constructed with the proposed FPEG algorithm.

Divide all the check nodes {c₀, c₁, ..., c_{m - 1}} into M separate check node groups G₁, G₂, ..., G _M where

$$G_i=\left\{c_{{\sum }_{j=1}^{i-1}{r}_j},\dots ,c_{{\sum }_{j=1}^i{r}_j-1}\right\}$$

(14)

and r₁, r₂, ..., r _M are M positive integers such that

$$r_1+r_2+\cdots +r_M=m.$$

(15)

Given a symbol-node-degree distribution, the FPEG algorithm for establishing edges of $V_s^p$ and $V_s^d$ is given in Algorithm 3. The symbol SC\G _i was used to denote the check nodes contained in the set of selectable check (SC) nodes, but not in the check node group G _i , where SC denote the set of check nodes available for the next round of spreading. The number of encoding steps of the FPEG codes, equaling the number of submatrices H _i , is

$$T_F=M\ge d_s^{\mathsf{\text{max}}}.$$

(16)

Algorithm 3. FPEG algorithm for establishing edges of $V_s^p$ and $V_s^d$

1: for j = 0 to n - 1 do

2:    if j < m then

3:       SC = {c₀, c₁, ..., c_j-1}.

4:    else

5:       SC = {c₀, c₁, ..., c_n-1}.

6:    end if

7:    for k = 0 to $d_{s_j}-1$do

8:       if k = 0 then

9:          if j < m then

      $E_{s_j}^0\leftarrow \mathsf{\text{edge}}\left(c_j,s_j\right)$, where $E_{s_j}^0$ is the first edge incident to s _j . This edge corresponds to the "1" in the diagonal line of matrix H^p.

10:          else

      $E_{s_j}^0\leftarrow \mathsf{\text{edge}}\left(c_j,s_j\right)$, where $E_{s_j}^0$ is the first edge incident to s _j and c _i is a check node such that it has the lowest check-node degree under the current graph setting $E_{s_0}\cup E_{s_1}\cup \cdots \cup E_{s_{j-1}}$.

11:          end if

12:       else

      expand a subgraph from s _j up to depth l under the current graph setting such that ${\bar{N}}_{s_j}^l\cap SC\ne \varnothing$ but ${\bar{N}}_{s_j}^{l+1}\cap SC=\varnothing$, or the cardinality of $N_{s_j}^l$ stops increasing, then $E_{s_j}^k\leftarrow \mathsf{\text{edge}}\left(c_i,s_j\right)$, where $E_{s_j}^k$ is the k th edge incident to s _j and c _i is a check node picked from the set ${\bar{N}}_{s_j}^l\cap SC$ having the lowest check-node degree.

13:       end if

14:       Find out which check node group G _i includes c _i . SC ← SC\G _i .

15:    end for

16: end for

Similar to the PEG algorithm, the check-node degrees are made as uniform as possible by the FPEG algorithm. Notice that the FPEG algorithm is not always valid for any given symbol-node-degree distribution. Since the column weight of H _i is at most one and the columns of H are ordered according to their weights in a nondecreasing order. The weight of first r₁ columns of H^pis at most one, that of the next r₂ columns is at most two, likewise the weight of the last r _M columns is at most M. In other words, the number of columns with weight less than or equal to i should be larger than or equal to ${\sum }_{j=1}^i{r}_j$. Therefore, the FPEG algorithm is valid if and only if

$$n\sum _{j=1}^i{\lambda }_j\ge \sum _{j=1}^i{r}_j,$$

(17)

for i ∈ {1, 2, ..., M}. When the condition (17) is satisfied, it was proved that, given a symbol-node-degree distribution, for large code lengths, the probability of failing to construct an approximate upper or lower triangular parity-check matrix was negligible [15] (Theorem 1).

Theorem 3.1 The lower bound on girth of the Tanner graph constructed by the FPEG algorithm is

$$g_F\ge 2\left(⌊\frac{\mathsf{\text{log}}\left(J{d}_c^{\mathsf{\text{max}}}-\frac{J{d}_c^{\mathsf{\text{max}}}}{d_s^{\mathsf{\text{max}}}}-J+1\right)}{\mathsf{\text{log}}\left[\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)\right]}-1⌋+2\right),$$

(18)

where ⌊⋅⌋ denotes the flooring operation,$J=r_{\mathsf{\text{min}}}\left(d_s^{\mathsf{\text{max}}}-1\right)+1$and r_minis the minimum of {r₁, r₂, ..., r _M }.

Proof: The proof of (18) is an adaptation of the proof of equation (1) reported in [6]. For a given symbol node s _j , define its neighborhood in G _k within depth $l,G_{k,s_j}^l$, as the set consisting of check nodes in G _k reached by a subgraph spreading from symbol node s _j . Its complementary set, ${Ḡ}_{k,s_j}^l$, is defined as $G_k\backslash G_{k,v_j}^l$. Consider a depth-l subgraph of an irregular Tanner graph which spreads from any symbol node s _j , s _j ∈ V _s , such that $G_{k,s_j}^l\subset G_k$ and $G_{k,s_j}^{l+1}=G_k$. By definition the depth-0 subgraph contains at most $d_s^{\mathsf{\text{max}}}$ check nodes, one of them is in G _k . Each of the $d_s^{\mathsf{\text{max}}}$ check nodes gives rise to at most $\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)$ check nodes in the next round of spreading. Thus, there are at most $d_s^{\mathsf{\text{max}}}\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)$ check nodes at depth 1, and $d_s^{\mathsf{\text{max}}}\left(d_c^{\mathsf{\text{max}}}-1\right)$ check nodes of them are in G _k . Similarly, there are at most $d_s^{\mathsf{\text{max}}}{\left(d_s^{\mathsf{\text{max}}}-1\right)}^l{\left(d_c^{\mathsf{\text{max}}}-1\right)}^l$ check nodes at depth l and $d_s^{\mathsf{\text{max}}}{\left(d_s^{\mathsf{\text{max}}}-1\right)}^{l-1}{\left(d_c^{\mathsf{\text{max}}}-1\right)}^l$ check nodes of them are in G _k . Let l' be the largest integer such that

$$\begin{array}{c}1+d_s^{\mathsf{\text{max}}}\left(d_c^{\mathsf{\text{max}}}-1\right)+\cdots \\ +d_s^{\mathsf{\text{max}}}{\left(d_s^{\mathsf{\text{max}}}-1\right)}^{l^{\prime }-1}{\left(d_c^{\mathsf{\text{max}}}-1\right)}^{l^{\prime }}<r_{\mathsf{\text{min}}}.\end{array}$$

(19)

From (19), it is easy to see that

$$\begin{array}{c}{d}_s^{\mathsf{\text{max}}}+d_s^{\mathsf{\text{max}}}\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)+\cdots \\ +d_s^{\mathsf{\text{max}}}{\left(d_s^{\mathsf{\text{max}}}-1\right)}^{l^{\prime }}{\left(d_c^{\mathsf{\text{max}}}-1\right)}^{l^{\prime }}\hfill \\ <r_{\mathsf{\text{min}}}\left(d_s^{\mathsf{\text{max}}}-1\right)+1,\hfill \end{array}$$

(20)

which can be simplified to

$$\begin{array}{c}\frac{d_s^{\mathsf{\text{max}}}\left[{\left(d_s^{\mathsf{\text{max}}}-1\right)}^{l^{\prime }+1}{\left(d_c^{\mathsf{\text{max}}}-1\right)}^{l^{\prime }+1}-1\right]}{\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)-1}\\ <r_{\mathsf{\text{min}}}\left(d_s^{\mathsf{\text{max}}}-1\right)+1.\hfill \end{array}$$

(21)

Let t be the solution of the equation

$$\begin{array}{c}\frac{d_s^{\mathsf{\text{max}}}\left[{\left(d_s^{\mathsf{\text{max}}}-1\right)}^{t+1}{\left(d_c^{\mathsf{\text{max}}}-1\right)}^{t+1}-1\right]}{\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)-1}\\ =r_{\mathsf{\text{min}}}\left(d_s^{\mathsf{\text{max}}}-1\right)+1\hfill \end{array}$$

(22)

that is,

$$t=\frac{\mathsf{\text{log}}\left(J{d}_c^{\mathsf{\text{max}}}-\frac{J{d}_c^{\mathsf{\text{max}}}}{d_s^{\mathsf{\text{max}}}}-J+1\right)}{\mathsf{\text{log}}\left[\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)\right]}-1,$$

(23)

where

$$J=r_{\mathsf{\text{min}}}\left(d_s^{\mathsf{\text{max}}}-1\right)+1.$$

(24)

Then l ≥ l' = ⌊t⌋ and

$$\begin{array}{c}{g}_F\ge 2\left(⌊t⌋+2\right)\hfill \\ =2\left(⌊\frac{\mathsf{\text{log}}\left(J{d}_c^{\mathsf{\text{max}}}-\frac{J{d}_c^{\mathsf{\text{max}}}}{d_s^{\mathsf{\text{max}}}}-J+1\right)}{\mathsf{\text{log}}\left[\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)\right]}-1⌋+2\right).\hfill \end{array}$$

(25)

The proof is completed.

Figure 2 depicts the lower bounds on PEG Tanner graphs and the lower bounds on FPEG Tanner graphs for regular $d_s^{\mathsf{\text{max}}}=3,d_c^{\mathsf{\text{max}}}=6$ codes and $d_s^{\mathsf{\text{max}}}=4,d_c^{\mathsf{\text{max}}}=8$ codes with varying m and R = 0.5. Note that due to the flooring operation in (1) and (25), there are almost vertical transitions shown in Figure 2. A step size of 100 was used when varying the value of m. It can be seen that, for the same $d_s^{\mathsf{\text{max}}}$ and $d_c^{\mathsf{\text{max}}}$, the PEG Tanner graph and the FPEG Tanner graph have similar lower bound on girth. It can also be seen that for small values of m, the girth can be 4. To avoid girth 4, equation below is used,

Figure 2

Lower bounds on two PEG Tanner graphs and two FPEG Tanner graphs. This figure depicts the lower bounds on PEG Tanner graphs and the lower bounds on FPEG Tanner graphs for regular $d_s^{\mathsf{\text{max}}}=3,d_c^{\mathsf{\text{max}}}=6$ codes and $d_s^{\mathsf{\text{max}}}=4,d_c^{\mathsf{\text{max}}}=8$ codes with varying m and R = 0.5.

$$2\left(⌊\frac{\mathsf{\text{log}}\left(J{d}_c^{\mathsf{\text{max}}}-\frac{J{d}_c^{\mathsf{\text{max}}}}{d_s^{\mathsf{\text{max}}}}-J+1\right)}{\mathsf{\text{log}}\left[\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)\right]}-1⌋+2\right)\ge 6,$$

(26)

which can be simplified to

$$t=\frac{\mathsf{\text{log}}\left(J{d}_c^{\mathsf{\text{max}}}-\frac{J{d}_c^{\mathsf{\text{max}}}}{d_s^{\mathsf{\text{max}}}}-J+1\right)}{\mathsf{\text{log}}\left[\left(d_s^{\mathsf{\text{max}}}-1\right)\left(d_c^{\mathsf{\text{max}}}-1\right)\right]}-1\ge 1,$$

(27)

that is

$$1+d_s^{\mathsf{\text{max}}}\left(d_c^{\mathsf{\text{max}}}-1\right)<r_{\mathsf{\text{min}}}.$$

(28)

Assume $r_{\mathsf{\text{min}}}=⌊\frac{m}{d_s^{\mathsf{\text{max}}}}⌋$, then

$$\begin{array}{c}1+d_s^{\mathsf{\text{max}}}\left(d_c^{\mathsf{\text{max}}}-1\right)<⌊\frac{m}{d_s^{\mathsf{\text{max}}}}⌋\\ d_c^{\mathsf{\text{max}}}<⌊\frac{\frac{m}{d_s^{\mathsf{\text{max}}}}-1}{d_s^{\mathsf{\text{max}}}}+1⌋.\end{array}$$

(29)

Hereafter in this article, for a given m, it was assumed $M=d_s^{\mathsf{\text{max}}}$ for two reasons: First, from (16) it can be seen that the number of encoding steps is least when $M=d_s^{\mathsf{\text{max}}}$. Second, from (18) it is easy to see that J grows linearly with r_min and larger J value leads to larger lower bound on g _F . It is also easy to see that the maximum

$$r_{\mathsf{\text{min}}}=⌊\frac{m}{M}⌋$$

(30)

is achieved when $M=d_s^{\mathsf{\text{max}}}$. Therefore, the maximum g _F is achieved when $M=d_s^{\mathsf{\text{max}}}$.

Note that there are degree-1 symbol nodes in the corresponding FPEG Tanner graph and the fraction of degree-1 symbol nodes is r₁/n. The existence of degree-1 symbol nodes is a necessary condition for a linear-encoding algorithm such as the label-and-decide algorithm and the LPEG algorithm [5, 12]. However, it was stated that the outbound extrinsic messages of degree-1 nodes would not be updated during the iterative decoding process [16, 17]. Consequently, the degree-1 symbol nodes would cause many problems such as mismatching of extrinsic information transfer (EXIT) functions and the halting of mutual information evolution. In the following section, we will introduce a modified FPEG algorithm, which construct LDPC codes with only one degree-1 symbol node.

3.2 MFPEG algorithm

A simple modification of the FPEG algorithm can be applied to construct LDPC codes which have only one degree-1 symbol node. This modified algorithm is called MFPEG algorithm in this article. The MFPEG algorithm is almost the same as the Algorithm 3 except for line 14. Therefore, we only describe the modified part in Algorithm 4.

Algorithm 4. MFPEG algorithm

1: Find out which check node group G _i includes c _i .

2: if i = 1 (the first check node group G₁) then

$$SC\leftarrow SC.$$

3: else

$$SC\leftarrow SC\backslash G_i.$$

4: end if

In a parity-check matrix corresponding to a Tanner graph generated by the MFPEG algorithm, the r₁ rows of the submatrix H₁ can have '1's in the same column. Consequently,

$$\left\{p_1,p_2,\dots ,p_{r_1}\right\}$$

should be computed serially, from $p_{r_1}$ to p₁, in r₁ steps by the parity-check equations in H₁ and the parity bits

$$\left\{p_{{\sum }_{j=1}^{i-1}{r}_j+1},p_{{\sum }_{j=1}^{i-1}{r}_j+2},\dots ,p_{{\sum }_{j=1}^i{r}_j}\right\}$$

for $i=2,3,\dots ,d_s^{\mathsf{\text{max}}}$ are computed, in parallel, in one step by the parity-check equations in H _i . Totally, the number of encoding steps of the MFPEG codes is

$$\begin{array}{ll}\hfill T_M& =\left(d_s^{\mathsf{\text{max}}}-1\right)+r_1\\ \ge \left(d_s^{\mathsf{\text{max}}}-1\right)+r_{\mathsf{\text{min}}}\\ \ge \left(d_s^{\mathsf{\text{max}}}+⌊\frac{m}{d_s^{\mathsf{\text{max}}}}⌋-1\right),\end{array}$$

(31)

where the equality is achieved when r₁ is the minimum of {r₁, r₂, ..., r _M }. In fact, the MFPEG algorithm has loosened the condition (A) and is a combination of the LPEG algorithm and the FPEG algorithm. Therefore, for a given degree distribution pair, we have the following equalities:

$$g_F\le g_M\le g_L,$$

(32)

where g _M is the lower bound on girth of the MFPEG Tanner graph.

Note that, since both of LPEG codes and MFPEG codes have only one degree-1 symbol node (FPEG codes have r₁ degree-1 symbol nodes), they may have the same symbol-node-degree distribution. As shown in Figure 3, the encoder of the proposed FPEG and MFPEG codes can be implemented as r _i SPC encoder and one quasi-random interleaver, thus increasing complexity, compared to MPC encoder.

Figure 3

Structure of the proposed encoder. The encoder of the proposed FPEG and MFPEG codes can be implemented as r _i SPC encoder and one quasi-random interleaver.

4 Examples and simulation results

In this section, we provide two examples of the proposed codes and compare them with the M-SC-MPC codes [10] and LPEG codes. In this article, we denote LPEG codes, FPEG codes and MFPEG codes with M submatrices by M-LPEG codes, M-FPEG codes, and M-MFPEG codes respectively. In the first example it is shown that, In comparison to the M-SC-MPC codes which have the same number of encoding steps as FPEG codes, FPEG codes have better error correcting performance. In the second example, it is shown that for a given symbol-node-degree distribution, FPEG codes and MFPEG codes have similar error correcting performance but less encoding steps. In computing the error correcting performance, in terms of the bit error rate (BER), we assume BPSK transmission over the AWGN channel. The decoding algorithm used here is the log-likelihood sum-product algorithm and the maximum iteration number is set to be 50.

Example 2: An M-SC-MPC code consists of M MPC encoders and offers a flexible code rate and code length with low encoding complexity [10]. The encoding process of an M-SC-MPC code includes M steps, where M is also the maximum symbol-node degree, $d_s^{\mathsf{\text{max}}}$. Clearly, for the same maximum symbol-node degree, the number of encoding steps of M-SC-MPC codes is the same as those of FPEG codes. Therefore, we will compare the performance of FPEG codes and M-SC-MPC codes, provided that the number of encoding steps and the symbol-node-degree distributions are the same.

For the rate 3/4, in [10], the authors considered the following M-SC-MPC codes:

• 4-SC-MPC: n = 1196, r₁ = 59, r₂ = 73, r₃ = 78, r₄ = 89;

• 5-SC-MPC: n = 1268, r₁ = 53, r₂ = 55, r₃ = 59, r₄ = 67, r₅ = 83;

• 6-SC-MPC: n = 1204, r₁ = 45, r₂ = 46, r₃ = 47, r₄ = 49, r₅ = 53, r₆ = 61.

The symbol-node degree distribution and check-node degree distributions of these codes from node perspective are shown in Tables 1 and 2, respectively. Using the same symbol-node-degree distribution, we construct the M-FPEG codes with the FPEG algorithm for M = 4, 5, 6. The BER performance comparisons of these codes are given in Figure 4. It is shown that an M-FPEG code performs better than that of the corresponding M-SC-MPC code. At BER = 10^-4, the advantage of the M-FPEG codes against the M-SC-MPC codes are about 0.1, 0.7, and 0.3 dB, respectively, for M = 4, 5, 6.

Table 1 Symbol-node-degree distributions of the M-SC-MPC codes

Table 2 Check-node-degree distributions of M-SC-MPC codes

Figure 4

BER performance of FPEG codes in comparison with M-SC-MPC codes. The BER performance comparisons of these codes are given in Example 2.

Example 3: We construct M-LPEG codes, M-FPEG codes and M-MFPEG codes with the LPEG algorithm, FPEG algorithm and MFPEG algorithm, respectively, for $M=4,5,6,\left(d_s^{\mathsf{\text{max}}}=4,5,6\right)$. The code length is n = 1000, the parity-check length is m = 500 and the code rate is R = 0.5. For the purpose of performance comparison, the optimal degree distributions given in [[18], Table I] are used in this example. The fraction of Tanner graph edges which emanate from degree-1 symbol nodes of M-LPEG codes, M-FPEG codes and M-MFPEG codes can be obtained from that of the degree-i symbol nodes by the following formula:

$${\psi }_1^{*}={\psi }_i-{\psi }_i^{*},$$

(33)

where ψ _i is the original fraction of Tanner graph edges which emanate from degree-i symbol nodes and ${\psi }_i^{*}$ is the new fraction used in this example. Note that if the number of degree-2 symbol nodes of the Tanner graph of H is larger than or equal to n - m, any combination of n - m degree-2 columns forms cycles. Thus we can improve the error floor performance by reducing the fraction

$${\lambda }_2=\frac{{\psi }_2/2}{{\sum }_j{\psi }_j/j},$$

(34)

if the fraction of degree-2 symbol nodes is higher than the optimal value given in [19]. Therefore, for the original degree distributions ψ _i given in [[18], Table I], we obtained the degree-1 symbol nodes from the degree-2 symbol nodes by

$${\psi }_1^{*}={\psi }_2-{\psi }_2^{*}.$$

(35)

The original node degree distributions are given in the Table 3 and in the simulation of this example, the degree distributions from edge perspective are given in Table 4.

Table 3 Original symbol-node-degree distribution in [18]

Table 4 New symbol-node-degree distribution

Note that the symbol-node-degree distributions from node perspective for the LPEG, FPEG, and MFPEG algorithms can be calculated from edge distribution with the formula (7) and the check-node-degree distribution is not needed as the check-node degrees are made as uniform as possible by the LPEG algorithm [6] and the proposed FPEG and MFPEG algorithms. From (1) and (18), it is clear that the maximum check-node degree $d_c^{\mathsf{\text{max}}}$ is necessary to derive the lower bound on girth. However, the value $d_c^{\mathsf{\text{max}}}$ can be obtained easily in the simulation program. The lower bound on girth, girth and average cycle length of the simulated codes are given in Table 5 and their number of encoding steps are given in Table 6. From Equations (5), (16), (31), and Table 6, it can be seen that T _F < T _M < T _L for these given symbol-node degree distributions. The simulation results are shown in Figure 5. It is shown that, compared to the LPEG codes, the FPEG codes perform better in the waterfall region but worse in the error floor region. However, the MFPEG codes perform similarly to the LPEG codes.

Table 5 Girth lower bound, girth and average cycle length for m = 500, n = 1000, and R = 0.5

Table 6 Number of encoding steps For m = 500, n = 1000, and R = 0.5

Figure 5

BER performance of FPEG codes and MFPEG codes in comparison with LPEG codes. The BER performance comparisons of these codes are given in Example 3.

5 Conclusion

In this article, we introduced the FPEG algorithm and the MFPEG algorithm for generating fast encodable LDPC codes. The number of encoding steps of the FPEG codes grows linearly with $d_s^{\mathsf{\text{max}}}$, not the code length n. The number of encoding steps of the MFPEG codes grows linearly with $\left(d_s^{\mathsf{\text{max}}}+⌊\frac{m}{d_s^{\mathsf{\text{max}}}}⌋-1\right)$. Moreover, we derived a lower bound on girth of the FPEG codes which is shown to be similar to that of PEG codes. By examples and simulations, it is shown that compared to the M-SC-MPC codes the FPEG codes have the same number of encoding steps but better error correcting performance, and compared to the LPEG codes the FPEG codes have similar error correcting performance but less encoding steps. Variants of M-SC-MPC codes, in which the degree of freedom is exploited, have been proposed in [20, 21]. Considering these variants of M-SC-MPC codes in the design of fast-encodable LDPC codes is an open issue for future research.