A cycle in a Tanner graph is a sequence of connected vertices that starts and ends at the same vertex in the graph, and which contains other vertices no more than once. To upgrade the performance of LDPC codes, it is necessary to avoid 4-cycles, which is the shortest possible length for a Tanner graph. The girth of an LDPC code is the length of the smallest cycle. Since cycles of short length may degrade the performance of LDPC codes, it is necessary to ensure that the Tanner graph of the LDPC codes is free of cycles with lengths of 4 and hence have girths of at least 6 [13]. In Section 4.1, we introduce how to construct the proposed memory-efficient QC-LDPC codes and prove that no 4-cycles are present. The construction examples and the simulation results are shown at the last two subsections.

### 4.1. Construction procedure

In this section, we propose a method for constructing the QC-LDPC codes with memory reduction. For clarity of exposition, the MWC-OCS LDPC codes [11] are used as an exemplification. However, for the application of the proposed memory-efficient scheme, only the cyclic parts of the MWC sequences are adopted in the construction procedure.

An element from GF(*p*) in a *j* × *k* preliminary matrix **Y** can be represented as *y*_{
u, v
}, where the (*u*, *v*)th element of **Y** can be calculated by Equation (2) with the corresponding values of *a*_{
u
} and *b*_{
v
}, for fixed parameters φ and α.

{y}_{u,v}=\alpha {\beta}^{\left({a}_{u}+{b}_{v}\right)}+\phi ,

(2)

where 0 ≤ *u* ≤ *j*-1, 0 ≤ *v* ≤ *k*-1.

For memory efficiency, two specific sequences {*a*_{0}, *a*_{1},..., *a*_{j-1}} and {*b*_{0}, *b*_{1},..., *b*_{k-1}} are constructed by the following procedure.

First, choose basic parameters *j*, *k*, and *p* (*p* is a prime) where the *j*, *k* ∈ integer.

Second, choose initial values *a*_{0}, *b*_{0}, and grid size *f* where 0 ≤ *a*_{
m
} (= *a*_{0} + *mf*) ≤ *p*-2 for *m* = 0, 1,..., *j*-1, 1 ≤ *b*_{
n
} (= *b*_{0} + *nf*) ≤ *p*-1 for *n* = 0, 1,..., *k*-1, and *f* ∈ {1, 2,..., *p*-1}.

Third, substitute *a*_{
m
} = *a*_{0} + *mf* and *b*_{
n
} = *b*_{0} + *nf* into (2). Note that *a*_{
i
} ≠ *a*_{
j
} and *b*_{
i
} ≠ *b*_{
j
} if *i* ≠ *j*. where α ∈ {1, 2,..., *p*-1}, φ ∈ {0, 1,..., *p*-1}, and β is the primitive element of GF(*p*). Then the following equation is obtained:

{y}_{m\mathsf{\text{,}}n}={\alpha \beta}^{\mathsf{\text{[(}}{a}_{0}+mf\left)+\left({b}_{0}+nf\right)\right]}+\phi

(3)

The proposed parity check matrix **H**, which reduces the non-volatile memory demand, can be represented by a *j* × *k* array of circulant permutation sub-matrices shown as follows:

\mathbf{H}\phantom{\rule{2.77695pt}{0ex}}=\phantom{\rule{0.3em}{0ex}}\phantom{\rule{0.3em}{0ex}}\left[\begin{array}{cccc}\hfill I\left({y}_{0,0}\right)\hfill & \hfill I\left({y}_{0,1}\right)\hfill & \hfill \cdots \phantom{\rule{0.3em}{0ex}}\hfill & \hfill I\left({y}_{0,k-1}\right)\hfill \\ \hfill I\left({y}_{1,0}\right)\hfill & \hfill I\left({y}_{1,1}\right)\hfill & \hfill \cdots \phantom{\rule{0.3em}{0ex}}\hfill & \hfill I\left({y}_{1,k-1}\right)\hfill \\ \hfill \vdots \hfill & \hfill \vdots \hfill & \hfill \vdots \hfill & \hfill \vdots \hfill \\ \hfill I\left({y}_{j-1,0}\right)\hfill & \hfill I\left({y}_{j-1,1}\right)\hfill & \hfill \cdots \phantom{\rule{0.3em}{0ex}}\hfill & \hfill I\left({y}_{j-1,k-1}\right)\hfill \end{array}\right]

(4)

where *I*(*x*) is a *p* × *p* identity sub-matrix with rows cyclically shifted to the right by *x* positions. For example, *I*(1) is the following permutation matrix:

I\mathsf{\text{(1)}}=\left[\begin{array}{ccccc}\hfill 0\hfill & \hfill 1\hfill & \hfill 0\hfill & \hfill \cdots \phantom{\rule{0.3em}{0ex}}\hfill & \hfill 0\hfill \\ \hfill 0\hfill & \hfill 0\hfill & \hfill 1\hfill & \hfill \cdots \phantom{\rule{0.3em}{0ex}}\hfill & \hfill 0\hfill \\ \hfill 0\hfill & \hfill 0\hfill & \hfill 0\hfill & \hfill \cdots \phantom{\rule{0.3em}{0ex}}\hfill & \hfill 0\hfill \\ \hfill \vdots \hfill & \hfill \vdots \hfill & \hfill \vdots \hfill & \hfill \vdots \hfill & \hfill 1\hfill \\ \hfill 1\hfill & \hfill 0\hfill & \hfill 0\hfill & \hfill \cdots \phantom{\rule{0.3em}{0ex}}\hfill & \hfill 0\hfill \end{array}\right]

(5)

Hence, the resulting **H**, which has *j* ones in each column and *k* ones in each row, represents a (*j*, *k*)-regular LDPC code (this LDPC code is also an [*N*, *K*] regular LDPC code, where *N* (= *kp*) is the block length of the MWC-OCS LDPC code and *K* is the number of message bits).

The size of the parity-check matrix **H** is *jp* × *kp*. Due to the linear dependence among the rows of **H**, it has a code rate of *r* = *K*/*N* ≥ 1-(*j*/*k*). Actually, since the summation of the *p* rows of the *J* th sub-matrices [*I*(*y*_{J,0}) *I*(*y*_{J,1})...*I*(*y*_{J, k-1})] (0 ≤ *J* ≤ *j*-1) in (4) are equal to an all-1 vector, there are at least *j*-1 dependent rows in **H**. Therefore, the Tanner graph of the resulting LDPC codes is free of cycles with lengths of 4 and hence has a girth of at least 6.

Based on (3), if two sequences *a*_{
m
} and *b*_{
n
} are both ordered incrementally or decrementally by *f*, an element *y*_{s, t}will be equal to *y*_{m, n}, as *s* + *t* is equal to *m + n* in the preliminary matrix **Y**. In (6), we also verify that if *a*_{
m
} and *b*_{
n
} are ordered in an opposite direction to each other, an element *y*_{s, t}is still equal to *y*_{m, n}when *s*-*t* = *m-n*. Note that *m* ≠ *s*, *n* ≠ *t*.

\begin{array}{ll}{y}_{s,t}& =\alpha {\beta}^{\{[{a}_{0}+s(+f)]+[{b}_{0}+t(-f)]\}}+\phi \\ =\alpha {\beta}^{[{a}_{0}+{b}_{0}+(s-t)f]}+\phi \\ =\alpha {\beta}^{[{a}_{0}+{b}_{0}+(m-n)f]}+\phi \\ =\alpha {\beta}^{\{[{a}_{0}+m(+f)]+[({b}_{0}+n(-f)]\}}+\phi \\ ={y}_{m,n}\end{array}

(6)

### 4.2. Construction examples

According to (3) and (6), two construction examples are shown as follows. The initial values chosen for the required sequences can be different.

Example A: A [155, 64] MWC-OCS LDPC code (*p* = 31)

Let *j* = 3, *k* = 5, *f* = 3. We select {*a*_{0}, *a*_{1}, *a*_{2}} = {0, 3, 6} and {*b*_{0}, *b*_{1}, *b*_{2}, *b*_{3}, *b*_{4}} = {1, 4, 7, 10, 13}. By using (3) and (4) with fixed parameter α = 1, φ = 0, we can form the following parity-check matrix:

\mathsf{\text{H}}\phantom{\rule{2.77695pt}{0ex}}=\phantom{\rule{2.77695pt}{0ex}}\phantom{\rule{2.77695pt}{0ex}}\left[\begin{array}{ccccc}\hfill I\left(3\right)\hfill & \hfill I\left(19\right)\hfill & \hfill I\left(17\right)\hfill & \hfill I\left(25\right)\hfill & \hfill I\left(24\right)\hfill \\ \hfill I\left(19\right)\hfill & \hfill I\left(17\right)\hfill & \hfill I\left(25\right)\hfill & \hfill I\left(24\right)\hfill & \hfill I\left(28\right)\hfill \\ \hfill I\left(17\right)\hfill & \hfill I\left(25\right)\hfill & \hfill I\left(24\right)\hfill & \hfill I\left(28\right)\hfill & \hfill I\left(12\right)\hfill \end{array}\right]

In Example A, two sequences are both ordered increasingly, and the resulting **H**-matrix shows the same shift values in the identity sub-matrices from the lower left to the upper right.

Example B: We select {*a*_{0}, *a*_{1}, *a*_{2}} = {0, 3, 6} and {*b*_{0}, *b*_{1}, *b*_{2}, *b*_{3}, *b*_{4}} = {13, 10, 7, 4, 1}, and then the following parity-check matrix is formed:

\mathsf{\text{H}}=\left[\begin{array}{ccccc}\hfill I\left(24\right)\hfill & \hfill I\left(25\right)\hfill & \hfill I\left(17\right)\hfill & \hfill I\left(19\right)\hfill & \hfill I\left(3\right)\hfill \\ \hfill I\left(28\right)\hfill & \hfill I\left(24\right)\hfill & \hfill I\left(25\right)\hfill & \hfill I\left(17\right)\hfill & \hfill I\left(19\right)\hfill \\ \hfill I\left(12\right)\hfill & \hfill I\left(28\right)\hfill & \hfill I\left(24\right)\hfill & \hfill I\left(25\right)\hfill & \hfill I\left(17\right)\hfill \end{array}\right]

Example B shows that a memory-efficient LDPC codes also can be constructed by two sequences ordered in the opposite direction of each other. The **H**-matrix is constructed by *a*_{
m
} = {*a*_{0}, *a*_{0}+*f*, *a*_{0}+2*f*,..., *a*_{0}+(*j-1*)*f*} and *b*_{
n
} = {*b*_{0}, *b*_{0}-*f*, *b*_{0}-2*f*,..., *b*_{0}-(*k-* 1)*f*}. The resulting H-matrix shows the same shift values in the identity sub-matrices from the upper left to the lower right. Each resulting **H**-matrix shown in Examples A and B is a 93 × 155 matrix and describes a (3, 5)-regular LDPC code with *rate* = 64/155 ≈ 0.4129 (by using Gaussian elimination, we know that **H** has a rank of 91).