e consider the problem of designing unoriented bipartite graphs with large girth. These graphs are the Tanner graphs associated with the parity-check matrix H of low density parity-check (LDPC) codes or Gallager codes. Larger girth improves the computational and bit error rate (BER) performance of these codes. The article overviews several existing methods in the literature and then describes two new constructions for LDPC codes with large girth—geometry based and turbo structured LDPC codes. Simulation results show the potential improvement in the error floor that such codes provide over randomly generated LDPC codes.
The Origin of LDPC Codes
LDPC codes were originally introduced by Gallager in his doctoral thesis; see [1]. Since the discovery of turbo codes in 1993 by Berrou
José M.F. Moura, Jin Lu,
and Haotian Zhang W
© IMAGESTATE
et al. [2] and the rediscovery of LDPC codes by Mackay and Neal in 1995 (see [3]), there has been renewed interest in turbo codes and LDPC codes because their bit error rate performance approaches asymptotically the Shannon limit [4]. Much research is devoted to charac- terizing the performance of LDPC codes and designing codes that have good performance. Commonly, a graph, the Tanner graph, is associated with the code and an important parameter affecting the performance of the code is the girth of its Tanner graph. In this article we consider the design of structured regular LDPC codes whose Tanner graphs have large girth. The regularity and structure of LDPC codes utilize memory more efficiently and simplify the implementation of LDPC coders. The Tanner graph is a special type of graph, a bipartite graph, where the nodes divide into two disjoint classes with edges only between nodes in the two different classes.
The problem we consider then is a generic problem in graph theory, namely, that of designing bipartite graphs with large girth. We actually consider a more special class of this generic problem, in particular, the design of undi- rected regular bipartite graphs with large girth.
Graphs and Codes
In this section we review a few needed concepts in lin- ear codes, low density parity-check codes, and graphs.
Linear Block Codes
In communications, a dataword is a sequence of p user bits. An (n, p) linear block code C with dataword length p and codeword (block) length n over the binary field F2
can be regarded as a p-dimensional subspace of the n- dimensional vector space Vn(F2) over the binary field F2, [5]. There are 2p datawords ¯u = [u0, u1, . . . , up−1] in the code C, and each of them corresponds to a unique codeword ¯c = [c0, c1, . . . , cn−1]. Note that ¯u and ¯c are row vectors, not column vectors. Since C is a subspace of dimension p, there exist p linearly independent vectors
¯g0, ¯g1, . . . , ¯gp−1 that span C. Therefore, each codeword can be written as a linear combination of these independ- ent vectors: ¯c = ¯u G, where G = [ ¯g0 ¯g1 . . . ¯gp−1]T is the p× n generator matrix [6]. The null space of the subspace C, i.e., the orthogonal subspace of C with dimension m= n − p, can be spanned by m linearly independent vectors ¯h0, ¯h1, . . . , ¯hm−1. Each codeword ¯c satisfies the parity-check equations ∀i : ¯c ¯hTi = 0. The m× n parity-check matrix H collects these ¯hi in matrix format as H= [ ¯h0 ¯h1. . . ¯hm−1]T, [6].
LDPC Codes
An LDPC code is a special class of linear block codes whose parity-check matrix H has a low density of ones, i.e., is sparse. This sparsity renders low complexity decoding and leads to simple implementations. We will emphasize regular (n, j, k) LDPC codes, [7], where the n columns and m rows of its parity-check matrix H all have the same number of ones, j and k, respectively, i.e., the columns have uniform weight j and the rows
have uniform weight k , where k n and j m = n − p. By counting the number of ones in H, it follows that nj = mk. The code rate of H is r = p/n = (n − m)/n = (k − j)/k = 1 − j/k . Note that the equation is true only if H is full rank. If H is not full rank, the code rate is r = (n − rank(H))/n.
Tanner Graph
To the LDPC code we can associate a graph G, referred to as its Tanner graph [8]. For the sake of completeness, we recall basic definitions from graph theor y. Let G = {(V, E)} be a graph, where V is a set of vertices or nodes V and E is a set of edges E connecting the vertices.
The degree of a node V is the number of edges incident on V . In an undirected graph, a series of successive edges forming a continuous curve passing from one vertex to another is called a chain. A chain of nodes where the ini- tial and the terminal nodes are the same and that does not use the same edge more than once is a cycle. The length of a cycle is the number of its edges; and the girth g of G is the length of the shortest cycle. The graph G is bipartite if the set of vertices V can be decomposed into two dis- joint sets V1 and V2 such that no two vertices within either V1or V2are connected by an edge. It is well known from graph theory that a graph with at least two nodes is bipartite if and only if all its cycles are of even length.
Tanner graphs are bipartite where the two disjoint sets V1orV2 collect the bit nodes and the check nodes:
each bit of a codeword is assigned a bit node, and each parity-check equation is assigned a check node. We illus- trate the relation between the m× n parity-check matrix H and its Tanner graph G with reference to Figure 1. The figure shows a 4× 8 H matrix and its
43
▲1. (a) The parity-check matrix H of an LDPC code. (b) Corresponding Tanner graph G.
H =
V1 V7
C1
C2
C3
C4 V8 V6
V5 V4 V3 V2
V1
C1 C2 C3 C4
V7 V8 V6
V5 V4 V3 V2
1 0 1 0 1 0 1 0
1 0 0 1 0 1 0 1
0 1 1 0 0 1 1 0
0 1 0 1 1 0 0 1
Check Node Bit Node (a)
(b)
Tanner graph G, respectively. The m rows of H corre- spond to the check nodes and the n columns to the bit nodes of the Tanner graph G; they are represented by filled squares and filled circles in Figure 1, respectively.
A 1 in row Ci and column Vj in H is represented by an edge in the Tanner graph connecting the associated check node Ci and the bit node Vj; for example, the 1 in row 4 and column 8 in H in Figure 1 is illustrated by the dashed line between C4 and V8 in Figure 1. The bold solid lines (C1,V3), (V3, C3), (C3,V7), and (V7, C1) depict a cycle in the Tanner graph; this turns out to be the shortest cycle in this graph, so that its girth is g= 4.
Decoding
The decoding of LDPC codes fits the general frame- work of Tanner graphs and the sum-product algorithm [9], which is an iterative message passing algorithm operating on the Tanner graph; see [10].
Cycles, Girth, and Performance
It is well known that with a cycle-free Tanner graph, the sum-product algorithm terminates naturally in a finite number of steps and yields optimal decoding in the sense that the symbol error probability is mini- mized [9], [11]. However, cycle-free Tanner graphs have poor BER performance: their minimum distance is two at code rates r> 1/2, and their error floors occur at unacceptable values of SNR [12]. When Tanner graphs have cycles, the resulting sum-product algorithm is suboptimal [9], [11]. Cycles, especially short cycles in the Tanner graph, lead to inefficient decoding and prevent the sum-product algorithm from converging to the optimal decoding result [13], [12], taxing the performance of the LDPC decoders. We dis- cuss briefly why the code performance is affected by short cycles. Intuitively, the girth determines the small- est number of iterations for a message sent by a node (in the shortest cycle of the graph) to propagate back to the node itself. This causes loss of independence in the extrinsic information merged on a node in the iter- ative decoding through the successive iterations;
Gallager [1] showed that the number of independent iterations M is proportional to the girth g of the Tanner graph, in particular, M < g /4 ≤ M + 1. A sec- ond reason relates to the minimum distance of the code. Tanner [8] derives a lower bound on the mini- mum distance dmin; this lower bound increases with the girth g of the code. Therefore, LDPC codes with large girth are to be preferred.
To increase the girth g and avoid short cycles, the parity-check matrix H should be sufficiently sparse. In turn, this means that the block length must be large enough. In fact, Gallager [1] provides a loose lower bound on the block length n given the girth g of a regular LDPC code. For a parity-check matrix H with column weight j and row weight k, the bound on the block length n is
▲1) for g = 4m + 2, n ≥m+1
1 Si where S1= 1 and for i ≥ 2, Si = j ( j − 1)(i−2)(k − 1)(i−1)
▲2) for g = 4m , n≥m
1 Li, where Li = k( j − 1)(i−1)(k − 1)(i−1), ∀i .
For example, to construct an (n, j = 3, k = 12) LDPC code with girth g = 12, its block length n should satis- fy n≥ 6, 084. Of course, this lower bound is just that;
even if n exceeds the bound for a given g∗ there might not exist a regular LDPC code with this block length n and the desired girth g∗.
Two alternative approaches to designing LDPC codes with girth g > 4 are described in later sections.
Due to the overview and introductory nature of the article, we focus specifically on examples of codes with column weight j= 2 and 4 < g ≤ 20 and codes with j= 3 and 4 < g ≤ 8. Codes with j = 2 are usually of less interest in digital communications systems because, as Gallager proved in his original work [1], the corre- sponding dmin grows only logarithmically fast with the block size n of the code, while for codes with j ≥ 3, dmin grows linearly with n.
Constructions for Large Girth LDPC Codes:
Brief Overview of the Literature
Designing LDPC codes with large girth is a combina- torial design problem. Given four positive integers m, n, j, k such that mk = nj , we are interested in con- structing an m× n parity-check matrix H with uniform column weight j and uniform row weight k such that the associated Tanner graph has large girth g .
Search Methods
A straightforward method for designing such H is brute force. For an m× n parity-check matrix H with uniform column weight j , there are mjn possible choices, which makes an exhaustive search computa- tionally infeasible for values of n of practical interest.
Further, a large number of choices are actually isomor- phic to each other and lead to identical LDPC codes.
Campello, Modha, and Rajagopalan [14], [15] provide a heuristic method called “bit-filling” to search for LDPC codes with large girth. The computational com- plexity of bit-filling is O(kmaxm3) where kmax is the maximum degree of any check node and m is the num- ber of rows in H. The polynomial complexity makes bit-filling feasible to implement. The H matrix generat- ed by bit-filling has uniform column weight j but non- uniform row weight k . Hence the LDPC codes constructed are not regular codes in strict sense. Also, there is no guarantee that codes with the largest possi- ble girth g are constructed for a given n. Another heuristic algorithm (see [16]) searches for a good LDPC code based on the average of the girth distribu- tion of the code. The complexity of this algorithm is shown in [16] to be O(n2). The algorithm described in [16] is suitable for designing short (10,000 bits or shorter) codes.
Finite Geometries
Kou et al. [17], [18] present a geometric approach to the design of LDPC codes based on the lines and points of Euclidean and projective geometries over finite fields [19], [20]. Codes construted from these finite geome- tries have no cycles of length four. By casting the design problem in the context of finite geometries, they obtain four classes of (quasi-) cyclic LDPC codes with girth g = 6.
Euclidean and projective geometries [19], [21] with n points and J lines satisfy the following structural properties:
▲1) each line is composed of ρ points
▲2) there is one and only one line between any two points
▲3) each point lies on γ lines
▲4) any pair of lines has only one common point or no common point.
Figure 2 gives a simple example of a finite geometry with n= 4, J = 6, ρ = 2, and γ = 3.
Associated with a finite geometry G is the J × n incidence matrix HG(1)= [hi, j] where each row and column correspond to a line and a point, respectively, and hi, j = 1 if and only if the jth point is on the ith line in G ; otherwise, hi, j = 0. The row and column weights ρ and γ correspond to the ρ points in the cor- responding line and to the γ lines passing the corre- sponding point, respectively. If ρ n and γ J , the matrix HG(1) can be regarded as a low-density parity- check matrix. The codes corresponding to HG(1) are called type I geometry-G LDPC codes whose block length is n. Interchanging the roles of the rows and columns in the incidence matrix, the codes correspon- ding to HG(2)= HG(1)T are called type II geometry-G LDPC codes.
References [17] and [18] used these finite-geome- tries to construct the above two types of LDPC codes.
From the fundamental properties 2) and 4) of finite- geometries, these codes are free of four-cycles; they have a wide range of block lengths and code rates and achieve good minimum distances. These codes can be encoded in linear time and by simple feedback shift registers, and they can be extended and shortened in various ways to obtain other good LDPC codes.
Simulation results in [17] show that with iterative decoding the performance of long extended finite- geometry LDPC codes are only a few tenths of a dB away from the Shannon limit.
Balanced Incomplete Block Designs
Recently, structured four-cycle-free regular LDPC codes have been constructed [22]–[28], based on com- binatorial designs known as balanced incomplete block designs (BIBD) [29], a concept thoroughly studied since the end of the 19th century.
A BIBD with parameters (v, k, λ, r, b ) is an ordered pair (X , A) in which a set X of v points is partitioned into a collection A of b subsets (blocks) in such a way
that any two points determine λ blocks with k points in each block and each point is contained in r different blocks [29]. Since b k= vr and λ(v − 1) = r(k − 1), only three of the five parameters are independent.
Therefore, the notation (v, k, λ)-BIBD represents a BIBD on v points, block size k, and index λ.
Example 1: Let X = {1, 2, 3, 4, 5, 6, 7, 8, 9}, and A the collection of 12 three-element blocks:
A = {(1, 2, 3), (4, 5, 6), (7, 8, 9), (1, 4, 7), (2, 5, 8), (3, 6, 9), (1, 5, 9), (2, 6, 7), (3, 4, 8), (1, 6, 8), (2, 4, 9), (3, 5, 7)}, the pair (X , A) is a (9, 3, 1)-BIBD [30].
The (v, k, λ)-BIBD with k = 3 and λ = 1 is called a Steiner triple system. The (9, 3, 1)-BIBD in the previ- ous example is a Steiner triple system. Steiner triple sys- tems exist for all v= 1, 3 mod 6. (We use both notations x= y mod z and x = (y , mod z).)
If a set of blocks partitions the point set X in a BIBD, the block set is a parallel class. A resolution of a BIBD is a partition of the family A of blocks into paral- lel classes. Clearly, a resolution is composed of exactly r parallel classes. A BIBD with at least one resolution is resolvable. A resolvable Steiner triple system is a Kirkman triple system. Kirkman triple systems exist for all v= 3 mod 6. For the (9, 3, 1)-BIBD in Example 1, which is also a Steiner triple system, the set A can be partitioned into four parallel classes as follows:
{(1, 2, 3), (4, 5, 6), (7, 8, 9)}, {(1, 4, 7), (2, 5, 8), (3, 6, 9)}, {(1, 5, 9), (2, 6, 7), (3, 4, 8)}, {(1, 6, 8), (2, 4, 9), (3, 5, 7)}
Large girth speeds the convergence of iterative decoding and improves the
performance at least in the high SNR range, by slowing down the onset of the error floor.
▲2. A finite geometry with ρ = 2, γ = 3.
i.e., this Steiner triple system is resolvable, and so it is also a Kirkman triple system.
Following [25], define a point-block incidence matrix H = [hi j]v×b, where hi j = 1 if the ith-point in X occurs in the j th-block of A , and hi j = 0 otherwise.
For the (v, k, λ)-BIBD with k ≥ 2 and λ = 1, if each point is regarded as a parity-check equation and each block is a bit in a linear block code, then H is a parity- check matrix of size v× b whose uniform row weight is r and the uniform column weight is k. If r v and k b , H is the sparse parity-check matrix of an LDPC code. Figure 3 shows the parity-check matrix H corre- sponding to the (9, 3, 1)-BIBD in Example 1, where the rows from top to bottom correspond to the points 1, 2, . . . , 9 in X , and the columns from left to right correspond to the blocks in A .
In a parity-check matrix H, two columns that have two 1’s on the same rows correspond to a four-cycle in the associated Tanner graph. It is easy to see that for the point-block incidence matrix H arising from BIBDs with λ = 1 this cannot happen. Therefore their Tanner graphs are free of four-cycles.
Mackay and Davey [22] were the first to use BIBDs, in particular, Steiner triple systems, to design LDPC codes. Johnson and Weller [23], [24] present a family of (n, 3, k) LDPC codes based on Kirkman triple sys- tems. These codes are systematically constructed and are free of four-cycles. Vasic et al. [28] do further work on constructing four-cycle-free (n, 3, k) LDPC codes based on Kirkman triple systems, present an efficient encoding algorithm for hardware implementation, and study their decoding performance by the sum-product algorithm in perpendicular magnetic read channels with different partial response targets and different types of noise. In [25], Vasic constructs structured four-cycle- free (n, 3, k) LDPC codes based on Steiner triple sys- tems and dif ference families of Abelian groups, proposes a hardware efficient encoding algorithm, and demonstrates that high-rate Steiner codes have a sub- stantial performance gain over current schemes for magnetic recording systems. References [26] and [27]
also construct four-cycle-free LDPC codes based on other BIBD techniques, such as mutually orthogonal Latin rectangles (MOLR) and anti-Pasch BIBDs. A Latin rectangle based on a set of n elements S is an r× s rectangular array, say A, with the property that each row of A is an s -permutation of elements of S and each column of A is an r -permutation of elements of S [31]. The Latin square is of order r if r = s . Two Latin rectangles are orthogonal, if no ordered pair occurs more than once when the rectangles are superimposed.
A set of Latin rectangles is said to be mutually orthog- onal if any two of the rectangles are orthogonal [32].
In [26], Vasic presents a family of LDPC codes based on MOLR and analyzes their decoding performance in perpendicular magnetic read channels.
An (n, k) configuration in a BIBD is a subset of k blocks of A whose union is an n-element subset of X . A Pasch configuration [33], or a quadrilateral, is a (6, 4) configuration in a Steiner triple system. Figure 4 shows an example of a Pasch configuration, where a, b , c , d,e, f is a six-subset of points of X , and a, b , c , a, d,e, b , d, f , c ,e, f is a subset of four blocks in A . Reference [27] constructs LDPC codes with the minimum distance dmin≥ 6 based on BIBDs without Pasch configurations, i.e., anti-Pasch BIBDs, to increase the minimum distance of the codes. For a lin- ear block code, any dmin− 1 columns of the associated parity-check matrix H are linearly independent. If there exist one or more Pasch configurations in a Steiner triple system, the four columns of H corresponding to four blocks in a Pasch configuration, respectively, must be linearly dependent, since each point occurs exactly twice in the configuration. Therefore, dmin= 4. If we can avoid Pasch configurations in a Steiner triple sys- tem to get an anti-Pasch system, the associated parity- check matrix has dmin ≥ 6, since dmin must be even for H when the column weight is j= 3.
The construction of regular LDPC codes based on anti-Pasch resolvable designs was also independently
▲3. The H matrix corresponding to a (9, 3, 1)-BIBD.
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 0 1 0 00 1 0 0 1 0
1 0 0 0 0 1 00 0 1 0 0 1
0 1 0 1 0 0 00 0 1 0 1 0
0 1 0 0 1 0 1 0 0 0 0 1
0 1 0 0 0 1 00 1 0 1 0 0
0 0 1 1 0 0 00 1 0 0 0 1
0 0 1 0 1 0 00 0 1 1 0 0
0 0 1 0 0 1 1 0 0 0 1 0
▲4. A Pasch configuration.
a
b c
d
e
f
proposed by Johnson and Weller [23]. These well- structured codes are free of four-cycles, achieve very high code rates, and can have arbitrary column weight, although this reference focuses on codes with low col- umn weights. These codes are quasi-cyclic so that their encoder can be realized by using shift registers.
All these BIBD based codes are well structured, free of four-cycles, i.e., girth g= 6, and achieve very high code rate; e.g., [28] gives a (n, 3, k) LDPC code with block length n= 2420 and code rate r = 0.95. However, BIBD based codes have a great restriction, namely, they cannot avoid cycles of length greater than four; they exhibit a large number of six-cycles. New methods are needed to design LDPC codes with girth g> 6.
Before leaving this section, we note that there are many other constructions available in the literature that due to space limitations we cannot address. We refer briefly to Margulis’ work [34] that designed LDPC codes with good girth properties based on Cayley graphs. Margulis presents a construction for (n, 3, 6) regular LDPC codes whose girth increases linearly as log n. Constructions for 1/2 rate codes with large girth using Ramanujan graphs [35] are presented in [36].
Both constructions [34], [36] lead to large girth codes but are limited to 1/2 rates. Tanner et al. [37] present a class of group-structured LDPC codes with girth g ≤ 12 based on subgroups of the multiplicative group of a prime field G F(p). Their parity-check matrices have fixed column weight j = 3 and fixed row weight k= 5. The design rate of these codes is only 0.4. Hu et al. propose in [38] a nonalgebraic method named pro- gressive edge-growth (PEG). Their paper presents examples of irregular codes of girth eight by progres- sively establishing edges between bit and check nodes in an edge-by-edge manner. PEG optimizes the place- ment of a new edge on the Tanner graph with the goal of maximizing the local girth.
Geometry-Based Designs
Here we present geometry-based constructions for LDPC codes with girth g ≥ 6. In [39] and [40], we present constructions for column weight j = 2 LDPC codes with girth up to 20. Here we illustrate briefly how to extend these results for column weight j= 3.
We first introduce an alternative graphical represen- tation for H. Let H be the parity-check matrix of an LDPC code with v parity-check equations, i.e., H is v× n. We represent these parity-check equations by a set X of v points. We call X the point set of the LDPC H matrix. For LDPC codes with j = 3, each column of the H matrix is represented by a triangle composed of three points in X that correspond to the three nonzero elements in this column. We call the resulting graph the structure graph for the LDPC H matrix; we refer to it by GH or simply G.
Consider a point set X = {a1, . . . , a8, b1, . . . , bp} and divide it into two subsets X1= {a1, . . . , ap} and X2= {b1, . . . , bp}. The points in each of these subsets
are positioned in a vertical line. We now label sequen- tially from bottom to top the points in each subset X1
and X2 by ai and bj, 1≤ i, j ≤ p = 8, respectively, as shown in Figure 5. The reader should note that this figure repeats twice the set X . Each edge is between a point ai ∈ X1 and a point bj ∈ X2. Here we need to introduce two concepts: slope of an edge and admissi- ble slope pair.
The slope s of an edge between points ai ∈ X1 and bj ∈ X2 is s = j − i . Slopes take values in the range
−(p − 1) ≤ s ≤ (p − 1), where p is the number of points in each subset. Hence, there are (2p − 1) possi- ble slopes. Note that we have assigned the points in subset X1 as reference points when calculating the slopes. The number of possible edges with slope s is (p − |s |). In Figure 5, we give examples of edges with slope +2 and −6, when p = 8.
A slope pair (s, s ) is an admissible slope pair (ASP) iff s = −sgn(s ) · (p − |s |), where the slopes s and s will be referred to as mirror slopes. The two slopes+2 and −6, shown in Figure 5, compose an AS. Each ASP (s, s ) allows us to introduce (p − |s |) + (p − |s |) = p edges, and it increases the degree of each point in X by one.
(n, 3, k) LDPC Codes with Girth Eight
We now consider the construction of codes with column weight j= 3 girth g = 8. In the structure graph for (n, 3, k) LDPC codes, each column of the H matrix is represented by a triangle whose three vertices correspond
▲ 5. Edges with specific slopes.
Slope=+2 Slope=–6
a8 a7 a6 a5 a4 a3 a2 a1
a8 a7 a6 a5 a4 a3 a2 a1
b8
b1 b2 b4 b7
b3 b5 b6 b8
b1 b2 b4 b7
b3 b5 b6
There has been renewed interest in turbo codes and LDPC codes because their bit error rate performance
approaches asymptotically the
Shannon limit.
to the three nonzero elements in the column, the col- umn triangles. As long as each edge belongs to a single column triangle, the corresponding LDPC code is free of four-cycles, since two distinct connection lines between two nodes in GH stand for a four-cycle. However, six- cycles are also represented by triangles in the structure graph, the cycle triangles, as shown in Figure 6(a). A tri- angle is a cycle triangle only when its three edges belong to three different columns; otherwise, it is a column tri- angle. In other words, each edge in a cycle triangle is shared with a column triangle. Figure 6(b) shows several examples of triangles in the structure graph of an (n, 3, k) LDPC code: {a, b, f}, {b, c, d}, and {d, e, f} are column triangles; and {b, d, f} is a cycle triangle, since its edges are all shared with the previous triangles.
To construct six-cycle-free (n, 3, k) LDPC codes with high code rates, we introduce as many columns as possible for a given value of v . The selection of columns follows two basic rules: each edge is used at most once to construct column triangles; each new col- umn should not introduce cycle triangles.
Assume v= 3p, with p an integer. We partition these points into three subsets X0, X1, and X2of equal size p.
The points in each subset are aligned in a vertical line, as shown in Figure 7, for p= 9. Like before, an edge in the structure graph must connect points in different
subsets. The section Si represents all the edges between the two neighboring subsets Xi and Xmod(i+1,3); it cor- responds to an ASP set Ai. The slope of each edge in Si
is calculated using a point in Xi as the reference point.
These ASP sets are of the same size. The task is now to find an admissible slope set Ai for each section Xi to obtain as many column triangles as possible without introducing cycle triangles. The following two facts underlie our construction of gir th g = 8 (n, 3, k) LDPC codes. The proofs are omitted here.
Fact 1: In a structure graph, any column triangle or cycle triangle must be composed of three edges in three different sections with slopes s0, s1, and s2, respectively, satisfying mod(s0+ s1+ s2, p) = 0.
Fact 2: Assume the three ASPs (s0, s0), (s1, s1), and (s2, s2) belong to ASP sets A0, A1, and A2, respectively, and that mod(s0+ s1+ s2, p) = 0. Then, after introducing all the edges corresponding to all the three ASPs, p trian- gles occur, and no two of these have a common edge.
To construct (n, 3, k) LDPC codes with girth eight, we need to find three sets Ai of admissible slope pairs one for each of the three sections Si, i = 0, 1, 2. These sets satisfy the following conditions:
▲Condition 1: The three ASP sets have the same cardi- nality Ns, i.e., Ai = {(si 1, si 1), . . . , (siNs, siN s)}.
▲6. (a) A six-cycle in an H matrix and its structure graph.
(b) Triangles in the structure graph of an (n, 3, k) LDPC code.
v1
v6 v2
v4 v7
v5 v6 v3 v2
v4 1 1
1 1
1 1
1 1
1 1
1 1 1 1
1 1 1
1 1
1 1
a
b
c d f e (a)
(b)
▲7. (a) At the top, a triangle in the structure graph when p= 9;
at the bottom, an example of an eight-cycle. (b) The H matrix of a Type-I code with n= 6990 and r = 0.9.
a9
a8
a1 a7
a2 a3 a4 a5 a6
b9
b8
b1 b7
b2 b3 b4 b5 b6
c9
c8
c1 c7
c2 c3 c4 c5 c6
0 500
0 1,000 2,000 3,000 4,000 5,000 6,000 (a)
(b) s1
s1
s2
s2a
s2b s1b
s1a
X1
X0 X2
▲ Condition 2: The slope pairs in each Ai must satisfy the following conditions:
—Condition 2.1: For 1≤ j ≤ Ns, mod(s0 j + s1 j+ s2 j, p) = 0.
—Condition 2.2: If mod(s0i+ s1 j+ s2k, p) = 0, then i = j = k.
By Fact 2, condition 2.1 guarantees that the three slope pairs (s0 j, s0 j ), (s1 j, s1 j ), and (s2 j, s2 j ), one from each ASP set, introduce p column triangles. Condition 2.2 guarantees that no cycle triangles are introduced.
We developed an algorithm to construct these three ASP sets, but, due to lack of space, we omit its details here. The resulting codes are referred to as type I codes. Figure 7(b) shows the structure of one parity- check matrix H when v= 699, n = 6, 990, and r = 0.9. Reference [41] presents a class of LDPC codes with j= 3 and g = 8 based on permutation matrices that, for example, for a similar code rate r= 8/9 has block shorter length n= 4, 509.
Though type I (n, 3, k) LDPC codes with girth eight have no six-cycles, they will have in general many eight-cycles. We can eliminate some of these eight- cycles by introducing additional conditions on the ASPs. The net effect is to reduce the code rate for a given v. We refer to the resulting codes as type II (n, 3, k) LDPC codes with girth g = 8.
T h e e i g h t - c y c l e s w e d e l e t e h a v e t h e f o r m shown on the bottom of Figure 7(a). These cycles occur when the slopes selected s0a, s0b, s1a, and s1b
satisfy mod(s0a+ s1a, p) = mod (s0b+ s1b, p), where (s0a, s0a ), (s0b, s0b ) ∈ A0, and (s1a, s1a), (s1b, s1b ) ∈ A1.
We add this additional condition when searching for admissible slope sets to avoid these eight-cycles. The H matrix of a type II code is also well structured, similar to that of a type I code.
We expect type II codes to have better decoding performance than type I codes, since they have a small- er number of eight-cycles. Simulation results confirm this. This performance gain is at the cost of a lower code rate for the same parity-check number v, because there are more strict conditions in searching for the admissible slope sets.
Turbo-Structured LDPC Codes
In this section, we present LDPC codes whose Tanner graphs of the associated parity-check matrix H exhibit a specific architecture that is stimulated by the structure of turbo codes; see also [42] and [43]. The Tanner graph of these codes has three components as shown in Figure 8(a): two height-balanced trees—an upper- tree TU, whose leaf-nodes are bit nodes (solid circles), and a lower-tree TL, whose leaf-nodes are check nodes (solid squares)—and an interleaver that “couples’’ in a turbo-like manner the leaf-nodes of TU to the leaf- nodes of TL. We refer to such codes as turbo-struc- tured LDPC (TS-LDPC) codes or turbo-like LDPC codes. The height of each tree, i.e., the number of lay- ers in each tree, is h . The first layer of the upper tree TU reduces to a single check node C∗, the root, as shown in Figure 8(a), while the root of TL is a bit node V∗. We note that either subtree TU or TL, or both, can be missing. If both are absent, we refer to the codes as flattened TS-LDPC codes.
▲8. (a) Turbo-structured LDPC code: h= 4, j = 3, and k = 4. (b) Auxiliary nodes in the upper tree TU.
Auxiliary Nodes TU C*
TU
TL
V*
Interleaver
(a) (b)
The structure formed by the edges connecting the leaf-nodes of TL and the leaf nodes of TU is the inter- leaver I. Because we are interested in regular codes, we let all the bit nodes have uniform degree j and all the check nodes have the same degree k; see, for example, the Tanner graph for a TS-LDPC code with h = 4, j = 3, and k = 4 in Figure 8(a). To achieve uniform degree, note that the roots of TU and of TL, C∗, and V∗, respectively, are connected to each other by the dashed line in the TS-LDPC code in Figure 8(a). The code rate for a TS-LDPC code is r = 1 − ( j/k). For example, if a code rate r = 8/9 and column-weight-six LDPC code is desired, simply let j = 6 and k = 54 in each of the component trees.
The design of TS-LDPC codes with large girth is facilitated by their specific architecture. By construc- tion, each subtree TU and TL is, in isolation, free of cycles. The cycles are introduced by the interleaver. We discuss briefly below the methodology to design TS- LDPC codes with column weight j= 2 and girth
g = 20 and codes with j ≥ 3 and g = 8.
We comment that the codes we present here are turbo like from the decoder point of view, i.e., from the parity-check matrix H and its associated Tanner graph. This stands in sharp contrast and should not be confused with the codes presented in [44] and [45]
that combine two LDPC codes as component codes in the encoder side. We also note that [41] designs graph based codes for column weight j = 2 and girth g up to 12 that, in the context of TS-LDPC codes, have no lower tree. The technique we discuss in this article can design TS-LDPC codes with arbitrary col- umn weight j .
Interleaver Design
By construction, each leaf-node in the upper tree TU
is connected to q= j − 1 leaf-nodes in TL. This means our TS-LDPC interleaver is a 1-to-q mapping while, usually, interleavers ar e a 1-1 mapping between elements of two sets with the same size. To get a standard interleaver, we introduce “auxiliary nodes’’ (solid triangles) as shown in Figure 8(b). For each leaf-node in TU, we add j− 1 auxiliary nodes as its children. Similarly, each leaf-node in TL has k− 1 auxiliary nodes as its descendants. Denote by AU
the set containing all the auxiliary nodes in TU and by AL the set containing all the auxiliary nodes in TL. Then, designing the interleaver corresponds to
finding an appropriate 1-1 mapping between ele- ments of AU and AL. We observe that a cycle con- tains at least two auxiliar y nodes in TU and two auxiliary nodes in TL. For convenience, and depend- ing on how many auxiliary nodes a cycle involves, we group the cycles into two disjoint categories: type I and type II cycles. Type I cycles contain four and only four auxiliar y nodes, two from TU and two from TL; type II cycles contain more than four auxil- iary nodes. In the sequel, by the girth of a type I or of a type II cycle we mean the length of the shortest type I or type II cycle, respectively, present in the graph.
To design large-girth LDPC codes, we proceed as follows. First, we develop a method, the symbol-wise reversal and shift, that maximizes the girth of type I cycles as determined from the height h of the subtrees.
Second, we present conditions to eliminate type II cycles of length four and six. We note that for flattened TS-LDPC codes only type II cycles are present.
(p– q)-Alternate-Decimal Format
Let the subtrees TU and TL have height h , the bit nodes degree j , and the check nodes degree k. Let p = k − 1 and q = j − 1. Each subtree has [(k − 1)( j − 1)]h/2 auxiliary nodes that are indexed from 0 to [(k − 1)( j − 1)]h/2− 1. The nodes in the upper subtree TU are indexed in a p− q-alternate-dec- imal format, labeled by Xp−q, that we introduce now.
In this format, we need only h digits, where h is the height of the tree, to represent the label Xp−q. These digits xi are numbered from one to h , starting from the rightmost digit; we refer to the position of the digit xi as the i th-coordinate in the (p − q)-alternate- decimal format. The odd coordinates take values zero to q− 1, and the even coordinates take values zero to p− 1. Similarly, we index all the auxiliary nodes of TL
in a (q − p)-alternate-decimal; we label these digits from left to right and refer to the position of the digit xi as the i th-coordinate of the (q − p)-alternate-deci- mal representation. We provide an example. With ref- erence to Figure 8(b) where the upper tree has height h = 4, the index Xp−q of an auxiliar y node in the upper tree TU is
Xp−q = x4 p
x3
q
x2
p
x1
q
=
x4× p1q2+ x3× p1q1 + x2× p0q1+ x1× p0q0
10, (1)
where (·)10represents the decimal value of Xp−q. Symbol-Wise Reversal and Shift Operators
The symbol-wise reversal operator πs(·) applied to the label Xp−q represented in (p − q)-alternate-decimal form with h coordinates exchanges the digits at the i th- and (h + 1 − i)th-coordinates, i.e.,
An LDPC code is a special class
of linear block codes whose
parity-check matrix has a low
density of ones, i.e., is sparse.
πs(Xp−q) = x1
q
x2
p
x3
q
x4
p
.
We now introduce symbol-wise shifts. We represent by ˙+ the symbol-wise addition. Using this addition, we add in (q − p)-alternate-decimal format the shift Sq−p
to the index πs(Xp−q) to obtain a new index. For exam- ple, let πs(Xp−q) = x1x2x3x4and Sq−p = s1s2s3s4, then
πs
Xp−q ˙+ Sq−p = y1y2y3y4,
where yi = xi ˙+ si = mod (xi + si, divi) . where divi = p if i is even and divi = q if i is odd.
Note that with symbol-wise addition there is no carry.
Similarly, we define symbol-wise subtraction ˙−.
Type I Cycles
Type I cycles are avoided by choosing an arbitrary shift S in (q − p)-alternate-decimal notation and by simply
connecting the auxiliary node Xp−q in TU to the auxil- iary node πs(Xp−q) ˙+ S in TL. It can be shown that this rule maximizes the girth of type I cycles.
Type II Cycles
To avoid type II cycles, we start by clustering the auxil- iary nodes of TU that have the same digit at the left- most coordinate in their (p − q)-alternate-decimal index in k− 1 groups. Likewise, we assemble the auxil- iary nodes of TL according to the values of their left- most coordinates into ( j − 1) groups. We now discuss the shift Si,m connecting (any of the) nodes in group i in TL to (any of the) nodes in group m in TU. For dif- ferent i and m, the shifts Si,m may be the same or dif- ferent. Hence, there are ( j − 1)(k − 1) shifts Si,m to adjust to prevent type II cycles of short length.
Fact 3: Consider two groups of nodes m and n in TU and two groups i and j in TL. If the correspon- ding shifts satisfy Si,m ˙+ Sj,n= Si,n ˙+ Sj,m, then no
▲9. (a) Type-II four-cycle. (b)–(d) three type-II six-cycles.
Group m
Group i Group j
Group n
Group n
Group j Group i
Group m Group m
Group j Group n
Group i
Group l Group m Group n
Group k Group j
Group i
TU
TL TU
TL
TU
TU
TL TL
(a) (b)
(c) (d)
A
F
E
A B D
E D
A
B
C C
A C E
B D
B D
C a1
b1 b2 d2 d1
a2 c1 c2
Si,m
Sj,m Si,n
Sj,n Si,l
Si,m
Sj,n Sk,n
Sk,j
Si,m
Sj,m Si,n Sj,n
Si,m
Si,n
Sj,n Sj,m
Sj,m
type II 4-cycle is formed among these four groups.
To prevent type II six-cycles, we first note that the only possible type II six-cycles are the ones displayed in Figure 9(b)–(d). Fact 3 is then extended such that these type II six-cycles are avoided. Due to lack of space, we present only the conditions on the shifts that prevent the type II six-cycles in Figure 9(c): Si,n˙−Sj,n˙+Sj,m
˙−Si,m > pq = (k − 1)( j − 1). Similar conditions can be derived for the other type II six-cycles and, in general, for type II 2l -cycles.
By choosing suitable shifts Su,vfor u= 1, . . . , (k − 1) and v= 1, . . . , ( j − 1), we can prevent type II cycles of length 4, 6, and so on up to g − 2 where g is the desired girth of the code. Figure 10(a) illustrates the 1, 521 × 6, 084 matrix H designed by this method and that corresponds to a (6,084, 3, 12) TS-LDPC code with girth g = 8. Matrix H clearly exhibits the upper and lower trees TU (thick dashed line) and TL (thin
solid line) and the interleaver (cloud of points). Along the solid (thin) lines in H there is a single one in each row, while along the dashed thicker diagonals there are 11 ones in each row, so that per row there are 12 ones.
Each row in the cloud in H has 11 ones also.
Designing LDPC codes with column weight j = 2 is a much simpler task, and details are found in [43];
Figure 10(b) shows a (13,120, 2, 4) TS-LDPC with rate r = 1/2 and girth g = 20.
TS-LDPC codes provide efficient memory utiliza- tion. Generically, an (n, j, k)-LDPC code is represent- ed by an m× n parity-check matrix H. An efficient direct representation of H exploits its sparseness to record only the nonzero column indices in each row, hence, n× j indices are recorded. In contrast, with TS-LDPC codes, we only need to record the (k − 1) × ( j − 1) matrix S of shifts. For example, for the j = 3 LDPC code with H shown in Figure 10(a), rather than storing the 6, 084 × 3 = 18, 252 column indices where the ones are located, we need to store only the (12 − 1) × (3 − 1) = 22 shifts, which signifi- cantly reduces the memory required to store the parity- check matrix H.
Simulation Results
We compare by simulation the BER of the geometry- based designs of LDPC codes (GB-LDPC) and of the turbo-structured LDPC codes (TS-LDPC) with the BER of randomly constructed LDPC codes in addi- tive white Gauss noise (AWGN) channels.
The codes are decoded with the sum-prod- uct algorithm [9], and we adopt the rate- adjusted signal to noise ratio (SNR) defined in [46] SNR1= 10 log10
Eb/ 2rσ2
, where SNR2= 10 log10[Eb/2σ2] is the usual SNR. The dif ference SNR1− SNR2=−10 log r may be signifi- cant because r < 1.
Figure 11(a) compares the BER perform- ance for three (n = 4368, 2, k) LDPC codes with rate r = 1/2: a random, a GB-, and a TS-LDPC code. The GB- and the TS-LDPC codes both have girth g= 16. In the high SNR region, the GB- and the TS-LDPC codes outper form the random code: at BER= 10−5 this gain is 1.1 and 1.2 dB, respectively. In the low SNR regime, the GB-LDPC code exhibits a small perform- ance loss, while the TS-LDPC code has per- formance similar to that of the random code.
Figure 11(b) compares the BER perform- ance for an (n, 2, k) GB-LDPC code with gir th 20 with a random (n, 2, k) LDPC code. The GB-LDPC code outperforms the random LDPC code by 1.4 dB at BER= 10−5. These plots show that (n, 2, k) LDPC codes with large girth out- perform random codes in the high SNR
▲10. Parity-check matrix H for (n, j, k) TS-LDPC code with rate r and girth g. (a) (6,084, 3, 12), r= 3/4, g = 8 and (b) (13,120, 2, 4), r = 1/2, g = 20.
Interleaver
Interleaver
TL
TL TU
TU 0
500
1,500
0 1,000 2,000 3,000 4,000 5,000 6,000
0 1,000 2,000
2,000 3,000
4,000 6,000 8,000 10,000 12,000 4,000
5,000 6,000 0
(a)
(b)
The Tanner graph is a special type of graph, a bipartite graph, where the nodes divide into two disjoint classes with edges only between nodes in the two
different classes.
region. This is well explained by the fact that, for LDPC codes with column weight j = 2, the minimum distance dmin= g /2, where g is the girth, and that, in the high SNR region, dmin is a dominant factor in determining the code BER performance.
Figure 12(a) compares the BER performance of two (n = 6, 990, 3, k) codes with rate r = 9/10: a GB- LDPC code with girth g= 8 and a random LDPC code. These codes show similar BER performance across the SNR region tested, though the GB-LDPC code out- performs the random LDPC code by 0.02 dB at BER= 10−5. At higher SNR, we expect the GB-LDPC code to outperform the random code.
Figure 12(b) compares the BER performance for two (n = 6, 986, 3, k) codes with rate r = 11/14: a type II GB-LDPC code with girth g = 8 and a random LDPC code. The codes show similar BER performance in the low SNR region; however, in the high SNR region, the GB-LDPC code outperforms the random LDPC code by 0.15 dB at BER= 10−5.
▲11. Comparison of BER performance for random code with (n, 2, k) GB- and TS-LDPC codes: (a) girth 16 and (b) girth 20 (GB-LDPC code only).
Random LDPC GB-LDPC (g=16)
Random LDPC GB-LDPC (g=20) TS-LDPC (g=16)
7
Bit Error Rate (BER)Bit Error Rate (BER)
10–2
10–3
10–4
10–5
10–6
10–7
10–3
10–4
10–5
10–6
10–7
SNR (dB) (a)
(b) SNR (dB)
3 3.5 4 4.5 5 5.5 6 6.5
4 4.5 5 5.5 6 6.5 7
▲12. BER performance. (a) Type I (n, 3, k) GB-LDPC code with g= 8 and random LDPC code, r = 9/10. (b), (c) Type II (n, 3, k) GB-LDPC code with g= 8, and random LDPC code, r = 11/14.
(c) (n, 3, k) TS-LDPC code with g= 8 and random code, r = 3/4.
Bit Error Rate (BER)
10–1
10–6 10–5 10–4 10–3 10–2
Random LDPC Type-I GB-LDPC (g=8)
SNR (dB) (a)
3.4 3.6 3.8 4.0 4.2 4.4
Bit Error Rate (BER)
10–1
10–7 10–6 10–5 10–4 10–3 10–2
Random LDPC Type-II GB-LDPC (g=8)
SNR (dB) (b)
2 2.5 3 3.5
Bit Error Rate (BER)
10–0
10–8 10–6 10–4 10–2
Random LDPC TS-LDPC
SNR (dB) (c)
2.2 2.4 2.6 2.8 3.0
