An Efficient Algorithm for Finding Dominant Trapping Sets of LDPC Codes
aa r X i v : . [ c s . I T ] A p r An Efficient Algorithm for Finding DominantTrapping Sets of LDPC Codes ∗ Mehdi Karimi,
Student Member, IEEE and Amir H. Banihashemi,
Senior Member, IEEE
Abstract
This paper presents an efficient algorithm for finding the dominant trapping sets of a low-density parity-check(LDPC) code. The algorithm can be used to estimate the error floor of LDPC codes or to be used as a tool todesign LDPC codes with low error floors. For regular codes, the algorithm is initiated with a set of short cyclesas the input. For irregular codes, in addition to short cycles, variable nodes with low degree and cycles with lowapproximate cycle extrinsic message degree (ACE) are also used as the initial inputs. The initial inputs are thenexpanded recursively to dominant trapping sets of increasing size. At the core of the algorithm lies the analysis ofthe graphical structure of dominant trapping sets and the relationship of such structures to short cycles, low-degreevariable nodes and cycles with low ACE. The algorithm is universal in the sense that it can be used for an arbitrarygraph and that it can be tailored to find a variety of graphical objects, such as absorbing sets and Zyablov-Pinsker(ZP) trapping sets, known to dominate the performance of LDPC codes in the error floor region over differentchannels and for different iterative decoding algorithms. Simulation results on several LDPC codes demonstratethe accuracy and efficiency of the proposed algorithm. In particular, the algorithm is significantly faster than theexisting search algorithms for dominant trapping sets.
I. I
NTRODUCTION E STIMATING the error floor performance of low-density parity-check (LDPC) codes under iterativemessage-passing decoding, and the design of LDPC codes with low error floors have attracteda great amount of interest in recent years. The performance of LDPC codes under iterative decodingalgorithms in the error floor region is closely related to the structure of the code’s Tanner graph. Forthe binary erasure channel (BEC), the problematic structures are stopping sets [10]. In the case of thebinary symmetric channel (BSC) and the additive white Gaussian noise (AWGN) channel, the error-pronepatterns are called trapping sets [30], near codewords [24] or pseudo codewords [38]. Among the trappingsets, the so-called elementary trapping sets are shown to be the main culprits [30], [17], [7], [26], [16],[48]. Related to this, it is demonstrated in [8] that for some structured LDPC codes decoded by iterativealgorithms over the AWGN channel, a subset of trapping sets, called absorbing sets , determine the error ∗ A preliminary version of part of this work appeared in Proc.
Brest, France, Sept. 6 - 10, 2010. floor performance. In fact, in an overwhelmingly large number of cases, dominant absorbing sets appearto be elementary trapping sets.For a given LDPC code, the knowledge of dominant trapping sets is important. On one hand, efficientmethods for estimating the error floor of an LDPC code, which rely on the importance sampling technique,operate by biasing the noise toward the dominant trapping sets of the code, see, e.g., [7]. On the otherhand, by knowing the dominant trapping sets, several decoder modifications can be applied to improvethe error floor performance (see, e.g., [4], [11]). Furthermore, the knowledge of dominant trapping setscan be used to design LDPC codes with low error floor. Related to this, Ivkovic et al. [14] applied thetechnique of edge swapping between two copies of a base LDPC code to eliminate the dominant trappingsets of the base code over the BSC. This was then generalized by Asvadi et al. [1] to cyclic liftings ofhigher degree to construct quasi-cyclic LDPC codes with low error floor. While the knowledge of theproblematic sets that dominate the error floor performance is most helpful in the design and analysis ofLDPC codes, attaining such knowledge, regardless of differences in the graphical structure of these sets,is a hard problem. For instance, it was shown in [27], [20], [23] that the problem of finding a minimumsize stopping set is NP hard. McGregor and Milenkovic [23] showed that not only the problem of findinga minimum size trapping set, but also the problem of approximating the size of a minimal trapping set isNP hard, regardless of the sparsity of the underlying graph.It should be noted that while the majority of the literature on estimating the error floor of LDPC codesrely on finding the dominant trapping sets, as an eventual result of decoder failure, in [42], [44], [43],Xiao and Banihashemi took a different approach. By focussing on the input error patterns that cause thedecoder to fail, they developed a simple technique to estimate the frame error rate (FER) and the biterror rate (BER) of finite-length LDPC codes over the BSC [42]. The complexity of this technique wasthen reduced in [44], and the estimation technique was extended to the AWGN channel with quantizedoutput in [43]. In this work, unlike [42], [44], [43], we are particularly interested in the examination of thegraphical structure of the problematic sets which dominate the error floor performance. This informationis then used to efficiently search for these sets.The complexity of the exhaustive brute force search method for finding problematic structures of size t in a code of length n becomes quickly infeasible as n and t increase. Efficient search algorithms havebeen devised to find small (dominant) stopping and trapping sets [40], [7], [32], [44], [41], [2], [21].The reach of these algorithms however is still very limited. For example, the complexity of the algorithmof [40], [41] is only affordable for codes with lengths up to ∼ . Even for these lengths, the algorithm can only find trapping sets of maximum size with only one or two unsatisfied check nodes. Thisis while for many codes, some of the dominant trapping sets may have larger size and/or more thantwo unsatisfied check nodes. In [37] and [29], the authors proposed to build a database of all possibleconfigurations for trapping sets of different sizes in a graph with specific degree distribution and girth.They then used a parent-child relationship between the trapping sets of different sizes to simplify thesearch of the larger trapping sets. This method was used to find the dominant trapping sets of left regularLDPC codes with left degree [37]. The method proposed in [37] however becomes very complex whenthe degree of variable nodes, and in turn the number of possible configurations increases. The applicationof this method becomes even more difficult when dealing with irregular LDPC codes as for such codes,there may be a large number of possible configurations for each type of trapping set, due to the varietyof variable node degrees. Even for the left regular graphs with small left degrees, the number of possibleconfigurations becomes quite large for the larger trapping sets. It is therefore important to look for moreefficient algorithms to find the problematic structures that dominate the error floor performance of LDPCcodes.In this paper, we study the problematic graphical structures that dominate the error floor performanceof LDPC codes, collectively referred to as trapping sets, and demonstrate that they all contain at least oneshort cycle (with a small exception of some of the trapping sets of irregular LDPC codes with degree-2variable nodes). By examining the relationships between cycles and trapping sets, we devise an efficientalgorithm to find dominant trapping sets of an LDPC code. The algorithm is initiated by a set of shortcycles as input. Each cycle is then expanded recursively to trapping sets of increasing size in a conservativefashion, i.e., the expanded sets all have the smallest size larger than the size of the current set, and each ofthem will be used as a new input to the next step of the algorithm. It should be mentioned that althoughour algorithm uses the topological relationships between the small trapping sets and the larger ones, it isdifferent from the method of [37] in several ways. Our algorithm is not based on the knowledge of theexact structure of trapping sets, and hence does not need to build a database. In fact, instead of checkingall the possible configurations to find the existing ones in a graph, it directly and efficiently finds thoseexisting configurations, and so it is much faster. Moreover, unlike the method of [37], our algorithm usesa general framework for all the degree distributions and girths (with a small exception of some of thetrapping sets of irregular LDPC codes with degree-2 variable nodes). The proposed algorithm is applicableto any Tanner graph (structured or random) and can be tailored to find a variety of graphical structures,such as elementary trapping sets and absorbing sets among others. For structured graphs, such as those of quasi-cyclic or protograph codes, one can use the existing automorphisms in the graph to further simplifythe search. Results on several LDPC codes verify the high efficiency and accuracy of the algorithm. Forexample, for the tested codes, the search speed is improved by a factor of 10 to 100 compared to themethods of [2] and [7].The remainder of this paper is organized as follows. Basic definitions and notations are provided inSection II. In Section III, we develop the proposed algorithm. Section IV presents the modification neededfor irregular LDPC codes. Section V includes some numerical results. Section VI concludes the paper.II. D EFINITIONS AND N OTATIONS
Let G = ( L ∪ R , E ) be the bipartite graph, or Tanner graph, corresponding to the LDPC code C , where L is the set of variable nodes, R is the set of check nodes and E is the set of edges. The notations L and R refer to “left” and “right”, respectively, pointing to the side of the bipartite graph where variable nodesand check nodes are located, respectively. The degree of a node v ∈ L ( or R ) is denoted by d ( v ) . Fora subset S ⊂ L , Γ( S ) denotes the set of neighbors of S in R . The induced subgraph of S , representedby G ( S ) , is the graph containing nodes S ∪ Γ( S ) with edges { ( u, v ) ∈ E : u ∈ S , v ∈ Γ( S ) } . Theset of check nodes in Γ( S ) with odd degree in G ( S ) is denoted by Γ o ( S ) . Similarly, Γ e ( S ) representsthe set of check nodes in Γ( S ) with even degree in G ( S ) . The subgraph resulting from removing thenodes of Γ o ( S ) and their edges from G ( S ) is denoted by G ′ ( S ) . In this paper, we interchangeably use theterms satisfied check nodes and unsatisfied check nodes to denote the check nodes in Γ e ( S ) and Γ o ( S ) ,respectively. Given a Tanner graph G = ( L ∪ R , E ) , the following objects play an important role in theerror floor performance of the corresponding LDPC code: Definition 1: i) A set
S ⊂ L is an ( a, b ) trapping set if |S| = a and | Γ o ( S ) | = b . The integer a is referred to as the size of the trapping set S .ii) An ( a, b ) trapping set S is called elementary if all the check nodes in G ( S ) have degree one or two.iii) A set S ⊂ L is an ( a, b ) absorbing set if S is an ( a, b ) trapping set and if all the nodes in S areconnected to more nodes in Γ e ( S ) than to nodes in Γ o ( S ) .iv) A set S ⊂ L is an ( a, b ) fully absorbing set if S is an ( a, b ) absorbing set and if all the nodes in L \S have strictly more neighbors in R \ Γ o ( S ) than in Γ o ( S ) .v) A set S ⊂ L is a k -out trapping set [40] if Γ o ( S ) contains exactly k nodes of degree one in G ( S ) .vi) Let G = ( L ∪ R , E ) be a left-regular bipartite graph with left degree l . A set S ⊂ L is a Zyablov-Pinsker (ZP) trapping set [23] if every node of S is connected to less than l − ⌊ ( l − / ⌋ nodes in Fig. 1. Two lollipop walks of length . Γ o ( S ) .The ZP trapping sets are the trapping sets of the Zyablov-Pinsker bit-flipping algorithm [49] over theBSC [23]. It should also be noted that for odd values of l , the definitions of ZP trapping sets and absorbingsets are identical.It is important to note that Definitions 1(ii) – 1(vi) are all special cases of a trapping set in Definition 1(i).In the rest of the paper, therefore, we collectively refer to them as trapping sets. Distinctions will be madeas necessary. Trapping sets with smaller values of a and b are generally believed to be more harmful toiterative decoding. Loosely speaking, such trapping sets are called dominant . To measure how harmful atrapping set really is, one can use techniques such as importance sampling [7] to measure the contributionof the trapping set to the error floor. This contribution and the dominance of a trapping set (comparedto others) would also depend on the channel model and the iterative decoding algorithm, as well as thedetailed structure of the Tanner graph (not just the values of a and b ).In a graph G = ( V, E ) with the set of nodes V and the set of edges E , a lollipop walk of length k isdefined as a sequence of nodes v , v , . . . , v k +1 in V such that v , v , . . . , v k are distinct, v k +1 = v m forsome m ∈ [2 , k ] , and ( v i , v i +1 ) ∈ E for all i ∈ { , . . ., k } . Fig. 1 shows two lollipop walks of length .The lollipop walk in Fig. 1 ( a ) is represented as v v v v v v v v . A cycle can be considered as a speciallollipop walk if the definition is extended to m = 1 . The length of the shortest cycle in a graph G isdenoted by g and is called the girth of G .III. D EVELOPMENT OF THE P ROPOSED A LGORITHM
A. Graphical Structure of Trapping Sets
Without loss of generality, we assume that the induced subgraph of a trapping set is connected.Disconnected trapping sets can be considered as the union of connected ones. Moreover, to the bestof our knowledge, almost all the structures reported as dominant trapping sets (of regular LDPC codes) inthe literature have the property that every variable node is connected to at least two satisfied check nodesin the induced subgraph. We thus focus on trapping sets with this property except for irregular LDPC
Fig. 2. The induced subgraph of a trapping set. codes, where we relax this condition for degree-2 variable nodes. As an example, the subgraph in Fig. 2does not satisfy this condition. (Variable nodes and check nodes are represented by circles and squares,respectively.) Removal of node v and its edges however makes the subgraph satisfy the condition. Thefollowing lemma proves this property for certain absorbing and ZP trapping sets. Lemma 1:
Suppose that
S ⊂ L is an absorbing set (ZP trapping set) in G = ( L ∪ R, E ) , and that forall variable nodes v ∈ S , we have d ( v ) ≥ ( d ( v ) ≥ ). Then each variable node v ∈ S is connected toat least two satisfied check nodes in G ( S ) . Proof:
The proof follows from the definition of absorbing and ZP trapping sets.For small trapping sets, which dominate the error floor performance, it is unlikely to see check nodesof degree larger than in their subgraphs, i.e., most of the dominant trapping sets are elementary [7],[30]. Related to this, almost all the trapping sets reported as the dominant trapping sets of practical LDPCcodes are elementary. In fact, it can be shown that the sizes of non-elementary trapping sets for left-regulargraphs are generally larger than those of elementary ones (cf. Lemma 7 in Appendix A). Example 1:
For left-regular LDPC codes with left degree 4 and girths 6, 8 and 10, lower bounds onthe sizes of non-elementary trapping sets S with less than 3 unsatisfied check nodes and with at least onesatisfied check node of degree larger than 2 in G ( S ) , are 7, 14 and 22, respectively (based on Lemma7 in Appendix A, and by choosing b = 2 ). Moreover, for the same conditions, the minimum sizes ofnon-elementary trapping sets S with at least one unsatisfied check node of degree larger than 1 in G ( S ) (and without satisfied check nodes of degree larger than 2 in G ( S ) ) are at least 5, 11 and 17, respectively.This is while for the same scenario, the code can have elementary trapping sets of size 5, 8 and 17,respectively.In the following, we develop our search algorithm mainly for elementary trapping sets, and then presentsimple modifications to tailor the algorithm to find non-elementary trapping sets.In the rest of the paper, we use the notation T to denote the set of all trapping sets S in a graph G whose induced subgraph G ( S ) is connected and for which every node v ∈ S is connected to at least twonodes in Γ e ( S ) . Notation T a is used for the set of all elements in T with size a and T S denotes the setof all elements in T that contain the set S . Naturally, T a S denotes the set of all elements in T of size a Fig. 3. Possible expansions of an elementary trapping set S to a larger elementary trapping set S ′ . (Unsatisfied check nodes of G ( S ′ ) arenot shown.) that contain the set S . In the following, we also assume that the Tanner graph G has no parallel edgesand no node of degree less than 2. B. Expansion of Elementary Trapping Sets
The main idea of the proposed algorithm is to start from a relatively small set of small elementarytrapping sets, which are easy to enumerate, and then recursively expand them to larger elementary trappingsets. To achieve this, we first characterize the expansion of an elementary trapping set to a larger elementarytrapping set through the following lemmas.
Lemma 2:
Let S be an elementary trapping set of size a in T . Then for each elementary trapping set S ′ ∈ T a +1 S (if any), the variable node in S ′ \S is only connected to unsatisfied check nodes of S (i.e., tothe check nodes in Γ o ( S ) ). Proof:
If the node in S ′ \S is connected to any satisfied check nodes of S , then S ′ will have unsatisfiedcheck nodes in Γ o ( S ′ ) connected to variable nodes of S ′ . This contradicts S ′ being an elementary trappingset.Fig. 3 ( a ) depicts an example of the set S ′ discussed in Lemma 2. (It should be noted that in all theconfigurations of Fig. 3, including 3 ( a ) , unsatisfied check nodes of G ( S ′ ) are not shown.) Lemma 3:
Suppose that A = { a , ..., a i , a i +1 , ..., a I } is the sorted set of sizes of the elementary trappingsets in T in increasing order. Let S be an elementary trapping set of size a i in T . If a i +1 > a i + 2 , thenfor each elementary trapping set S ′ ∈ T a i +1 S (if any), the set S ′ \S is connected to zero satisfied check nodes of S (i.e., nodes in Γ e ( S ) ) and to only one or two unsatisfied check nodes of S (i.e., nodes in Γ o ( S ) ). If the set S ′ \S is connected to two nodes in Γ o ( S ) , then there is no cycle in G ( S ′ \S ) . If the set S ′ \S is connected to only one node in Γ o ( S ) , then there is exactly one cycle in G ( S ′ \S ) . Proof:
If any variable node in S ′ \S is connected to Γ e ( S ) , then G ( S ′ ) contains satisfied check nodesof degree or higher, or unsatisfied check nodes of degree greater than . Both are in contradiction with S ′ being an elementary trapping set.Since S ′ is an elementary trapping set, there cannot be more than one connection between each node of Γ o ( S ) and the nodes in S ′ \S . To see this, consider a node v ∈ S ′ \S which is connected to Γ o ( S ) . Node v can have only one connection to Γ o ( S ) because otherwise, all the other nodes in S ′ \S can be removedand we will end up with an elementary trapping set of size a i + 1 in T , which is in contradiction withthe assumption of the lemma.Now suppose that there are at least 3 connections between the variable nodes in S ′ \S and Γ o ( S ) .Based on the discussion in the previous paragraph, this means that there are at least variable nodes in S ′ \S each with a single connection to a different check node in Γ o ( S ) . If G ( S ′ \S ) is not connected,then one can remove one of its components and obtain an elementary trapping set of size smaller than a i +1 , which results in a contradiction. If G ( S ′ \S ) is connected, then one can find the shortest paths in G ( S ′ \S ) between every two variable nodes of S ′ \S that are connected to Γ o ( S ) , and among them selectthe one with the least number of nodes. By keeping the nodes on the selected path and removing all theother nodes in S ′ \S , one can then obtain an elementary trapping set of size smaller than a i +1 , which isagain a contradiction. We therefore conclude that the number of connections between the variable nodesin S ′ \S and Γ o ( S ) must be strictly less than 3.For the case that S ′ \S is connected to exactly two nodes in Γ o ( S ) , there must be two different variablenodes v and v ′ of S ′ \S corresponding to those connections. Also, there must be no cycles in G ( S ′ \S ) .Otherwise, one can remove all the variable nodes on the cycle except those on the shortest path between v and v ′ , and obtain an elementary trapping set larger than a i but smaller than a i +1 . This contradicts thelemma’s assumption. Fig. 3 ( b ) is an example of the case where S ′ \S is connected to exactly two nodesin Γ o ( S ) .The proof for the case with one connection is similar and omitted. Fig. 3 ( c ) is an example of thiscase, where the expansion of set S is through a lollipop walk. In both Figs. 3 ( b ) and ( c ) , the dashed lineindicates that more variable and check nodes can be part of the chain. Lemma 4:
Suppose that A = { a , ..., a i , a i +1 , ..., a I } is the sorted set of sizes of the elementary trapping sets in T in increasing order and that a i +1 = a i + 2 . Let S be an elementary trapping set of size a i in T . If the girth of the graph is larger than 4, then for each elementary trapping set S ′ ∈ T a i +1 S (if any),the only possible configuration for G ( S ′ ) is that of Fig. 3 ( b ) , described in Lemma 3, with only 2 variablenodes in S ′ \S . If the girth is 4, then the only possible configurations are those in Figs. 3 ( b ) (with only2 variable nodes in S ′ \S ) 3 ( d ) and 3 ( e ) . Proof:
The proof is similar to that of Lemma 3 and is omitted.
C. Proposed Algorithm
The basic idea behind the proposed algorithm is to construct larger elementary trapping sets byexpanding smaller ones. More precisely, given an elementary trapping set S of size a i at the input,the algorithm finds all the elementary trapping sets S ′ containing S , with the property that their size a i +1 is the smallest size greater than a i . The algorithm then continues by using the sets found in the currentstep as the inputs to the next step and finds the next set of larger elementary trapping sets. Each stepof the algorithm is performed by using Lemmas 2 - 4. The pseudo-code for one step of the proposedalgorithm is given in Algorithm 1. Algorithm 1 : Expansion of input elementary trapping sets to larger ones of size up to k with the numberof unsatisfied check nodes up to T in G = ( L ∪ R , E ) .( L in and L out are the lists of input and output trapping sets, respectively.) Inputs: G and L in . Initialization: L out ← ∅ . repeat Select an element of L in and denote it as t j . Construct a new graph G ′ by removing all the nodes in Γ e ( t j ) and their neighbors from G . i max ← ( k − | t j | ) and G ← ∅ . for each node c in Γ o ( t j ) do Examine the neighborhood of c in G ′ one layer at a time and to the maximum of i max layersin search for paths with i ≤ i max variable nodes between c and the other nodes of Γ o ( t j ) , andlollipop walks with i ≤ i max variable nodes starting from c . Denote G c as the set of all such paths/lollipop walks of shortest length i (if any). if i < i max then i max ← i . G ← G c . else G ← G ∪ G c . end if end for for each element S in G do t ′ ← t j ∪ S . if ( t ′ / ∈ L out ) and ( | Γ o ( t ′ ) | ≤ T ) then L out ← L out ∪ { t ′ } . end if end for until all the elements of L in are selected. Output: L out . Remark 1:
Note that in Line 5 of Algorithm 1, all the satisfied check nodes in G ( t j ) , i.e., the set Γ e ( t j ) ,and their neighboring variable nodes are removed from the graph. This is because, based on Lemmas 2 - 4,such nodes cannot be part of the expansion of an elementary trapping set. Remark 2:
In Line 19 of the algorithm, the threshold value T on the number of unsatisfied check nodesis needed to keep the complexity of the overall search algorithm, which involves multiple applications ofAlgorithm 1, low. A proper choice of T has negligible effect on the ability of the algorithm to find thelarger trapping sets ( a, b ) with small values of b . This is explained in the following example. Fig. 4. An example of a (7 , trapping set (satisfied and unsatisfied check nodes are shown by empty and full squares, respectively) Example 2:
Consider the (7 , trapping set S , shown in Fig. 4. This set belongs to T and contains trapping sets of size , all also in T . These four trapping sets can be each obtained by removing one of thenodes v , v , v and v . As a result, we have (6 , , (6 , , (6 , and (6 , trapping sets, respectively.Among these trapping sets, the (6 , ones have a smaller number of unsatisfied check nodes. Startingfrom each of these two trapping sets, Algorithm finds S . Hence, ignoring the (6 , (or even (6 , and (6 , ) trapping set(s) does not impair the ability of the algorithm to find S . Remark 3:
Based on Lemmas 2 – 4, it can be proved that starting from an ( a, b ) elementary trappingset S , Algorithm 1 will find all the ( a ′ , b ′ ) elementary trapping sets of the smallest size a ′ larger than a that contain S (this requires the removal of the condition | Γ o ( t ′ ) | ≤ T in Line 19). Note that this doesnot imply that by the recursive application of Algorithm 1 one can obtain all the elementary trapping setscontaining S . The following example demonstrates this. Example 3:
Consider the (6 , elementary trapping set S ′ = { v , v , v , v , v , v } in Fig. 5. Assumethat Algorithm 1 starts from the elementary trapping set S = { v , v , v } . Using this input, the outputof the algorithm is { v , v , v , v } . By subsequent applications of the algorithm, the next outputs are { v , v , v , v , v } and { v , v , v , v , v , v , v } , respectively. This means that the algorithm does notfind the trapping set S ′ , although S ′ contains S . (It is however easy to see that if the algorithm startsfrom the set { v , v , v , v } , it will find S ′ .) Fig. 5. An example explaining that the algorithm cannot find all the elementary trapping sets containing a specific elementary trapping set
In fact, the sufficient condition for the algorithm to find a trapping set S ′ of size a j , starting with one ofits subsets S of size a i < a j , is that S ′ has at least one subset in T a S for all a ∈ A, a i < a < a j , where A is defined in Lemma 3.The following example shows that despite the limitation explained in Remark 3 and Example 3, formany cases, the proposed algorithm in fact finds (in a guaranteed fashion) all the trapping sets ( a, b ) with a and b up to certain values. Example 4:
For a left-regular graph with left degree 4 and girth larger than 4, initiating the proposedalgorithm with the set of cycles of length g and g +2 , one can guarantee to find all the elementary trapping sets of size less than with less than unsatisfied check nodes. This can be seen by the inspection of allthe possible structures for such trapping sets and verifying that for each structure, the removal of only onevariable node will result in another trapping set in T . Subsequent removals of such nodes from an ( a, b ) elementary trapping set with a < and b < in T , thus, results in a sequence of embedded elementarytrapping sets in T , each with size only one less than that of its parent. The sequence will always endwith a cycle of length g or g + 2 . This implies that all such trapping sets satisfy the sufficient condition,mentioned earlier, for being found by the algorithm starting from a cycle of length g or g + 2 .Similar results to those of Example 4 can be found for other left-regular graphs. For irregular graphshowever, it is very difficult to provide such guarantees. This is due to the fact that the number of possiblestructures for a trapping set of a given size could be very large in this case. Remark 4:
For irregular LDPC codes, the variable nodes with large degrees cannot be part of smalltrapping sets. This is formulated in the following lemma.
Lemma 5:
In a graph G with girth g > , if an ( a, b ) trapping set S contains a variable node v ofdegree d ( v ) > b , then a ≥ d ( v ) + 1 − b . Proof:
The proof is provided in Appendix A.Based on Lemma 5, for example, for an irregular code with girth larger than , a variable node of degree15 can not participate in an ( a, b ) trapping set with a < and b < . Such results can be used tosimplify the algorithm by removing the large degree variable nodes and their edges from the graph. Remark 5:
It is easy to see that for the left-regular graphs with left degree 3 or 4, all the trapping setsfound by Algorithm 1 are ZP trapping sets. For the left-regular graphs with left degree 3, the obtainedtrapping sets are also absorbing sets.
Remark 6:
Our simulations for many practical LDPC codes show that in almost all the cases, a i +1 ≤ a i + 3 .In the following, we discuss the selection of the initial set of elementary trapping sets. D. Initial Set of Trapping Sets
One of the graphical objects that plays an important role in the structure of trapping sets is a cycle.Tian et al. [36] showed that every stopping set includes the variable nodes of at least one cycle. Relatedto this, the induced graph of the support of a pseudo-codeword always contains at least one cycle [18].In [7], [44], [48], it was shown that an overwhelming majority of dominant trapping (absorbing) sets arecombinations of short cycles. Short cycles are also easy to enumerate [44]. We thus use short cycles as the initial inputs to the proposed algorithm. The following lemma provides more justifications for thischoice. Lemma 6: i) In a left-regular graph G with left degree d l ≥ , if the induced subgraph G ( S ) of an ( a, b ) trappingset S does not contain any cycle, then b ≥ a ( d l −
2) + 2 . The inequality is satisfied with equality forelementary trapping sets.ii) The variable nodes in any shortest cycle (of length g ) of a Tanner graph form an elementary trappingset.iii) Let T be the set of all trapping sets S of a graph G , whose induced subgraph G ( S ) is connectedand for which every node v ∈ S is connected to at least two nodes in Γ e ( S ) . Then for every S ∈ T ,its induced subgraph G ( S ) contains at least one cycle.iv) Suppose that S ⊂ L is an absorbing set of a left-regular Tanner graph G = ( L ∪ R, E ) with left nodedegrees at least 2. Then G ( S ) contains at least one cycle.v) Suppose that S ⊂ L is a ZP trapping set of a Tanner graph G = ( L ∪ R, E ) with node degrees atleast 3. Then G ( S ) contains at least one cycle. Proof:
The proof of Part (i) is provided in Appendix A. The proofs for Parts (ii) and (iii) are simpleand thus omitted. Parts (iv) and (v) follow from Lemma 1 and Part (iii).It can be shown that Part (i) of Lemma 6 can be generalized to the case where variable node degreedistribution is irregular. In this case, the result is modified as b ≥ a ( ¯ d S −
2) + 2 , where ¯ d S is the averagedegree of variable nodes in S . The following example, based on Part (i) of Lemma 6, demonstrates thatcycle-free ( a, b ) trapping sets have relatively large values of b . Example 5:
For a left-regular graph G with left degree 4, any cycle-free ( a, b ) trapping set satisfies b ≥ a + 1) . Such large values of b for a given a would imply that the ( a, b ) trapping set is not dominant.Our simulation results indicate that for denser graphs, the set of short cycles of length g , or g and g + 2 ,where g is the girth, is sufficient to find almost all the small (with, say, a ≤ ) dominant trapping sets.In this case, adding short cycles of larger lengths to the input set has negligible effect on the performanceof the algorithm, while increasing its complexity. For example, we examined a number of randomlyconstructed codes with rates larger than 0.4. The codes had block length 1000 and left-regular Tannergraphs with left degree 5 and girth 6. In all cases, the trapping sets obtained by Algorithm 1 using cyclesof length 6 and 8 as input were identical to those obtained by using cycles of length 6, 8 and 10 as theinput set. For sparser graphs, however, one may need to use short cycles of larger lengths (e.g., g , g + 2 , and g + 4 ) as the initial set. E. Complexity of the Algorithm
The complexity of the algorithm is highly dependent on the short cycle distribution of the graph, whichitself is mostly a function of the degree distribution of the graph (code) [19]. As a result, in general, thecomplexity increases much faster with the increase in the average variable and check node degrees of thegraph than it does with increasing the block length. To have a more detailed analysis of the complexityof Algorithm 1, we note that the total complexity can be divided into two parts: a ) Finding the initialinput set and b ) Expanding the input set to larger trapping sets.Regarding the complexity of Part ( a ) , assuming that an exhaustive brute force search is used to findcycles of length k , say for g ≤ k ≤ g + 4 , the complexity is O ( nd k/ v d k/ c ) , for a ( d v , d c ) regular graph with n variable nodes. This is obtained by considering all the possible paths of length k starting from all the n variable nodes in the graph. The memory required for the storage of all the k -cycles is of order O ( kN k ) ,where N k is the number of k -cycles in the graph. To the best of our knowledge, there is no theoreticalresult on how N k scales with n or the degree distribution of the Tanner graph. Empirical results of [19]however suggest that N k is mainly a function of the degree distribution and is rather independent of n .Regarding the complexity of expanding the input trapping sets to larger ones, consider the expansionof an ( a, b ) trapping set S of a ( d v , d c ) graph. Depending on the size a ′ > a of the smallest trapping set(s) S ′ that contain S , the complexity and memory requirements for finding and storing the sets S ′ woulddiffer. For a ′ = a + 1 , a + 2 and a + 3 , the complexity is O ( bd c ) , O ( bd v d c ) and O ( bd v d c ) , respectively. Thememory requirement for these cases are respectively O ( abd c ) , O ( abd v d c ) and O ( abd v d c ) . To see this, forexample, consider the case where a ′ = a + 1 . To find S ′ , one needs to check at most b ( d c − variablenodes as possible candidates, which corresponds to O ( bd c ) complexity. The memory required to store allpossible trapping sets of size a + 1 obtained through such a search is thus upper bounded by ( a + 1) bd c ,which is of order O ( abd c ) .Based on the above discussions, assuming that the initial set is limited to cycles of length up to g + 4 , and that we only consider trapping sets S ′ of size up to a ′ = a + 3 in the expansion process, thecomplexity of Algorithm 1 will be O ( d v d c ( T P g/ i = g/ N i + nd g/ v d g/ − c )) and the memory requirement willbe O ( T d v d c P g/ i = g/ iN i ) , where T is the maximum number of unsatisfied check nodes in Algorithm 1.It is however important to note that the actual complexity and memory requirements are much less thanwhat these complexity bounds may suggest. In particular, our simulation results show that codes with block lengths up to about 10,000 with a wide variety of degree distributions can be managed using theproposed algorithm on a regular desktop computer. F. Expansion of Non-Elementary Trapping Sets
According to the general definition of trapping sets, any arbitrary set of variable nodes can be consideredas a trapping set. Hence, to expand a connected trapping set S of size a , one just needs to select a variablenode from the neighboring variable nodes, and add it to S to obtain a new trapping set S ′ with size a ′ = a + 1 . This method of expansion leads to an exponentially growing search space. Even by limitingthe search space to the trapping sets in T , i.e., connected trapping sets for which every variable node isconnected to at least two satisfied check nodes, there are still too many configurations for S ′ , especiallywhen a ′ ≫ a . For practical LDPC codes with g > , however, considering a nested sequence of trappingsets, the size of the next larger trapping set a ′ is almost always less than a + 3 .The search for non-elementary trapping sets of size a ′ ≤ a + 3 in a graph with girth g > , canbe performed similar to what was described for the elementary trapping sets with a number of smalldifferences. For non-elementary trapping sets, since there is no limitation on the degrees of the checknodes in G ( S ) , only the variable nodes of S and their edges are removed from the graph. Then the shortestpaths between different check nodes of G ( S ) or the shortest lollipop walks starting from different checknodes of G ( S ) are found. However, it should be mentioned that not all such structures will necessarilysatisfy the condition that each variable node is connected to at least two satisfied check nodes. Afterfinding a candidate trapping set, one should thus check for this condition. In summary, to find the non-elementary trapping sets of size a ′ ≤ a + 3 , the only modifications needed to be applied to Algorithm 1are the followings:5: Construct a new graph G ′ by removing all the nodes of S from G .7: for each node c in Γ( t j ) do
8: Examine the neighborhood of c in G ′ one layer at a time and to the maximum of i max layers insearch for paths with i ≤ i max variable nodes between c and the other nodes of Γ( t j ) , and lollipopwalks with i ≤ i max variable nodes starting from c .19: if ( t ′ ∈ T ) and ( t ′ / ∈ L out ) and ( | Γ o ( t ′ ) | ≤ T )IV. IRREGULAR
LDPC
CODES
For the irregular LDPC codes which do not have variable nodes of degree 2, Algorithm 1 without anymodification can be used to find the dominant trapping sets. As mentioned in Remark 4 of Section III.C, based on the desired sizes of trapping sets, one may also remove the high-degree variable nodes and theiredges from the graph to simplify the algorithm. In the case that the code has variable nodes of degree2, some modifications are needed for the initial input set of the algorithm. In this section, we study theeffect of degree-2 variable nodes on the structure of trapping sets in irregular LDPC codes, and presentsimple steps to find the corresponding trapping sets. A. On the Degree-2 Variable Nodes
It is known that degree-2 variable nodes play an important role in the performance of irregular LDPCcodes. On one hand, to have codes with asymptotic performance close to the capacity, the proportionof degree-2 variable nodes should be as large as possible. This is usually a considerable fraction of thetotal variable nodes of the code. On the other hand, having a large proportion of degree-2 variable nodesresults in a small minimum distance and a high error floor [35]. Cycles containing only degree-2 variablenodes are codewords. Hence, to have a large minimum distance, it is desirable to avoid such cycles,especially the shorter ones. To avoid all cycles of any length containing only degree-2 variable nodes,the number of these nodes n v must be strictly less than the number of check nodes m (i.e., n v < m ).Based on this fact, a class of irregular LDPC codes with n v = m − , called extended irregular repeataccumulate (eIRA) codes was proposed in [46]. It was shown in [46] that these codes exhibit relativelybetter error floor performance compared to the codes constructed by the optimized degree distributionswithout applying this restriction on n v . Related to this, it was proved in [33] that for the case where n v > m , the minimum distance grows only logarithmically with the code length. For the special casewhere n v = m and all the degree-2 variable nodes are part of a single cycle, the minimum distance isa sub-linear power function of the block length [35]. In the following, we study the effect of having alarge fraction of degree-2 variable nodes on the structure of trapping sets in irregular LDPC codes. Example 6:
For all the degree distributions optimized for rate-1/2 LDPC codes on the binary-inputAWGN (BIAWGN) channel [31], to of variable nodes are of degree 2. This implies that, onaverage, every check node in the corresponding codes is connected to about variable nodes of degree 2.The average number of degree-2 variable nodes connected to each check node becomes even larger forthe optimized codes of higher rate. This is explained in the next example. Example 7:
For the optimized degree distribution of rate / over the BIAWGN channel with themaximum variable node degree 10 [31], of variable nodes are of degree 2. This implies that, on In case that the graph contains degree-1 variable nodes as well, a similar approach to the one described in Section IV.B (for findingdominant trapping sets which include degree-2 variable nodes) can be used to find the dominant trapping sets containing degree-1 variablenodes. Fig. 6. Typical trapping sets constructed mostly by the degree-2 variable nodes. average, every check node in a Tanner graph with this degree distribution is connected to about variablenodes of degree 2.Consequently, it is very likely to see chains of degree-2 variable nodes, referred to as , in theTanner graph of LDPC codes with optimized degree distributions. The length of a 2-chain is defined asthe number of the edges in the subgraph induced by the degree-2 variable nodes of the chain. That is,the length of a 2-chain containing k variable nodes of degree 2 is k . A 2-chain of length k is a ( k, trapping set (with the exception of the case where the chain is closed and forms a cycle; in that case, werefer to the 2-chain as a . A 2-cycle of length k , is a ( k, trapping set). Having only 2 unsatisfiedcheck nodes, 2-chains of length k are among the most dominant trapping sets of size k . Fig. 6 ( a ) showsa 2-chain of length 10 (a (5 , trapping set). Note that this trapping set also contains two (4 , , three (3 , and four (2 , trapping sets as its subsets. It is worth noting that although for the cases where n v = m − and n v = m , the graph may have no or only one 2-cycle, it can have many 2-chains ofdifferent lengths. For example, it is easy to see that for the case where m = n v and all the degree-2variable nodes are contained in a single cycle, there are m k , ≤ k ≤ m − .Another aspect of having 2-chains in the Tanner graph of irregular LDPC codes is that they mightparticipate in short cycles with other variable nodes of higher degrees. These cycles have low approximatecycle extrinsic message degree (ACE) (ACE is defined as P i d i − , where the summation is taken overall the variable nodes of the cycle, and d i is the degree of the i th variable node in the cycle [36]). It hasbeen shown that cycles with low ACE deteriorate the error rate performance, and that avoiding them inthe construction of irregular LDPC codes generally improves the error rate [45], [39]. Example 8:
Consider the case where m = n v and all the degree-2 variable nodes are contained ina single cycle. In this case, there exist two 2-chains between any two check nodes of the graph. This implies that every variable node of degree d v > along with the 2-chains connecting its check nodesform several trapping sets with at most d v − unsatisfied check nodes. Example 9:
Fig. 6 ( b ) shows a (7 , trapping set composed of one variable node of degree 3 and achain of six variable nodes of degree 2. Example 10:
The (12 , trapping sets of the (1944 , LDPC code adopted in the IEEE 802.11standard [13] are single cycles of length , each consisting of a 2-chain of length 22 and one degree-3variable node.Even in the cases where n v < m (but not much smaller), it is likely to see cycles mostly constructed by2-chains. Example 11:
Fig. 6 ( c ) shows a (7 , trapping set composed of two variable nodes of degree 3 andfive variable nodes of degree 2.Due to the important role that 2-chains (and 2-cycles) play in the formation of dominant trapping sets,we study the necessary condition to avoid these structures in the following theorem. Theorem 1:
Let m be the number of check nodes and n v be the number of degree-2 variable nodes inthe graph G corresponding to an irregular code C . If G has no 2-chains of length k or larger, for k ≥ (and no 2-cycles of length less than or equal to k ) then m ≥ n v (1 + 1 P k − i =0 ( d c,max − ⌊ i +12 ⌋ ) , where d c,max is the maximum check node degree in G . Proof:
Let G v denote the induced subgraph of degree-2 variable nodes of the graph G . This subgraphcontains no cycle. Otherwise, the length of such a cycle would be at least k + 2 , which would imply theexistence of a 2-chain of length k in G v , and thus in G . This contradicts the assumption of the theorem.The subgraph G v is thus composed of some tree-like components. For each component, the number ofcheck nodes is always larger than the number of variable nodes by one. Therefore the total number ofcheck nodes of the graph is more than the number of degree-2 variable nodes by at least the number ofdisjoint components in G v (some check nodes of G may not appear in G v ). To avoid 2-chains of length k or larger, the maximum number of variable nodes in each component is P k − i =0 ( d c,max − ⌊ i +12 ⌋ (AppendixA, Lemma 8). The minimum number of components in G v is thus ⌈ n v / P k − i =0 ( d c,max − ⌊ i +12 ⌋ ⌉ .Theorem 1 can be used to determine the maximum number of degree-2 variable nodes in an irregulargraph to avoid 2-chains (and 2-cycles) of a specific length. Example 12:
For an irregular code with 1000 check nodes of degree d c = 6 , to avoid (4 , trapping sets corresponding to 2-chains of length 8, the number of variable nodes of degree 2 must be at most910.Theorem 1 can be also used to obtain some information about the existing trapping sets in a code. Example 13:
For the same scenario as that of Example 12 (i.e., m = 1000 , d c = 6 ), the eIRAconstruction [46] results in n v = m − . For these parameters, the smallest value of k whichsatisfies the inequality of Theorem 1 is k = 9 . This implies that the eIRA code will have 2-chains oflength 16 and smaller, corresponding to ( k, trapping sets for all values of k < . B. Finding Trapping Sets of Irregular LDPC Codes
In this section, we present a simple process to find the dominant trapping sets involving degree-2variable nodes. The process can be used in combination with Algorithm 1 to find the dominant trappingsets of irregular graphs containing degree-2 variable nodes. It is important to note that according to thedefinition of absorbing sets, any variable node of degree 2 in these sets is connected to 2 satisfied checknodes. Also, for the trapping sets found by Algorithm 1, each variable node is connected to at least 2satisfied check nodes. Therefore, 2-chains and other trapping sets containing variable node(s) of degree2 with one satisfied check node are neither absorbing sets nor found by Algorithm 1. In fact, it appearsthat being connected to 2 satisfied check nodes is too strong of a condition for a variable node of degree2 to be part of a dominant trapping set. For this reason, we consider also trapping sets whose variablenodes of degree 2 are connected to only one satisfied check node. To obtain such trapping sets usingthe expansion of smaller trapping sets, we consider an ( a − , b ) trapping set S which is expanded to atrapping set S ′ by the connection of a variable node v of degree 2 to an unsatisfied check node of S .Three cases are possible: a ) v is not connected to any other check node of Γ( S ) . In this case, S ′ = S ∪ { v } is an ( a, b ) trappingset. If S is elementary, so is S ′ . b ) v is also connected to a satisfied check node of S . In this case, S ′ = S ∪{ v } is an ( a, b ) non-elementarytrapping set. c ) v is also connected to another unsatisfied check node of S . In this case, S ′ = S ∪ { v } is an ( a, b − trapping set. If S is elementary (or is in the set T ), so is S ′ .Such an expansion of a trapping set can be performed multiple times by adding one neighboring variablenode of degree 2, each time. This is summarized in Algorithm 2. In a general case, Algorithm 2 can beused with Algorithm 1 to expand the trapping sets found by Algorithm 1. This is summarized in Algorithm3. Algorithm 2 : Finding trapping sets of size up to k with the number of unsatisfied check nodes up to T constructed by adding degree-2 variable nodes to the input trapping sets for an irregular LDPC code withthe Tanner graph G = ( L ∪ R , E ) .( L in and L out are the lists of input and output trapping sets, respectively) Inputs: G , L in L out ← ∅ . repeat Select an element of L in with size less than k , and denote it as t . Form the set N ( t ) which contains variable nodes of degree 2 in L \ t that are connected to at leastone unsatisfied check node of t , i.e., to Γ o ( t ) . for each node v in N ( t ) do t ′ ← t ∪ { v } . if ( t ′ ∈ T ) and ( t ′ / ∈ L out ) and ( | Γ o ( t ′ ) | ≤ T ) then L out ← L out ∪ { t ′ } . end if end for until all the elements of L in are selected. Output: L out . Remark 7:
Note that in Algorithm 2, the number of unsatisfied check nodes of the resultant trappingsets never increases. Hence, to find trapping sets of size a with less than b unsatisfied check nodes, oneshould consider all the ( a ′ , b ′ ) trapping sets with a ′ < a, b ′ < b. It should be mentioned that since everysingle variable node of degree d v can be regarded as a (1 , d v ) trapping set, to find the trapping sets withless than b unsatisfied check nodes, we consider also all the variable nodes of degree d v ≤ b as part ofthe initial set. For example, for the case of b = 3 , starting with a single variable node of degree d v = 2 or d v = 3 , two typical structures of the resultant trapping sets are shown in Figs. 7(a) and 7(b), respectively.Note that starting from a degree-2 variable node and performing the above steps results in finding a This condition ensures that each variable node of degree larger than 2 is connected to at least 2 satisfied check nodes. The condition hasno bearing on degree-2 variable nodes. Although this condition may not cover all the trapping sets discussed in Part c of Section IV.B, our simulations show that for the testedcodes, almost all the trapping sets are in fact found by Algorithm 2. The trapping sets that are missed by Algorithm 2 are the ones that can only be obtained by starting from trapping sets with larger number of unsatisfied check nodes. Fig. 7. Typical expansions of degree-2 and degree-3 variable nodes by adding the neighboring degree-2 variable nodes.
Algorithm 3 : Finding trapping sets of size up to k with the number of unsatisfied check nodes up to T for an irregular LDPC code with the Tanner graph G = ( L ∪ R , E ) .( L in and L out are the lists of input and output trapping sets, respectively.) Inputs: G , L in Use L in as the input of Algorithm 1 L out = trapping sets found by Algorithm 1 L in = L out S { low degree variable nodes } Use L in as the input of Algorithm 2 L out = trapping sets found by Algorithm 2 Output: L out . Remark 8:
For irregular codes, in addition to short cycles, cycles with low ACE are also consideredas part of the initial input set of Algorithm 1. This is because these cycles may not be found usingthe expansion process of Algorithm 1. Algorithm 1 finds the smallest trapping sets containing the input,which are usually the combination of the input and a short cycle (or a structure described in Lemmas 2– 4). Since variable nodes of large degree are more likely to be part of such structures, the outputs ofAlgorithm 1 are usually the combinations of the input and variable node(s) of large degree. This is whilecycles with low ACE are generally constructed by low degree variable nodes. Cycles with low ACE canbe easily found by monitoring the ACE value during the execution of a cycle finding algorithm.
Remark 9:
As an alternative approach to using Algorithm 3, one can only use Algorithm 2 with thevariable nodes of low degree and cycles with low ACE as the initial input set, and then recursively expandthem to larger trapping sets. It should however be noted that for the irregular LDPC codes with a small fraction of degree-2 variable nodes, this approach may not find all the dominant trapping sets of the code.V. N UMERICAL R ESULTS
For the simulations, we assume binary phase-shift keying (BPSK) modulation over the AWGN channelwith coherent detection. Notations E b and N are used for the average energy per information bit and theone-sided power spectral density of the AWGN, respectively. A. Regular Codes
We have applied the proposed algorithm successfully to a large number of regular LDPC codes. Here,we only present the results for four of them. The first three examples are random and structured LDPCcodes whose dominant trapping sets have already been reported in the literature and thus provide us witha reference for comparison. The fourth example is a random LDPC code of rate / with variable nodedegree 4. To verify the trapping sets found by the proposed algorithm for this code, we estimate theerror floor using importance sampling [7] based on the obtained trapping sets and demonstrate that theestimation is practically identical to the results of Monte Carlo simulations. The reported running timesin the following examples are for a desktop computer with -GHz CPU and GB of RAM.
Example 14:
We consider an LDPC code constructed by the progressive edge growth (PEG) algorithm[12] ( PEGReg252x504 of [50] ) . This code is left-regular with the left degree 3, and girth 8. The samecode was also investigated in [21] and the distribution of its fully absorbing sets was determined. ForAlgorithm 1, the short cycles of length g , g + 2 and g + 4 were used as the initial input set. The algorithmwas limited to finding trapping sets of maximum size 13, and the threshold T was selected such that onlythe trapping sets with the two smallest values of b for each size were considered. (Using a larger T hasno effect on the accuracy of the results reported here.) Since all the variable nodes have degree 3, all thetrapping sets found by Algorithm 1 are absorbing sets. Fully absorbing sets were found by examiningthe obtained absorbing sets and testing them for the definition of a fully absorbing set. Table I showsthe absorbing sets and the fully absorbing sets found by the proposed algorithm and their multiplicities.In the table, we have also reported the results obtained by the exhaustive search algorithm of [21], forcomparison. (Note that the hyphen notation “-” in the table means that no data was reported.) As canbe seen from Table I, for many classes of trapping sets, the proposed algorithm found exactly the samenumber of fully absorbing sets as the exhaustive search algorithm of [21] did. For the other classes,the difference between the two sets of results is rather small. Moreover, the proposed algorithm found (11 , , (13 , , (10 , and (12 , fully absorbing sets which are out of the reach of the exhaustive search algorithm. It is worth mentioning that the exhaustive search algorithm of [21] took about 7 hours to findonly the first three rows of Table I [21] (needless to say, the larger the size of the absorbing sets, thelonger the running time of the algorithm). This is while Algorithm 1 took only 10 minutes to find all theabsorbing sets listed in Table I. TABLE I D OMINANT A BSORBING S ETS (ABS)
AND F ULLY A BSORBING S ETS OF THE
PEGReg252x504 C ODE O BTAINED BY THE P ROPOSED A LGORITHM AND THE E XHAUSTIVE S EARCH A LGORITHM OF [21]
Trapping Proposed Proposed ExhaustiveSet Algorithm Algorithm Search [21](ABS) (Fully ABS) (Fully ABS) (4, 4) 802 760 760(5, 3) 14 14 14(5, 5) 11279 10156 10156(6, 4) 985 849 849(6, 6) 86391 66352 66352(7, 3) 57 47 47(7, 5) 27176 21810 22430(8, 2) 5 4 4(8, 4) 2610 2258 2270(9, 1) 1 1 1(9, 3) 156 146 146(10, 2) 6 6 6(10, 4) 7929 6691 -(11, 3) 605 558 -(12, 2) 25 24 26(12, 4) 23668 19959 -(13, 1) 1 1 1(13, 3) 2124 1954 -
Example 15:
In this example, we consider the Tanner (155 , code [34]. This code was also investi-gated in [41]. The exhaustive search algorithm of [41] showed that this code has no trapping set of lengthless than with unsatisfied check nodes and has no trapping set of length up to with unsatisfiedcheck node. It was also shown in [41] that the code has
465 (8 , trapping sets.The girth for the Tanner graph of this code is g = 8 . The short cycles of length g , g + 2 and g + 4 wereused as the initial inputs to Algorithm 1. The algorithm was limited to only find trapping sets of maximumsize 12 and the threshold T was selected such that only the trapping sets with the two smallest values of b for each size were considered. Table II shows the trapping sets found by the proposed algorithm andtheir multiplicity. As can be seen in the table, the algorithm found all the 465 (8 , trapping sets amongothers. All the trapping sets in Table II were found in less than minutes.To further verify that the obtained trapping sets do in fact include the dominant ones, we performed Monte Carlo simulations on the code with a 4-bit quantized min-sum decoder over the AWGN channelat signal-to-noise ratio (SNR) of 6.5 dB (which is in the error floor region of this code). Among the error patterns, about were (8 , trapping sets, about were (10 , trapping sets, and only 2 didnot belong to the sets reported in Table II. TABLE II D OMINANT T RAPPING S ETS OF THE T ANNER (155 , C ODE O BTAINED BY THE P ROPOSED A LGORITHM
Trapping Set Multiplicity (4,4) 465(5,3) 155(6,4) 930(7,3) 930(8,2) 465(9,3) 1395(10,2) 1395(11,3) 1860(12,2) 930
Example 16:
As the third example, we consider the Margulis (2640 , code [25], [50]. It is knownthat the most dominant trapping sets of this code are , and , trapping sets [30].The Tanner graph of this code has girth g = 8 . The set of short cycles of length g , g + 2 and g + 4 wasused as the input set of the proposed algorithm. The algorithm was limited to use only the trapping setswith the two smallest values of b for each size. Since the degree of all the variable nodes of this code is3, all the trapping sets found by Algorithm 1 are also absorbing sets. The first column in Table III showsthe dominant absorbing sets found by Algorithm 1. For comparison, the dominant trapping sets obtainedby the algorithm of [2] are listed in the last column of Table III. It should be noted that in [2] there isno condition on the number of satisfied check nodes connected to each variable node. Thus to have afair comparison, we also consider the trapping sets constructed by the combination of trapping sets foundby Algorithm 1 and one of their neighboring variable nodes. The second column of Table III shows thenumber of such trapping sets. As can be seen, for all the trapping set classes, the proposed algorithmperforms at least as well as the algorithm of [2]. Moreover, the required time for the algorithm of [2]was 7 days on a 2.8 GHz PC [2], while the proposed algorithm took about 5 hours to finish. As anothercomparison for the running time of the proposed algorithm, it took the algorithm 55 minutes to find allthe absorbing sets of size less than 15, while the same task took 8.2 hours for the impulse method of [7]on a comparable computer (2.2-GHz CPU with 1 GB RAM). Our simulations indicate that the effect of extra trapping sets found by removing the constraint on the number of satisfied check nodesconnected to each variable node of the trapping set on the error floor performance of the code is negligible. TABLE III D OMINANT T RAPPING S ETS OF THE M ARGULIS (2640 , C ODE O BTAINED BY THE P ROPOSED A LGORITHM AND THE A LGORITHM OF [2]
Trapping Proposed Proposed AlgorithmSet Algorithm Algorithm of [2](Absorbing) (Trapping) (Trapping) (7, 5) 7920 7920 -(8, 6) 106920 > > Example 17:
For this example, we consider a (1008 , random code with variable node degree 4and check node degree 8 constructed by the program of [50]. This code has one cycle of length 4 ( C ).In addition to that, the short cycles of length 6 to 10 were used as the initial input set for Algorithm 1.The algorithm was constrained to find trapping sets of size up to 12 and to use only the trapping sets withthe two smallest values of b for each size. Table IV shows the dominant trapping sets found by Algorithm1 and their multiplicities. It is worth mentioning that none of the trapping sets listed in Table IV containsany of the variable nodes participating in C . The trapping sets reported in Table IV were used to estimatethe error floor of the code using the importance sampling technique described in [7]. Fig. 8 shows theMonte Carlo simulation results for the frame error rate (FER) and the corresponding error floor estimationbased on importance sampling. The results are for a 3-bit min-sum decoder with a maximum numberof 50 iterations. As can be seen in Fig. 8, the estimation closely matches the Monte Carlo simulation,verifying the dominance of the trapping sets found by Algorithm 1. Monte Carlo simulations also revealedthat the most harmful trapping set of this code is the (6 , trapping set. In fact, in almost all the decodingfailures, the decoder converged to the (6,4) trapping set. As can be seen in Table IV, all the trapping setshave at least 4 unsatisfied check nodes. This makes the exhaustive search methods of [40], [41], [21]ineffective for finding the dominant trapping sets of this code. This is while all the trapping sets in TableIV were found in less than 5 minutes by the proposed algorithm. Using code6.c with seed=380. TABLE IV D OMINANT T RAPPING S ETS OF THE (1008 , R EGULAR
LDPC C
ODE ( d v = 4 , d c = 8 ) O BTAINED BY THE P ROPOSED A LGORITHM
Trapping Set Multiplicity (5,6) 15(6,4) 1(6,6) 36(7,5) 13(8,6) 5(9,6) 5(10,6) 3(11,6) 3(12,8) 75
Fig. 8. Error floor estimation and Monte Carlo simulation for the (1008 , regular LDPC code ( d v = 4 , d c = 8 ). B. Irregular Codes
In this section, we present the results of applying the proposed algorithm to three irregular LDPCcodes. To find the dominant trapping sets of the irregular codes, we used two approaches. In the firstapproach, we used Algorithms 1 and 2 in the framework described in Algorithm 3. In this approach, asthe first step, we used the short cycles of the codes, as well as the low ACE cycles as the initial input set,and applied Algorithm 1. We then used the trapping sets found by Algorithm 1 along with the variablenodes of low degree, and applied Algorithm 2 to expand them. As the second approach, we only used thevariable nodes of low degree and cycles with low ACE as the initial input set, and then used Algorithm2 to recursively expand them to larger trapping sets. Interestingly, for all three codes, the results of thesecond approach were very close to those of the first one. Example 18:
For this example, we consider the irregular LDPC code constructed by the PEG algorithm(
PEGirReg252x504 code [50]). This code was also investigated in [21] for its fully absorbing sets. ForAlgorithm 1, the short cycles of length g , g + 2 , and the cycles with length less than 20 and ACE lessthan 4 were used as the initial input set. The algorithm was constrained to find only trapping sets of sizeless than 12 and the threshold T was selected such that only the trapping sets with the four smallestvalues of b for each size were considered. The resultant trapping sets and variable nodes of degree 2 and3 were then expanded by adding neighboring degree-2 variable nodes, and finally were examined to findthe fully absorbing sets. Table V shows the fully absorbing sets found by Algorithm 3 and the exhaustivesearch algorithm of [21]. It should be noted that, similar to [21], we relaxed the condition that degree-2variable nodes of (fully) absorbing sets must be connected to two satisfied check nodes. As can be seenfrom Table V, the proposed algorithm found almost all the fully absorbing sets of this code. Moreover,the proposed algorithm found a number of ( a, trapping sets for a ≥ , which were not reported in [21].For the second approach, the cycles of length up to 20 with ACE lower than 4 and the variable nodes ofdegree 2 and 3 were used as the initial inputs, and the algorithm found almost the same trapping sets asin the first approach. For the running time, the first and the second approaches took 15 minutes and 5minutes, respectively. TABLE V D OMINANT F ULLY A BSORBING S ETS OF THE
PEGirReg252x504 C ODE O BTAINED BY THE P ROPOSED A LGORITHM ANDTHE A LGORITHM OF [21]
Trapping Proposed ExhaustiveSet Algorithm Search [21] (3, 2) 219 219(4, 2) 208 208(5, 2) 198 198(6, 2) 205 205(7, 1) 2 2(7, 2) 271 272(8, 1) 8 8(8, 2) 458 460(9, 1) 16 -(9, 2) 855 -(10, 1) 22 -(10, 2) 1533 -(11, 1) 36 -
Example 19:
For this example, we used the (1944 , structured irregular code with rate / , adopted The multiplicity for trapping sets (7 , and (8 , are reported as 274 and 468 in [21], respectively. Moreover, no (7 , or (8 , trappingset is reported in [21]. The values reported for these four trapping sets in the last column of Table V are based on [22]. in the IEEE 802.11 standard [13]. We used the same parameters as in the previous example for the twoapproaches. Table VI shows the number of dominant trapping sets of different sizes found by the algorithmof [2] and the proposed approaches. For this code, both of our approaches found exactly the same set oftrapping sets. In fact, all the trapping sets listed in Table VI have one of the following three structures: a2-chain, a single cycle with low ACE, and the combination of a 2-chain and a single cycle of low ACE.For example, all the trapping sets of size less than 7 listed in Table VI are 2-chains, and all the (12 , trapping sets are single cycles of eleven degree-2 variable nodes and one degree-3 variable node. As canbe seen in Table VI, for all classes of trapping sets, the proposed algorithms found at least as manytrapping sets as the algorithm of [2] did. The first and the second approaches took 45 and 5 minutes,respectively, to find all the trapping sets in Table VI. This is while the algorithm of [2] took 5 days (ona 2.8-GHz CPU) to find the results reported in Table VI. TABLE VI D OMINANT TRAPPING SETS OF THE (1944,972)
CODE OBTAINED BY THE PROPOSED ALGORITHM
Trapping Proposed AlgorithmSet Algorithm of [2] (2, 2) 810 -(3, 2) 729 -(4, 2) 648 648(5, 2) 567 567(6, 2) 486 486(7, 2) 486 485(8, 2) 648 637(9, 2) 972 -(10, 2) 1377 1210(11, 2) 1944 1635(12, 1) 81 81(12, 2) 2754 2166(13, 1) 162 162(14, 1) 162 162(15, 1) 162 -(16, 1) 162 -(17, 1) 162 -(18, 1) 81 -
Based on the importance sampling technique of [7], the trapping sets in Table VI with size l , ≤ l ≤ ,were used to estimate the error floor of this code for a 3-bit quantized min-sum decoder over the AWGNchannel. Fig. 9 shows the error floor estimation and the Monte Carlo simulation results for this code. Ascan be seen in Fig. 9, the importance sampling estimation closely matches the Monte Carlo simulation,further verifying the dominance of the trapping sets found by the proposed algorithm. Fig. 9. Error floor estimation and Monte Carlo simulation for the (1944 , irregular LDPC code. Example 20:
As the last example, we use the following degree distribution optimized for the min-sumalgorithm in [6] and construct a (1000 , LDPC code using the PEG algorithm: λ ( x ) = . x + . x + . x + . x + . x and ρ ( x ) = . x + . x . The girth of the resultantgraph is 6, and we use the short cycles of length 6 and 8, and cycles of length up to 20 with ACE lessthan 4 as the initial input set of Algorithm 2. It takes 1 minute for the algorithm to find the trapping setsof size up to 10. Based on the obtained trapping sets and using the importance sampling, we estimate theerror floor of the code. Fig. 10 shows the estimation and Monte Carlo simulations for this code. As canbe seen in this figure, the estimation closely matches the Monte Carlo simulation results, verifying thatthe dominant trapping sets of the code have been found by the algorithm.VI. C ONCLUSIONS
In this paper, we proposed an efficient algorithm for finding the dominant trapping sets of an LDPCcode. The algorithm starts from an initial set of trapping sets and recursively and greedily expands themto trapping sets of larger size. The initial set for regular codes is a set of short cycles, and for irregularcodes, it also includes variable nodes of small degree and cycles with low ACE values. To devise theexpansions, the structure of dominant trapping sets is carefully studied for both regular and irregularcodes. The efficiency and accuracy of the proposed algorithm was demonstrated through a number ofexamples. It was observed that the proposed algorithm is faster by up to about two orders of magnitudecompared to similar search algorithms. Fig. 10. Error floor estimation and Monte Carlo simulation for the (1000 , irregular LDPC code. A PPENDIX
AIn this appendix, we present Lammas 7 and 8, used in Sections III and IV, respectively, along withtheir proofs. The appendix also contains the proofs for Lemmas 5 and 6(i).
Lemma 7:
For a left-regular graph G with left degree d l ≥ and girth g > , consider an ( a, b ) trapping set with b < a . If such a trapping set is elementary, let the notation a e denote its size, andconsider the case where d l ( d l − > b . Otherwise, for non-elementary trapping sets with b < a , let thenotations a n and a n denote the size of the trapping set if it has at least one unsatisfied check node ofdegree d o > and one satisfied check node of degree d e > in G ( S ) , respectively. For the two lattercases, suppose that d o ( d l − > b and d e ( d l − > b , respectively. Then depending on the value of g ,we have the following two sets of inequalities:a) For g = 4 k , where k is an integer larger than 1, we have: a e ≥ d l + ( d l ( d l − − b ) k − X i =0 ( d l − i + ( d l ( d l − − b )( d l − k − d l ,a n ≥ d e + ( d e ( d l − − b ) k − X i =0 ( d l − i ; For the case of d l = 2 , it is easy to see that any ( a, b ) elementary trapping set has b = 0 or b = 2 . For b = 0 , the smallest value of a is g/ , which corresponds to the trapping set being a shortest cycle. For an elementary trapping set with b = 2 , the smallest value of a isone, which corresponds to a single variable node. For a non-elementary ( a, b ) trapping set however, if b = 0 , the smallest value of a is g .If b = 2 , the minimum value of a for such a trapping set is . a n ≥ d o + ( d o ( d l − − b + 1) k − X i =0 ( d l − i . b) For g = 4 k + 2 , where k is a positive integer, we have: a e ≥ d l + ( d l ( d l − − b ) k − X i =0 ( d l − i ,a n ≥ d e + ( d e ( d l − − b ) k − X i =0 ( d l − i + ( d e ( d l − − b )( d l − k − d l ; a n ≥ d o + ( d o ( d l − − b + 1) k − X i =0 ( d l − i + ( d o ( d l − − b + 1)( d l − k − d l . Proof:
Here, we just present the sketch of the proof. For this, we first need the following lemma,whose proof follows later in the appendix.
Lemma G with left degree d l ≥ , if the induced subgraph G ( S ) of an ( a, b ) trapping set S does not contain any cycle, then b ≥ a ( d l −
2) + 2 . The inequality is satisfied withequality for elementary trapping sets.Based on Lemma 6(i), it is clear that a trapping set with b < a has at least one cycle. Therefore,considering any variable (or check) node of S as the root, and growing G ( S ) from that node, one canconstruct a tree of at least g/ layers, where the layers contain either variable or check nodes alternately,with no repetition of nodes. The number of variable nodes in this tree can be used as a lower boundon the number of variable nodes in S . In this tree, the number of check nodes in layer i > of thetree, N ic , is N ic = ( d l − N i − v , where N i − v is the number of variable nodes in layer i − . Similarly, N iv = P ( d c i − j − , where d c i − j is the degree (within G ( S ) ) of the j th check node in layer i − , andthe summation is over all the check nodes in layer i − . To minimize the number of variable nodes inthe tree, one needs to make P ( d c i − j − as small as possible in each check node layer of the tree. Inparticular, this should be done at the upper layers of the tree if possible, since these layers contribute themost in the total number of variable nodes in the tree. In addition, to obtain a lower bound on the sizeof the trapping sets, we assume that even for the non-elementary case, except for one check node, thedegrees of all the other check nodes in G ( S ) are either 1 or 2. Moreover, we assume that all the checknodes of degree 1 are in the first (upper) layer(s) of check nodes after the root layer.For the case of an elementary trapping set, according to the assumption of b < a , there is at leastone variable node that is not connected to any unsatisfied check nodes. Considering such a variable node as the root node, all the check nodes in the first layer are satisfied check nodes. That is, N v =1 (root node), N c = N v = d l , N c = d l ( d l − , N v = d l ( d l − − b and N i − c = ( d l − N i − v , N iv = N i − c , for i = 6 , , . . . . Therefore, the total number of variable nodes in the constructed tree is d l + ( d l ( d l − − b ) + ( d l ( d l − − b )( d l −
1) + . . . . Distinction should be made between the casesof g = 4 k + 2 and g = 4 k . While in the former, the last layer of the tree consists of variable nodes, inthe latter, it consists of check nodes. In this case, for each set of d l check nodes in the last layer of thetree, there must be at least one other variable node in S . The sketch of the proofs for the non-elementarycases are similar to that of the elementary case, with the difference that the check node of degree d o or d e is used as the root node. Proof of Lemma d ( v ) neighbors of v in G ( S ) . At least d ( v ) − b of them are in Γ e ( S ) and are thus connectedto other variable nodes in S . None of such variable nodes can share more than one check node from Γ e ( S ) with v , because of the condition g > . This implies that there are at least d ( v ) − b variable nodesin S\{ v } . (cid:4) Proof of Lemma G ( S ) does not contain any cycle, it forms a tree (note that G ( S ) is connected). Suppose that G ( S ) is grown from a variable node of S as the root, one layer at a time, until along each path, thegrowth is terminated by reaching a check node as a leaf. These nodes are the unsatisfied check nodesof degree one. In the tree, each variable node, except the root, has a parent which is a check node ofdegree ≥ . In the case that S is elementary, the degree of the parent check nodes is 2, and hence eachcheck node is the parent to one variable node. There are thus exactly a − check nodes of degree 2 in G ( S ) . Since G ( S ) is a tree, the number of its nodes is more than the number of its edges by one. Thetotal number of nodes in the graph is a + ( a −
1) + b and the total number of edges is a · d v , where b is the number of unsatisfied check nodes of degree one. For an elementary trapping set, we thus have a + b − ad v + 1 , which implies b = b = a ( d v −
2) + 2 . In the case that S is not elementary, somevariable nodes may share the same parent. The number of parent check nodes is thus less than a − , andtherefore b ≥ b > a ( d v −
2) + 2 . (cid:4) Lemma 8:
Let G = ( L ∪ R, E ) be a left-regular bipartite graph with left degree . Consider a set S ∈ L , for which the induced subgraph is a tree and has the longest path of length k − . Then Here, based on the statement of the lemma, we have assumed that all the unsatisfied check nodes can fit in the third layer of the tree. Inthe case that d l ( d l − − b ≤ , some of the unsatisfied check nodes have to be located in the next layer(s), and the above equations andthe claims of the lemma will have to be accordingly revised. |S| ≤ P k − i =0 ( d c,max − ⌊ i +12 ⌋ , where |S| is the number of nodes in S and d c,max is the maximum degreeof the nodes in R . Proof:
The upper bound is derived by counting the number of variable nodes in a tree where thenumber of check nodes is maximized with the constraint that the longest path has k − edges. Thisimplies that there is a path of length k − between any two leaf check nodes of G ( S ) . In addition, tomaximize |S| , the degree of all the check nodes in G ( S ) is assumed to be d c,max .A CKNOWLEDGEMENT
The authors wish to thank the Associate Editor and the anonymous reviewers whose comments haveimproved the presentation of the paper. R
EFERENCES [1] R. Asvadi, A. H. Banihashemi and M. Ahmadian-Attari, “Lowering the error floor of LDPC codes using cyclic liftings,”
IEEE Trans.Inform. Theory , vol. 57, no. 4, pp. 2213-2224, Apr. 2011.[2] S. Abu-Surra, D. DeClercq, D. Divsalar, and W. Ryan, “Trapping set enumerators for specific LDPC codes,” Proc.
Inform. Theory andApplications Workshop,
San Diego, CA, Jan. 31- Feb. 5, 2010, pp. 1-5.[3] E.T. Bax, “Algorithms to count paths and cycles,”
Information Processing Letters , vol. 52, no. 5, pp. 249252, Dec. 1994.[4] E. Cavus and B. Daneshrad, “A performance improvement and error floor avoidance technique for belief propagation decoding of LDPCcodes,” Proc.
Sept. 2005, vol. 4, pp. 2386-2390.[5] E. Cavus, C. Haymes, and B. Daneshrad, “An IS simulation technique for very low BER performance evaluation of LDPC codes,” Proc.
IEEE International Conference on Communications , Istanbul, June 11-15, 2006, pp. 1095-1100.[6] S. Y. Chung, “On the construction of some capacity-approaching coding schemes,” Ph.D. thesis, Dept. of Electrical Engineering andComputer Science, Massachusetts Institute of Technology, Sept. 2000.[7] C. Cole, S. Wilson, E. Hall, and T. Giallorenzi, “A general method for finding low error rates of LDPC codes,”
CoRR,arxiv.org/abs/cs/0605051 .[8] L. Dolecek, Z. Zhang, M. Wainwright, V. Anantharam, and B. Nikolic, “Evaluation of the low frame error rate performance of LDPCcodes using importance sampling,” Proc.
IEEE Inform. Theory Workshop , Lake Tahoe, CA, Sept. 2-6, 2007, pp. 202-207.[9] L. Dolecek, P. Lee, Z. Zhang, V. Anantharam, B. Nikolic, and M. Wainwright, “Predicting error floors of LDPC codes: deterministicbounds and estimates,”
IEEE Journal on Selected Areas in Communications , vol. 27, no. 6, pp. 908-917, Aug. 2009.[10] C. Di, D. Proietti, E. Telatar, T. J. Richardson, and R. L. Urbanke, “Finite-length analysis of low-density parity-check codes on thebinary erasure channel,”
IEEE Trans. Inform. Theory , vol. 48, no. 6, pp. 1570-1579, June 2002.[11] Y. Han, and W. E. Ryan, “LDPC decoder strategies for achieving low error floors,” Proc.
Inform. Theory and Applications Workshop ,Jan. 2008, pp. 277-286.[12] X.-Y. Hu, E. Eleftheriou, and D. M. Arnold, “Regular and irregular progressive edge-growth Tanner graphs,”
IEEE Trans. Inform.Theory, vol. 51, no. 1, pp. 386-398, Jan. 2005.[13] IEEE-802.11n. Wireless LAN medium access control and physical layer specifications: enhancements for higher throughput.
P802.11n/D3.07 , Mar. 2008. [14] M. Ivkovic, S. K. Chilappagari, and B. Vasic, “Eliminating trapping sets in low-density parity-check codes by using Tanner graphcovers,” IEEE Trans. Inform. Theory , vol. 54, no. 8, pp. 3763-3768, Aug. 2008.[15] D. B. Johnson, “Find all the elementary circuits of a directed graph,”
Society for Industrial and Applied Mathematics (SIAM) Journalon Computing , vol. 4, no. 1, pp. 77-84, Mar. 1975.[16] S. Laendner, T. Hehn, O. Milenkovic and J.B. Huber, “The trapping redundancy of linear block codes,”
IEEE Trans. Inform. Theory ,vol. 55, no. 1, pp. 53-63, Jan. 2009.[17] S. Laendner and O. Milenkovic, “Algorithmic and combinatorial analysis of trapping sets in structured LDPC codes,” Proc.
IEEEInternational Conference on Wireless Networks, Communications and Mobile Computing , Hawaii, USA, June 13-16, 2005, pp. 630-635.[18] R. Koetter and P. O. Vontobel, “Graph-covers and iterative decoding of finite length codes,” Proc.
IEEE International Symposium onTurbo Codes and Applications,
Brest, France, Sept. 2003, pp. 75-82.[19] M. Karimi and A. H. Banihashemi, “A message-passing algorithm for counting short cycles in a graph,”
CoRR, arxiv.org/abs/1004.3966 .[20] K. M. Krishnan and P. Shankar, “Computing the stopping distance of a Tanner graph is NP-hard,”
IEEE Trans. Inform. Theory , vol.53, no. 6, pp. 2278-2280, June 2007.[21] G. B. Kyung and C.-C. Wang, “Exhaustive search for small fully absorbing sets and the corresponding low error-floor decoder,” Proc.
IEEE International Symposium on Inform. Theory,
Austin, TX, June 2010, pp. 739-743.[22] G. B. Kyung, “private communication,” Jan. 4, 2011.[23] A. McGregor and O. Milenkovic, “On the hardness of approximating stopping and trapping sets in LDPC codes,”
IEEE Trans. Inform.Theory , vol. 56, no. 4, pp. 1640-1650, Apr. 2010.[24] D. J. C. MacKay and M. S. Postol, “Weaknesses of Margulis and Ramanujan-Margulis low-density parity-check codes,”
ElectronicNotes in Theoretical Computer Science , vol. 74, 2003.[25] G. A. Margulis, “Explicit constructions of graphs without short cycles and low density codes,”
Combinatorica , vol. 2, no. 1, pp. 71-78,1982.[26] O. Milenkovic, E. Soljanin, and P. Whiting, “Asymptotic spectra of trapping sets in regular and irregular LDPC code ensembles,”
IEEETrans. Inform. Theory , vol. 53, no. 1, pp. 39-55, Jan. 2007.[27] K. Murali Krishnan and L. Sunil Chandran, “Hardness of approximation results for the problem of finding the stopping distance inTanner graphs,” Proc. , Dec.13-15, 2006, pp. 69-80.[28] B. D. McKay, N. C. Wormald and B. Wysocka, “Short cycles in random regular graphs,”
Electronic Journal of Combinatorics , vol.11, no. 1, 2004.[29] D. V. Nguyen, S. K. Chilappagari, M. W. Marcellin, and B. Vasic, “On the construction of structured LDPC codes free of small trappingsets,”
IEEE Trans. Inform. Theory , to appear.[30] T. Richardson, “Error floors of LDPC codes,” Proc.
Monticello, IL, Oct. 2003, pp. 1426-1435.[31] T. J. Richardson, M. A. Shokrollahi, and R. L. Urbanke, “Design of capacity-approaching irregular low density parity-check codes,”
IEEE Trans. Inform. Theory, vol. 47, no. 2, pp. 619-637, Feb. 2001.[32] E. Rosnes and O. Ytrehus, “An efficient algorithm to find all small-size stopping sets of low-density parity-check matrices,”
IEEETrans. Inform. Theory , vol. 55, no. 9, pp. 4167-4178, Sept. 2009.[33] A. Otmani, J.-P. Tillich, I. Andriyanova,“On the minimum distance of generalized LDPC codes,” Proc.
International Symposium onInform. Theory , Nice, France, June 24-29, 2007, pp. 751-755.[34] R. M. Tanner, D. Sridhara and T. Fuja, “A class of group-structured LDPC codes,” Proc.
International Symposium on CommunicationTheory and Applications , Ambleside, U.K., July 2001, pp. 365-370. [35] J.-P. Tillich and G. Zemor, “On the minimum distance of structured LDPC codes with two variable nodes of degree 2 per parity-checkequation,” Proc. IEEE International Symposium on Inform. Theory,
Seattle, WA, July 9-14, 2006, pp. 1549-1553.[36] T. Tian, C. Jones, J. D. Villasenor, and R. D. Wesel, “Selective avoidance of cycles in irregular LDPC code construction,”
IEEE Trans.Communications , vol. 52, no. 8, pp. 1242-1248, Aug. 2004.[37] B. Vasic, S. Chilappagari, D. Nguyen, and S. Planjery, “Trapping set ontology,” Proc.
Monticello, IL, Sept. 2009, pp. 1-7.[38] P. O. Vontobel and R. Koetter, “Graph-cover decoding and finite-length analysis of message-passing iterative decoding of LDPC codes,”
CoRR, arxiv.org/abs/cs/0512078 .[39] D. Vukobratovic and V. Senk, “Generalized ACE constrained progressive edge growth LDPC code design,”
IEEE CommunicationsLetters , vol. 12, no. 1, pp. 32-34, Jan. 2008.[40] C.-C. Wang, “On the exhaustion and elimination of trapping sets: Algorithms & the suppressing effect,” Proc.
International Symposiumon Inform. Theory , Nice, France, June 24-29, 2007, pp. 2271-2275.[41] C.-C. Wang, S.R. Kulkarni, H.V. Poor, “Finding all small error-prone substructures in LDPC codes,”
IEEE Trans. Inform. Theory , vol.55, no. 5, pp. 1976-1998, May 2009.[42] H. Xiao and A. H. Banihashemi, “Estimation of bit and frame error rates of low-density parity-check codes on binary symmetricchannels,”
IEEE Trans. Communications , vol. 55, pp. 2234-2239, Dec. 2007.[43] H. Xiao and A. H. Banihashemi, “Error rate estimation of finite-length low-density parity-check codes decoded by soft-decision iterativealgorithms,” Proc.
International Symposium on Inform. Theory , Toronto, Ontario, July 6-11, 2008, pp. 439-443.[44] H. Xiao and A. H. Banihashemi, “Error rate estimation of low-density parity-check codes on binary symmetric channels using cycleenumeration,”
IEEE Trans. Communications , vol. 57, pp. 1550-1555, June 2009.[45] H. Xiao and A. H. Banihashemi, “Improved progressive-edge-growth (PEG) construction of irregular LDPC codes,”
IEEE Communi-cations Letters , vol. 8, no. 12, pp. 715-718, Dec. 2004.[46] M.Yang, W. E. Ryan, and Y. Li, “Design of efficiently-encodable moderate-length high-rate irregular LDPC codes,”
IEEE Trans.Communications , vol. 52, no. 4, pp. 564-571, Apr. 2004.[47] Z. Zhang, L. Dolecek, M. Wainwright, V. Anantharam, and B. Nikolic, “Quantization effects in low-density parity-check decoders,”Proc.
IEEE International Conference on Communications , Glasgow, Scotland, June 24-28, 2007, pp. 6231-6237.[48] Y. Zhang and W. E. Ryan, “Toward low LDPC-code floors: a case study,”
IEEE Trans. Communications , vol. 57, no. 6, pp. 1566-1573,June 2009.[49] V. Zyablov and M. Pinsker, “Estimates of the error-correction complexity of Gallager’s low-density codes,”