111The first revision of this paper according to the comments of the reviewers has been submitted to IEEE Transactions on Communications on June 12, 2019. Construction of QC LDPC Codes with Low Error Floor by Efficient Systematic Search and Elimination of Trapping Sets
Bashirreza Karimi, and Amir.H Banihashemi, *Senior Member, IEEE *
Abstract
We propose a systematic design of protograph-based quasi-cyclic (QC) low-density parity-check (LDPC) codes
with low error floor. We first characterize the trapping sets of such codes and demonstrate that the QC structure of the code eliminates some of the
trapping set structures that can exist in a code with the same degree distribution and girth but lacking the QC structure. Using this characterization,
our design aims at eliminating a targeted collection of trapping sets. Considering the parent/child relationship between the trapping sets in the collection,
we search for and eliminate those trapping sets that are in the collection but are not a child of any other trapping set in the collection.
An efficient layered algorithm is designed for the search of these targeted trapping sets.
Compared to the existing codes in the literature, the designed codes are superior in the sense that they are free of the same collection of trapping sets while having a smaller block length,
or a larger collection of trapping sets while having the same block length. In addition, the efficiency of the search algorithm
makes it possible to design codes with larger degrees which are free of trapping sets within larger ranges
compared to the state-of-the-art.
Index Terms:
Low-density parity-check (LDPC) codes, quasi-cyclic (QC) LDPC codes, LDPC code construction, leafless elementary trapping sets, elementary trapping sets, trapping sets, low error Floor.
I Introduction
Protograph-based quasi-cyclic (QC) low-density parity-check (LDPC) codes are an important category of LDPC codes, adopted in many standards and widely used in practice.
The Tanner graphs for such codes are obtained by cyclically lifting a small bipartite graph, called base graph or protograph. Protograph-based QC-LDPC codes not only have a competitive performance under iterative decoding algorithms over a variety of channels, but also enjoy efficient implementations which take advantage of the QC structure of the code. A potential problem in using QC-LDPC codes in applications that require low error rates is the error floor,
characterized by a change in the slope of error rate curves as the channel quality improves.
There are two main approaches to improve the error floor of LDPC codes: (1) modification of the decoding algorithm, and (2) new/modified code constructions.
This work focusses on the second approach. Increasing the girth of QC-LDPC codes and removing the dominant trapping set structures in the Tanner graph of codes are
two main methods dealing with the error floor in the construction process of LDPC codes. Progressive-edge-growth (PEG) is one of the most well-known algorithms to design
LDPC codes with large girth [1]. The PEG algorithm also has been extended to irregular [2] and QC structures [3]. In [4],
Asvadi et al. designed QC-LDPC codes with low error floor by removing the short cycles that were part of dominant trapping sets. The same authors [5] also proposed another technique based on the approximate cycle extrinsic message degree (ACE) spectrum to design irregular QC-LDPC codes with good error floor.
In [6], Nguyen et al. constructed structured regular LDPC codes with low error floor over the binary symmetric channel (BSC).
The low error floor in [6] was achieved by ensuring that certain small trapping sets were absent in the code. Khazraei et al. [7] modified
the PEG algorithm for the construction of LDPC codes to avoid the creation of dominant trapping sets in the construction process. In [8], Wang et al. used the cycle consistency matrix to design separable circulant-based LDPC codes, in which certain absorbing sets were avoided. More recently,
Diouf et al. [9] proposed an improved PEG algorithm to construct regular LDPC codes with variable degree 3 and girth 8
without (5,3) trapping sets and with the minimum number of (6,4) trapping sets. (An (a,b) trapping set has a variable nodes and b odd-degree check nodes in its subgraph.)
Most recently, in [10], Tao et al. proposed a construction of QC-LDPC codes with variable node degree 3
and girth 8 from fully-connected protographs, where (a,b) elementary trapping sets (ETSs) with
a≤8 and b≤3 were removed by avoiding certain cycles of length 8 (8-cycles) in the Tanner graph. Based on their approach,
the authors of [10] also derived lower bounds on the lifting degree, and as a result on the block length, of the designed codes, and were able to find codes, using random
search, to either achieve or approach the bound.
Elementary trapping sets of LDPC codes are known to be the main culprits in the error floor region over the additive white Gaussian noise (AWGN) channel, see, e.g., [11, 12], and the references therein.
These sets have been, in general, characterized in [11, 12] using the so-called dpl characterization.
The dpl characterization describes each and every ETS S as an embedded sequence of ETSs that starts from a simple cycle and expands recursively, in each step by one of the
three simple expansions dot, path and lollipop, to reach S. Associated with the dpl characterization is an efficient dpl search algorithm [11, 12], that can find
all the ETSs within a range of interest, exhaustively.
In this paper, we first characterize the ETSs of QC-LDPC codes, and demonstrate that some of the ETS structures that can
exist in a general (randomly constructed) LDPC code are absent in QC-LDPC codes due to the QC structure of the code. To find such structures, we translate
the problem into an edge coloring problem involving the normal graph [13] of the ETS structure. Our characterization still follows the dpl principle but
with fewer structures compared to those of a general LDPC code, as considered in [11, 12].
Based on the characterization of ETSs in QC-LDPC codes, we then propose a systematic approach to design protograph-based QC-LDPC codes that are free of a certain collection of
trapping sets. The design is based on investigating the parent/child relationship between all the ETS structures within the collection and target those that are
not child to any structure within the collection. We then devise an efficient layered algorithm to search for the targeted structures in the construction process.
Compared to the exhaustive dpl search of [11, 12], the proposed search algorithm is significantly less complex. This is mainly due to the fact that while the goal of the dpl algorithm of [11, 12] is to find all the instances of a certain collection of ETS structures, our goal here is only to verify whether any instances of at least one of the
targeted structures exists in the code. A number of techniques are then employed to solve this new problem efficiently. In particular, the problem
is formulated as a backward recursion in which the goal is to minimize the number of intermediate structures to reach the targeted structures and to use structures that
have a higher chance of having a smaller multiplicity in the graph. It is important to note that the proposed layered characterization/search algorithm of ETSs can also be used
to design LDPC codes with low error floor that lack the QC structure. The only difference is that for such codes the number of possible ETS structures is larger.
The constructed codes in this work are superior to the state-of-the-art codes in the literature in the sense that, with the same protograph,
they are either free of the same collection of ETSs while having a shorter block length, or are
free of a larger range of trapping sets (and thus have a superior error floor) while having the same block length. To the best of our knowledge, the proposed design
is the first that can systematically, efficiently and optimally construct QC-LDPC codes that are free of a certain collection of trapping sets. The systematic (general)
nature of the design means that it is applicable to a variety of QC-LDPC codes with different node degrees, girths and different choices of targeted
ETS structures. The high efficiency (low complexity) makes it possible to design codes of larger block length with wider range of node degrees and
to target larger collections of trapping sets. The optimality of the design, which ensures that only the structures of interest are targeted for elimination,
guarantees that the block length is minimized (for the elimination of a given set of ETSs) or that the largest collection of ETSs are removed (for a given block length).
This is in contrast with some of the existing work, such as [9, 10], in which, some parent structures which are not of direct interest are targeted for elimination
just to eliminate some of their children.
We end this section by noting that there is a body of work that considers absorbing sets to be responsible for the error floor of
LDPC codes (as an alternative to TSs), see, e.g., [8, 14, 15, 16]. There are close relationships between absorbing sets
and TSs. In particular, elementary absorbing sets, which are a category of absorbing sets widely studied in the literature [8, 14, 15, 16], are in general a subset of leafless ETSs (LETSs) [11, 17], considered in this work.
(The two categories of LETSs and elementary absorbing sets are identical for LDPC codes with maximum variable node degree 3.) Therefore, the general characterization of LETSs for QC-LDPC codes and
the layered search algorithm of LETSs proposed in this work are both readily applicable to elementary absorbing sets. We also note that an example of an LDPC code with
variable node degree 4 is provided in [11] (C10), for which the error-prone structures of quantized iterative decoders over the AWGN channel in the error floor region
are shown to be LETSs and not elementary absorbing sets. The existence of such cases further justifies the choice made in this paper to focus on LETSs rather than elementary absorbing sets.
The rest of this paper is organized as follows. In Section II, we present some definitions, notations and preliminaries. The ETS characterization for QC-LDPC codes is
discussed in Section III. Section IV describes the approach for determining the ETSs within a given collection that are targeted for elimination based on parent/child relationships within the collection, and the proposed layered search algorithm for finding the targeted ETSs efficiently. In Section V, we present the method for the construction
of QC-LDPC codes with low error floors based on the proposed layered search algorithm. Section VI is devoted to numerical results and presents some of the constructed
codes and comparisons with existing codes in the literature. The paper is concluded in Section VII.
II Preliminaries
Consider an undirected bipartite graph G′(V′=U′∪W′,E′), where V′ and E′ are the sets of nodes and edges of G′, respectively,
and U′ and W′ are the sets of nodes on the two sides of the bipartition. Suppose that ∣U′∣=n and ∣W′∣=m.
In this work, we consider bipartite graphs with no parallel edges.
Suppose the graph G(V=U∪W,E) is constructed from the bipartite graph G′(V′=U′∪W′,E′) through the following process: Make N copies of G′. Corresponding to every node v′∈V′ and every edge e′∈E′, generate a set of nodes v={v′0,...,v′N−1} and a set of edges e={e′0,...,e′N−1}. Assign a circular permutation πe′ over the set {0,1,…,N−1} to each edge e′ in E′, and connect the nodes in V by the edges in E such that if e′={u′,w′}, for u′∈U′ and w′∈W′, is in G′, then {u′i,w′j} belongs to G if and only if πe′(i)=j. The graph G so constructed is referred to as a cyclic N-lifting of G′, with N called the lifting degree. Graph G′, on the other hand, is called the base graph or protograph.
Now, consider an LDPC code whose Tanner graph is G with the set of variable and check nodes equal to U and W, respectively.
Such an LDPC code is a protograph-based QC-LDPC code whose mN×nN parity-check matrix H, given by the bi-adjacency matrix of G, has the following form:
[TABLE]
In (1), the parameters pij, called permutation shifts, are in the set {0,1,⋯,N−1,∞} for 0≤i≤m−1, 0≤j≤n−1. The matrix Ipij is obtained by cyclically shifting the rows of the identity matrix IN×N to the left by pij units, if pij=∞. Otherwise, I∞ denotes the N×N all-zero matrix.
The collection of permutation shifts pij as a matrix is denoted by P=[pij] and is called exponent matrix.
In this work, we focus on protograph-based QC-LDPC codes, whose base graphs are fully-connected, i.e., every node on each side of the graph is connected to all the nodes on the other side.
This implies that all the nodes in U′ have the same degree dv=m and all the nodes in W′ have the same degree dc=n.
Parameters dv and dc are the variable and check node degrees of the constructed regular QC-LDPC code.
It is well-known that for any QC-LDPC code with a fully-connected base graph, there exists an isomorphic QC-LDPC code with the exponent matrix in the following form (see, e.g., [18]):
[TABLE]
where 0≤p11≤⋯≤p1(n−1).
Given the exponent matrix of a QC-LDPC code, the necessary and sufficient condition for having a 2l-cycle in the Tanner graph is [18, 19]:
[TABLE]
where, n0=nl, mi=mi+1, ni=ni+1. The sequence of permutation shifts in (3) corresponds to a tailless backtrackless closed (TBC) walk [18]
in the base graph whose permutation shift is equal to the left hand side of (3). An additional condition for having a 2l-cycle in the Tanner graph is that the TBC walk
corresponding to (3) has no TBC subwalk whose permutation shift is also equal to zero.
The length of the shortest cycle(s) in a Tanner graph is called girth, and is denoted by g. It is well-known that for good performance 4-cycles should be avoided and that
codes with larger girth generally perform better both in waterfall and error floor regions. In our constructions, we impose a lower bound on g. When
the goal is to find a QC-LDPC code with g≥g0, we choose pij values in (2) such that (3) is not satisfied
for any l<g0/2, and any sequence of 2l permutation shifts.
It is well-known that certain substructures of Tanner graphs are responsible for the error floor of LDPC codes. These substructures are
generally referred to as trapping sets. A trapping set is often characterized by its
size (the number of variable nodes) a and the number of unsatisfied (odd-degree) check nodes b in its induced subgraph.
Such a trapping set is said to belong to the (a,b)* class*. Among trapping sets, elementary trapping sets (ETS),
whose subgraphs have only degree-1 and degree-2 check nodes, are known to be the most problematic ones [11], [12].
Within ETS category, leafless ETSs (LETS), those in which each variable node is connected to
at least two satisfied (even-degree) check nodes, are the most harmful [11], [17].
Recently, Hashemi and Banihashemi [11] proposed a hierarchical graph-based characterization of LETS structures,
dubbed dpl, for variable-regular LDPC codes.222An LDPC code is called variable-regular, if all the variable nodes in the Tanner graph of the code have the same degree.
The characterization corresponds to an exhaustive search algorithm
of LETSs within any range of a≤amax and b≤bmax, for general LDPC codes.
III Characterization of ETS Structures in QC-LDPC codes
In this section, we investigate the constraints that the QC structure of LDPC codes imposes on the ETS structures. We demonstrate that as a result of such constraints, certain ETS structures that can appear in (randomly constructed) LDPC codes, cannot exist in similar QC-LDPC codes. To show this, we transform the problem into a graph coloring problem.
Consider the induced subgraph G(S) of an ETS S in the Tanner graph G of a variable-regular LDPC code with variable degree dv.
Replace any degree-2 check node and its adjacent edges in G(S) with a single edge, and remove all the degree-1 check nodes and their adjacent edges from G(S).
The resulted graph, which is not bipartite, is called the normal graph of S [13], and is denoted by G^(S) in this paper. There is
clearly a one-to-one correspondence between G(S) and G^(S) for variable-regular LDPC codes. To investigate the constraints imposed by the QC structure of the codes,
in the following, we work with the normal graph representation of ETSs. We note that for Tanner graphs with girth at least 6, the normal graph of any ETS is simple, i.e., has no parallel edges.
For a graph G, a k-edge coloring is defined as a function f:E(G)→C, such that ∣C∣=k, and f(e)=f(e′) for any two adjacent edges
e and e′ of G. A graph G is k-edge colorable if G has a k-edge coloring.
The chromatic index of G, denoted by χ(G), is the minimum value of k for which G has a k-edge coloring.
It is well-known that for a simple graph G, Δ(G)≤χ(G)≤Δ(G)+1, where Δ(G) is the maximum node degree of G [20].
A graph G is said to be of Class 1 (resp., Class 2) if χ(G)=Δ(G) (resp., χ(G)=Δ(G)+1).
Proposition 1. Consider a QC-LDPC code with the parity-check matrix given by (1). For an ETS S to exist in the code,
the normal graph G^(S) must be m-edge colorable.
Proof. It is clear that for protograph-based QC-LDPC codes with the parity-check matrix H of the form (1), each variable node in an ETS S can be connected
to at most m check nodes, where each such check node must belong to a distinct row block of H. Now, suppose that we assign m different colors to
different row blocks of H, and consider the following assignment of colors to the edges of G^(S):
for each edge e in G^(S), find the row block R of H corresponding to the
degree-2 check node in G(S) that has been replaced by e. Then, assign the color of R to e. It is easy to see that for an ETS S to exist in a QC-LDPC code,
the aforementioned color assignment must be an m-edge coloring of G^(S), or in other words, G^(S) must be m-edge colorable. ■
We thus have the following result.
Corollary 1. Consider a QC-LDPC code with the parity-check matrix given by (1). An ETS S cannot exist
in the Tanner graph of the code if χ(G^(S))>m.
We note that the result of Corollary 1 is applicable to any QC-LDPC code with the parity-check matrix given by (1). This includes cases in which some of the
sub-matrices of (1) are all-zero, and cases where the degree distribution is irregular. In the latter case, there is no one-to-one correspondence
between the normal graph G^(S) of an ETS S and S (see [12], for more information on normal graphs of ETS structures in
irregular codes and their relationship to quasi-normal hypergraphs of such structures).
Corollary 2. An ETS S whose normal graph G^(S) is of Class 2 with Δ(G^(S))=m cannot exist in
a QC-LDPC code with g≥6 and the parity-check matrix given by (1).
A graph G=(V,E) is called overfull if ∣E∣>⌊2∣V∣⌋×Δ(G). It is known that an overfull graph is of Class 2 [20].
We thus have the following result.
Proposition 2. Any (a,b) ETS with an odd value of a and with b<min(a,dv) cannot exist in a variable-regular QC-LDPC code with variable degree dv and g≥6, that is a cyclic lifting of a fully-connected base graph.
Proof. We first note that for an ETS S with b<a, we have Δ(G^(S))=dv, because there is at least one variable node in G(S) that is not connected to any
degree-1 check nodes. We then show that under the conditions of the proposition,
the graph G^(S) is also overfull and thus of Class 2, This, based on Corollary 2, completes the proof. To show that G^(S) is overfull, we note that
the number of edges in G^(S) is ∣E∣=(adv−b)/2, by the definition of a normal graph. Since b<dv, we have ∣E∣>(a−1)dv/2=⌊a/2⌋dv,
where the equality is a result of a being odd. ■
We note that the results of Corollaries 1, 2 and Proposition 2 hold regardless of the lifting degree and permutation shifts of the QC-LDPC code.
Using Proposition 2, we can conclude that some of the ETS classes that can generally exist in (randomly constructed) variable-regular LDPC codes will not appear
in similar QC-LDPC codes. As an example, consider a variable-regular LDPC code with dv=3 and g=6. Based on Table VI of [11], this code can have
LETSs in classes (5,1), (7,1) and (9,1). The multiplicity of non-isomorphic structures in these classes are 1, 4 and 19, respectively. Based on Proposition 2,
however, none of these structures can possibly exist in a QC-LDPC code, lifted from a fully-connected base graph, with similar dv and g values.
It is important to note that while one can use the vast literature on the edge coloring of graphs and derive analytical results
similar to Proposition 2 for other classes or structures of ETSs, for practical purposes, one can also use an
algorithm for finding the chromatic index of a graph, such as that of [21], to examine different ETS structures and see
if their chromatic index is larger than dv (i.e., it is dv+1). Clearly, a “yes” answer would mean that such a structure
cannot exist in a variable-regular QC-LDPC code with variable degree dv.
In Table I, we have listed all the classes in which at least one LETS structure does not exist in the QC category of the corresponding variable-regular LDPC codes.
Similar to [11], in Table I, the results are separated based on the values of dv and g. For each value of dv and g, and for each class with at least one missing structure, we have provided the multiplicity of the non-isomorphic structures within the class as the bottom entries, where the right and left entries are for the general and the QC cases, respectively. For the entries, we have followed the same notation as in [11], where the number in the brackets shows the multiplicity of the structures and the notation sk indicates the simple cycle parent of those structures which has a length of 2k. As an example, for dv=3 and g=6, the bottom entries for the (5,1) class are s3(0)/s3(1), which means while a general LDPC code with dv=3 and g=6 can have one structure within this class with the parent being a 6-cycle, this structure cannot exist in the QC category.
The boldfaced entries in the table highlight the classes for which all the structures are non-existent for the QC category. The non-existence of all these classes follow from Proposition 2.
The non-existence of some LETS structures in QC-LDPC codes compared to their random counterparts not only reduces the search complexity of the proposed technique, as discussed in Subsection IV.D, but also can be potentially beneficial in achieving a lower error floor.
In the rest of the paper, similar to the existing literature [22, 23, 11, 13], we focus on LETSs as the main problematic structures in the error floor. This
is due to the fact that a vast majority of trapping sets of variable-regular LDPC codes are known to be LETSs , see, e.g., [11].
We then use the results presented in Table I to reduce the number of structures that we need to search for in the process of constructing QC-LDPC codes.
IV Efficient Search Algorithm for A Targeted Set of LETSs
The goal of this paper is to construct QC-LDPC codes free of a certain collection L of LETS structures.333The proposed layered characterization/search algorithm of LETSs can also be used
to construct LDPC codes with low error floor that lack the QC structure. The only difference is that for such codes the number of possible LETS structures is larger.
In the literature, this collection is often identified by a certain range of a and b values, i.e., a≤amax and b≤bmax. As we will discuss in Section V,
to construct the exponent matrix of a QC-LDPC code (for a given lifting degree), a greedy column-by-column search algorithm is
used to assign the permutation shifts. In the search process, after assigning the permutation values of a new column, one needs
to check whether the Tanner graph corresponding to the exponent matrix constructed so far contains any instances of the LETS structures within L.
A naive approach to perform this task would be to use the exhaustive dpl search of [11] within the specified range, and see if
the algorithm can find any LETSs within the range. This approach, however, is too complex to use in the construction process that
may require hundreds or even thousands of such searches. Moreover, the information provided by the dpl algorithm of [11] is
much more than what we need in the construction process, i.e., the algorithm provides an exhaustive list of all LETSs within the range of interest.
However, what we need is just to know whether there exists at least one instance of one of the structures of L within the graph.
In this section, we devise an efficient search algorithm for this problem. The efficiency of the algorithm is a result of the following
considerations: (a) the algorithm only searches for a minimal
number of structures within L. These targeted structures, denoted by Lt, are the ones that are not child to any of the other structures in L,
and (b) the algorithm aims to minimize the number of LETS structures that do not belong to L but are needed in the
search for the structures in Lt. For the choice of these out-of-range structures, the algorithm also gives priority to LETS classes
that have a higher chance of having smaller multiplicities in the graph.
Our search algorithm still follows the general framework of dpl characterization/search of [11], and thus has all the advantages
of the dpl technique. This means that in the proposed search algorithm, each LETS is characterized (and searched for)
as an embedded sequence of LETS structures that starts from a simple cycle and is expanded, at each step, by one of the three expansions dot, path and lollipop
until it reaches the LETS structure of interest.
(For a review of these expansions and the corresponding notations, which we closely follow, the reader is referred to [11].)
IV-A Finding the Target LETSs Lt
Suppose that we are interested in constructing a QC-LDPC code free of LETSs in the range of a≤amax and b≤bmax.
To perform this task, we first identify all the non-isomorphic LETS structures within this range based on the values of dv and g,
and investigate the parent/child relationship between all such structures. (See [11].)
We then start from the smallest size of LETSs in the range, i.e., a=g/2, and identify all the non-isomorphic (g/2,b) LETS structures with b≤bmax.
These structures are stored in Lt. We then go through an iterative process, where in each iteration, we increase a by one, until
we reach amax. In each iteration, we examine all the (a,b) LETS structures with the specific a value of that iteration, and b values in the range b≤bmax.
If there is any such structure that is not a child of previously stored structures in Lt, we add that structure to Lt.
By the way that the list Lt is constructed, it is clear that it contains the minimum number of structures in L that need to be targeted for elimination
such that none of the LETS structures in L can exist in the code. (Elimination of a parent guarantees the elimination of all its children.)
The following is an example of finding Lt.
Example 1. In this example, we consider a QC-LDPC code construction with dv=3, g=8, and four different
ranges of interest r1:a≤6,b≤3, r2:a≤8,b≤3, r3:a≤10,b≤3, and r4:a≤12,b≤3.
The parent/child relationships between non-isomorphic LETS structures within the largest range r4 are shown in Fig. 1.
In Fig. 1, the direct (resp., indirect) children are those that are created from their parents by one expansion (resp., multiple expansions).
Different non-isomorphic structures within the same class are identified by different numbers in braces.
From Fig. 1, it is easy to see Lt sets for ranges r1 to r4 are Lt1={(5,3)}, Lt2=Lt1∪{(7,3){1},(7,3){2}},
Lt3=Lt2∪{(9,3){7,8,9,10,13,14,15,16,17}},
and Lt4=Lt3∪{(11,3){45,…,48,50,…,84,89,90,91,94,95,98,…,108,112,117,…,122}}, respectively.
As can be seen, ∣Lt∣ is considerably smaller than ∣L∣ for each range. For example for r4, ∣Lt4∣=74 versus ∣L∣=392.
IV-B Efficient Search Algorithm for LETSs in Lt
To search for all the LETS structures in Lt, we devise a backward recursion that starts from the LETS structures in Lt with the largest size (largest a).
Let such structures be denoted by S1, and let S=S1.
Since the structures in S cannot be reached through any LETS structure within Lt (or L) using dpl expansions,
we consider all the possible direct parents P of such structures outside L. The structures in P are those that can reach
at least one of the structures in S by the application of just one of the three dpl expansions. We then prioritize the
classes of the structures in P according to certain criteria discussed later.
Within the class with the highest priority, we then select structures using a greedy iterative process. The process starts by
selecting the structure in P that has the largest number of direct children in S. Denote this structure by ξ.
We move ξ from P to a set Π1 (Π1 is initially empty), and remove all the direct children of ξ from S. This ends the first iteration.
The iterations continue until the set S is empty or until no direct parent of the structures in S is left in the class with the highest priority.
In the former case, the first step of the recursion is completed. In the latter case, we move on to the class with the second highest priority
and apply the iterative process. This will continue until the set S is empty and thus the first step of the recursion is completed.
At this point, the set Π1 contains all the direct parents of the structures in S.
To start the next step of recursion, we consider S=Π1∪S2 as the new set S, where S2 denotes
the LETS structures in Lt with the second largest size. The steps of recursion will continue until all the LETSs in Lt are covered.
At the end of the recursion, the union of sets Πi contains all the out-of-range LETS structures that need to be included in the search process. A pseudo-code for
the process of obtaining out-of-range parent structures is given in Algorithm 1.
Now, we discuss the criteria that we use to prioritize the classes of structures in P.
The main idea is to give priority to classes that have a higher chance of having a smaller multiplicity in the graph.
This translates to a less complex search and smaller memory requirement. Since there is no
theoretical result available to predict the multiplicity of different LETS classes within a finite Tanner graph, we
rely on empirical results. In general, experimental results show that, for a given a, LETS
classes with smaller value of b have smaller multiplicity [11]. The empirical results also show that for two LETS classes (a,b) and (a′,b′),
where a<a′ and b<b′, the multiplicity of (a,b) class is generally smaller than that of (a′,b′) class [11].
Moreover, consider two classes
(a,b) and (a′,b′) of structures in P, where a<a′, and let S and S′ be two structures in the two classes, respectively.
Also suppose that S and S′ are direct parents of two structures ξ and ξ′, respectively, where both ξ
and ξ′ are in the same class (a",b") in S. The following lemma (Lemma 1) shows that, based on the
dpl characterization, we must have b<b′. (This implies that when all the structures in S belong to a single class,
then one can easily order the direct parent classes of such structures in P in accordance with the a or the b value of the classes, with
classes of smaller a and b values, or the same a value and smaller b, having a higher priority in the selection process.)
Lemma 1. *Consider variable-regular LDPC codes with variable degree dv≥3 and the dpl characterization of LETS structures within such codes.
For a given LETS class (a,b), suppose that classes (a1,b1),(a2,b2),…,(aq,bq) are all the direct parent classes of the (a,b) class.
For any two such parent classes, if ai<aj, then bi<bj. *
Proof. From [11], one can see that direct parent classes of the (a,b) class can be one of the two following classes: (a−1,b+2m−dv)),
or (a−m,b+2−m(dv−2)). The first parent class is for dotm expansion with 2≤m≤dv, and the second parent class is for pam expansion with
2≤m≤min{b/(dv−2),a−g/2−1}, and for lomc expansion with g/2≤m≤min{(b+1)/(dv−2),a−g/2−1} and g/2≤c≤m.
Since m≥2, it is clear that the a value for the parent classes corresponding to pam and lomc expansions is always smaller than that of the dotm
expansion. So, we first show that the corresponding b values follow the same trend. For this, we prove that the smallest b value for a parent class corresponding to
dotm is larger than the largest b value of a parent class corresponding to pam or lomc. In the case of dotm expansion, the smallest b value of
a parent class is b+2×2−dv=b−dv+4 since m≥2, and for pam or lomc expansion, the largest b value of a parent class is
b+2−2×(dv−2)=b−2dv+6, which is smaller than b−dv+4 for dv>2.
Considering that the parent classes corresponding to pam and lomc expansions are identical, to complete the proof, we just need to show that if
a−m1<a−m2, for some values of m1 and m2, then b+2−m1(dv−2)<b+2−m2(dv−2), which is clearly true under the condition that dv>2.
■
Based on the above discussions, to prioritize the structures in P, we first prioritize the classes: classes with smaller a and b values have
a higher priority and for the same value of a, classes with smaller b values have a higher priority. Within each class, we then prioritize the structures
based on the number of direct children that they have in S, where larger number of children means higher priority.
Example 2. Consider the code construction discussed in Example 1, where all the LETSs in r4 are to be avoided.
In this case, the set S1 consists of 62 structures in the (11,3) class. The careful study of these structures reveals that
all the (out-of-range) direct parents of these structures belong to (10,4) and (10,6) classes, and that the structures in
S1 are generated by the application of dot2 and dot3 expansions to these parent structures. Between the two classes
of (10,4) and (10,6), the priority is given to the parent structures in the (10,4) class since for the same value of a, this
class has a smaller b value compared to the (10,6) class. In total, 63 structures exist in the (10,4) class. By prioritizing these
structures based on the number of their direct children and choosing them iteratively in the order of their priority, we can cover
all the structures in S1 by choosing only 22 structures in the (10,4) class. These structures can generate
all the structures in S1 with the dot2 expansion. This ends the first step of the recursion. (see the last level of the trellis diagram in Fig. 2. To prevent the figure from being over crowded, rather than making a connection between each parent/child pair, for the last level, we have shown parents and their children collectively.)
For the second step, we have S=Π1∪S2, where Π1 is the set of the 22 structures in the (10,4) class and S2 consists of the 9
LETS structures in the (9,3) class of Lt. Investigating the direct (out-of-range) parent structures for the set S2, we find that they all belong to (8,4) and (8,6) classes, while for the 22 structures in the (10,4) class, the direct parent structures are in (8,4), (9,5), and (9,7) classes.
Among the direct parent classes of the set S, the highest priority is given to the (8,4) class since it has the smallest a and b values.
By the application of the iterative selection process to the structures in the (8,4) class, we can generate all the 9 structures in the (9,3) class and 7 out of 22 structures
in the (10,4) class, by using only 7 structures in the (8,4) class. The remaining 15 structures in the (10,4) class, however, cannot be generated by
the structures in the (8,4) class. To generate these remaining structures, the parent class with the highest priority (out of the two remaining classes that are direct parent classes
of the (10,4) class) is the (9,5) class. By the application of the iterative process to this class, the remaining 15 structures of the (10,4) class are generated through only 5
structures in the (9.5) class. (See the second last level of the trellis diagram in Fig. 2.)
In the next step of the recursion, the 7 and 5 structures from the (8,4) and (9,5) classes, respectively, along with the two (7,3) structures
in Lt form the set S. The outcome of this step of recursion can be seen in Fig. 2, together with the final step of the recursion,
that has all the simple cycles of length 8 and 10 as the output set Π4.
Corresponding to the trellis diagram of Fig. 2, we have the characterization table of LETSs for the proposed search, given at the top of Table II,
in comparison with the characterization table corresponding to the exhaustive search of [11] (limited to structures that exist in QC-LDPC codes, as explained in Section III),
given at the bottom. The entries of the table
correspond to different classes of LETSs. For each class, the top entry shows the non-isomorphic structures within the class that are involved
in the search process and the bottom entry shows the expansions that will have to be applied to all the instances of those structures.
By comparing the entries for similar classes in the top and the bottom parts of Table II, one can see
that both the number of structures and the variety of required expansions have decreased substantially in the proposed search algorithm
compared to the exhaustive search of [11]. As an example, for the (9,5) class, the proposed search algorithm only
needs to apply dot2 expansion to 5 structures. In comparison, the exhaustive search algorithm of [11]
requires the application of dot2,dot3 and pa2 expansions to 20 structures.
IV-C Layering of the Search Algorithm
To further reduce the complexity and memory requirement of our proposed search algorithm, we implement the algorithm in multiple layers.
We recall that the purpose of our search is to determine whether there exists at least one instance of one of the structures of L
in the graph. Consider the structures in Lt, and assume that they belong to classes with size a1,a2,…,aη, where a1<a2<…<aη.
To make the determination that whether there exists at least one instance of one of the structures of L
in the graph, rather than searching for all the structures in Lt in one shot, we first search for the structures in the class with size a1 (Layer 1).
If we can find at least one instance of a structure in this class, we terminate the search with a positive response. If the graph has
none of the structures of Lt with size a1, we continue our search to Layer 2, which contains structures in Lt with size a2.
We continue this process, until we either find one instance of one structure within one of the layers, or finish the search through all layers without finding
any LETS in Lt. In the former case, the search is terminated with a positive response, while in the latter case, the response is negative.
As an example, the four layers of the proposed search algorithm for the construction discussed in Examples 1 and 2, corresponding to classes
(5,3), (7,3), (9,3) and (11,3) in Lt are identified by different line types in Fig. 2.
Remark 1. For further memory reduction, in each layer of the search algorithm, we only keep those LETSs that are needed
for next layer(s) of our search algorithm. For example, in the second layer of Fig. 2 (solid lines), we only need to
keep (6,4){1} LETSs since these trapping sets are needed in third and fourth layers. Moreover, to further reduce the complexity,
we can perform the search process within each layer sequentially. For example, in the third layer of Fig. 2 (dash-dot lines),
we can first apply the expansions corresponding to the (9,3) structures originated from cycles of length 8,
and in the case that these trapping sets were missing in the graph, we can continue to search for the rest of the structures in the (9,3)
class that are originated from cycles of length 10.
IV-D Complexity of the Search Algorithm
In general, the complexity of the search algorithm depends on the multiplicity of different LETS structures involved in the search of the graph
and the expansions that are applied to them. There is however no theoretical result for the multiplicity of different LETS structures in finite graphs.
Moreover, as explained before, the graph itself changes throughout the construction process. In addition, in the layered implementation of the algorithm,
the complexity of the search can highly vary depending on the layer at which an instance of a structure may be found by the algorithm.
For these reasons, it is difficult to evaluate the complexity of the proposed search algorithm theoretically.
To compare the complexity of the proposed algorithm with that of the exhaustive search algorithm of [11], however, we count
the number of different LETS structures involved in the search and the different expansions that are applied to them. For this, we use
characterization tables such as those of Table II, and calculate the weighted sum of each expansion over different entries of the table
with the weights being the multiplicity of the structures in the corresponding class. Since different expansions have different complexities [11],
we count the weighted sum for each expansion, separately. These results for three construction scenarios are listed in Table III:
dv=3,g=8,r:a≤12,b≤3; dv=4,g=6,r:a≤8,b≤5; and dv=3,g=6,r:a≤11,b≤2. For each scenario,
we have listed the results for four search algorithms in four columns. The first column corresponds to the exhaustive search algorithm of [11]
where the QC structure of the graph is not taken into account. These results correspond to the characterization tables reported in [11].
In the second column, labeled as “QC,” we have reported the results corresponding to the exhaustive search algorithm of [11],
where the QC structure of the graph is taken into account. The difference between this case and the first was explained in Section III (Table I).
Finally, the third and fourth columns correspond to the proposed search algorithm for a general and a QC graph, respectively (where the advantages of layering are ignored).
As an example of how the results in Table III are obtained, consider the first construction scenario and the expansion pa3. For this case, the results reported in
Table III for the proposed QC search and QC search are 2 and 14, respectively. By examining the top part of Table II, one can see that
pa3 appears in only two entries corresponding to classes (4,4) and (5,5), where each class has only one structure, hence the result 1+1=2.
In the bottom table, however, pa3 appears in 7 entries corresponding to classes (4,4),(5,3),(5,5),(6,2),(6,4),(7,3), and (8,2), where
each class has the following number of structures: 1,1,1,1,2,3, and 5, respectively, which add up to 14.
The comparison of the results presented in Table III shows the considerable advantage of the proposed algorithm over the exhaustive search
of [11], for both a general and a QC graph. One should also note that further advantage is gained through the layered implementation
of the proposed search algorithm. Table III also demonstrates that the difference between the complexity of searching a general graph and that of searching a QC graph
is smaller for the proposed algorithm compared to the exhaustive search algorithm of [11].
V Construction of QC-LDPC Codes with Low Error Floor
In this part, we propose a construction method for protograph-based QC-LDPC codes with low error floor. The low error floor is achieved by avoiding the LETS structures within a
predetermined list of structures L. This is performed using the proposed search algorithm discussed in Section IV.
In this work, we tackle two problems related to designing QC-LDPC codes: (a) For a given base graph of size m×n, a given even integer g0,
and a given range a≤amax and b≤bmax, find a code with girth at least g0 that has the minimum lifting degree (block length) and does not have
any (a,b) LETS with a≤amax and b≤bmax; (b) For a given base graph, a given even integer g0, a given positive integer bmax,
and a fixed lifting degree N, find a code with girth at least g0 and lifting degree N that has no (a,b) LETS in the range a≤amax and b≤bmax,
where amax is maximized. We note that formulation of Problem (a) is similar to the formulation used in [10]. A similar formulation is also
commonly used in the context of designing QC-LDPC codes of a certain girth with minimum length (see, e.g., [18]). We further note that in Problem (a),
rather than a range for a and b values, one can use a list L of LETS structures to be avoided.
To design a QC-LDPC code based on a given base graph and a given lifting degree, we need to determine the nonzero elements of the
exponent matrix of (2). The design constraints are to maintain the girth to at least g0, and to ensure that no target LETS structure
from the list L exists in the code. In this work, to design the code, we use a greedy search algorithm in which the nonzero elements
of the exponent matrix P are selected column by column starting from the leftmost column. At each step, all the nonzero
elements of one column of P are assigned in random simultaneously. The sub-matrix of the parity-check matrix H corresponding to the selected columns of P
so far is then searched to see if the girth constraint is satisfied (no cycle of length less than g0 exists in the corresponding graph)
and that none of the structures in L exists in the sub-matrix. If the sub-matrix satisfies these constraints,
the algorithm moves on to the next step and assigns the permutation shifts of the next column of P. If the selected column fails
to satisfy the constraints, a new random column is selected and tested. This process will continue until a column is found that
satisfies the constraints or all the possible choices for that specific column are exhausted (although the choices are made randomly, repeated choices are avoided).
In the latter case, the algorithm back tracks to the previously selected column and makes a new random choice for it.
The algorithm will continue until all the columns of P are assigned and the corresponding H matrix satisfies all the constraints,
or until all the possibilities are exhausted without reaching a solution. A third possibility would be to stop the algorithm if
it fails to find a solution within a predetermined time period. Note that to search for the LETSs (of L) in the graph
corresponding to the sub-matrix of H at each step of the algorithm, we use the proposed layered search algorithm of Section IV.
VI Numerical Results
In this section, we report some of the constructed QC-LDPC codes based on the technique described in Section V. All the simulation results
are for binary-input AWGN channel, and a 5-bit min-sum decoder with clipping threshold equal to 2 [24],
and maximum number of iterations 100. For each simulated point, at least 100 block errors are collected.
As the first experiment, we tackle Problem (a) in Section V for a fully-connected 3×5 base graph (dv=3,dc=5), with the constraint g0=8, and with
no LETSs in ranges r1 to r4, described in Example 1. The lifting degrees and the exponent matrices of the constructed codes are given in
Table IV. To obtain the results for r1:a≤6,b≤3, we start from the minimum lifting degree required for having a code with girth 8, which is N=13 [18],
and increase the lifting degree N by one at each step until we can find a code which is free of LETSs within the range of interest.
For r1, the result presented in Table IV is optimal in that N=18 is the smallest lifting degree that can result in no LETSs within r1,
(i.e., all the possible exponent matrices for all the values of 13≤N≤17 were checked and none was completely free of LETSs in r1).
To obtain the results for the other ranges, since r1⊂r2⊂r3⊂r4, for each range ri,2≤i≤4, we start from the
smallest N value obtained for ri−1. For ranges r2,r3,r4, however,
the value of N presented in Table IV is an upper bound on the smallest lifting degree satisfying the design constraints, i.e., as the value of N was increased at each step by one,
we limited the search time for each N to 3 hours.444Our search algorithm is implemented in MATLAB and is run on a PC with 3.50 GHZ CPU and 32 GB RAM. If no exponent
matrix satisfying all the constraints was found during this time, we would increase N by one and restart the search.
Similar approach was used for the 3×6 base graph to design rate-1/2 QC-LDPC codes with girth 8 and free of LETSs within ranges r1 to r4.
The results are presented in Table V.
In [10], Problem (a) was tackled for fully-connected base graphs of size 3×5 and 3×6, g=8 and r2, i.e., a≤8,b≤3.
Based on the design approach of [10], it was shown that the minimum lifting degrees required to satisfy the trapping set constraint for
the two base graphs are N=41 and N=61, respectively. Using a search algorithm, the authors of [10] were able to find
QC-LDPC codes with girth 8 and lifting degrees 41 and 63 for the two base graphs, respectively, that were free of LETSs within r2,
In comparison, the codes designed here have N=26 and N=41 for 3×5 and 3×6 base graphs, respectively.
These codes are significantly superior to those found in [10], in the sense that they have the same girth and
degree distribution and satisfy the same trapping set constraint but have a much smaller block length.
The main reason for the improved results in this work compared to [10] is that, contrary to the approach adopted here which in fact
imposes a necessary and sufficient condition for removing all the LETS structures within the targeted range, in [10],
the authors targeted the (5,3) and (6,4){1} structures. Note that (6,4){1} structure is a parent to some of the targeted structures in the range
but is not of interest itself. This imposes a sufficient but not necessary condition for removing the targeted LETSs.
This unnecessary constraint imposed on the design degrades the quality of the achievable solution.
As another example, we design a QC-LDPC code C1 lifted from the 3×5 fully-connected base graph with lifting degree N=41, with g=8, and
free of LETSs within the union of two rectangular regions a≤10,b≤3, and a≤12,b≤2. The exponent matrix of C1 is
[TABLE]
This code has the same degree distribution and block length as the code designed in [10], but is free of LETS structures within a much larger region.
(See Table VI for the comparison of LETS distributions. In the table, we have only listed the classes for which at least one code has non-zero multiplicity).
As another experiment, we construct a QC-LDPC code which has similar parameters to the well-known (155,64) Tanner code [25], but has a lower error floor.
Tanner code is a cyclic lifting of the fully-connected 3×5 base graph with N=31 and has g=8. A similar code was also designed in [9] with the goal of
reducing the error floor by removing all (5,3) LETSs and minimizing the number of (6,4) LETSs in the Tanner graph of the code.
In this case, we use the formulation of Problem (b) in Section V for the fully-connected 3×5 base graph with N=31 and g0=8.
We consider two cases of bmax=3 and bmax=2, and are able to construct two codes that are free of LETS structures
up to size amax=8 and amax=10, respectively. Then, we target the union of the LETSs within the two regions a≤8,b≤3, and a≤10,b≤2,
and are able to design a code C2 with N=31 and g=8 that has no LETS within the targeted region.
The exponent matrix of this code is as follows
[TABLE]
We have presented the multiplicities of LETSs of the designed code and those of the Tanner code as well as the code designed in [9] in Table VII.
It is well-known that the most dominant trapping sets of the Tanner code are (8,2) and (10,2) LETSs, respectively.
Both structures are completely removed from C2. On the other hand, for the code of [9], although
the (8,2) LETSs are removed, there are still a number of (10,2) LETSs present. This code also has 31 instances of the
(7,3) LETS, another potentially problematic structure. We have compared the frame error rate (FER) of the constructed code
C2 with those of Tanner code and the code of [9] in Fig. 3.
The superior performance of C2 over both Tanner code and the code of [9] in the error floor region can
be observed. Based on the LETS multiplicities presented in Table VII, we expect the performance gap between C2
and the code of [9] to increase by further increase in the signal-to-noise ratio (SNR). In fact,
based on the simulation results, at SNR = 6 dB, 44 out of 100 errors of the code designed in [9]
are (10,2) LETSs, which are completely absent in C2.
As another example, we construct girth-6 codes following the formulation of Problem (a), and by using the fully-connected 3×5 base graph
with the constraint that the code is free of LETSs within 4 different ranges as shown in Table VIII.
The smallest lifting degree and the exponent matrix for each case are also given in Table VIII. For the first range, a≤5 and b≤2,
our search result is exhaustive and N=10 is in fact the smallest possible lifting degree that can satisfy the LETS constraint.
For the other ranges, the search is not exhaustive and the given value of N provides an upper bound on the smallest lifting degree.
We have included the FER of the code C3 designed to be free of LETSs in the range a≤11,b≤2, in Fig. 3.
As can be seen, this code handily outperforms the Tanner code in the error floor region. This is impressive, considering that both the
girth and the block length of C3 are smaller than those of the Tanner code (6 vs. 8, and 145 vs. 155, respectively).
To further demonstrate the strength of the designed codes, we consider the code whose exponent matrix is given in the last column of Table V, and compare
it with similar codes (3×6 fully-connected base graph, N=80 and g=8) constructed using the well-known QC-PEG [3] and Improved QC-PEG [9] methods.
The multiplicities of LETSs for the three codes are presented in Table IX. As can be seen from the table, many of LETSs that dominate the error floor performance of the other two codes
are absent from the Tanner graph of the designed code. To investigate this further, in Fig. 4, we have provided the FER of the three codes.
Fig. 4 shows the superior error floor performance of the designed code. Based on the simulation results, the dominant trapping set structures of QC-PEG code
are (8,2) and (10,2). In the code of [9], the (8,2) structure has been removed and thus the error floor performance has improved compared to the QC-PEG code.
The dominant trapping sets of the code of [9] are in (10,2) and (12,2) classes, followed by (7,3) and (9,3) classes.
All of these classes however, are absent from our designed code, thus the superior error floor performance.
All the examples given so far, similar to the majority of the results available in the literature, were for codes with dv=3.
To demonstrate the generality of our method, we also construct girth-6 codes
from the fully-connected 4×6, 4×8 and 4×16 base graphs following the formulation of
Problem (a) in Section V. For each base graph, four codes are designed, where the LETS structures within 4 different ranges are avoided.
The results are presented in Tables X, XI, and XII, respectively. All the values of N in these tables are upper bounds on
the smallest lifting degree that can satisfy the corresponding LETS constraint, with the exception of the result of N=7 in Table X,
which is in fact the smallest lifting degree that can result in a code free of LETSs within the range a≤5,b≤5.
We note that Diouf [26] has constructed a protograph-based QC-LDPC code with g=6
and free of the (4,4) LETS structure using the 4×6 fully-connected base graph with N=7.
An examination of the code of [26] reveals that its LETS distribution within the range a≤8,b≤5 is the same as that of the code designed here.
As another example, we consider the regular (576,432) QC-LDPC code with dv=4 designed in [27]. This code is designed based on array dispersion method,
where first a 4×36 exponent matrix with lifting degree N=36 is constructed, and then, 16 columns of this matrix are selected
such that the resulting code contains fewer short cycles and larger girth. For comparison, we design a cyclic lifting C4 of the 4×16 base graph with N=36 and g=6
and free of LETSs within the union of the ranges a≤5,b≤5 and a≤8,b≤3:
[TABLE]
In Table XIII, we have listed the LETSs of C4 and the code of [27] in the range a≤8,b≤6.
The FER curves for the two codes are also given in Fig. 5. These results clearly show the superior LETS distribution and error floor performance of C4.
As the final example, we consider a (2133,1817) array-based code with lifting degree N=79, dv=4, and dc=27. To construct this code, similar to the previous example,
first a 4×79 exponent matrix is generated, and then 27 columns of this matrix are chosen such that the resulting code has fewer short cycles and larger girth [27].
For comparison, we then use our technique to construct a code C5 with similar parameters (N=79, dv=4, dc=27) which is free of LETSs within the union of
the ranges a≤7,b≤5, and a≤8,b≤3. The exponent matrix of C5 is given by:
[TABLE]
The exhaustive search of LETSs within the range of a≤8 and b≤5 for C5 reveals that this code has only one class, i.e., (8,4), within this range with non-zero multiplicity. The multiplicity of (8,4) LETSs in C5 is 5925. On the other hand, the code of [27] has three classes with non-zero multiplicity in the range a≤8, b≤5. These classes are (7,4),(8,2) and (8,4), with multiplicities 9006,3634, and 122450, respectively. As can be seen, the designed code has a superior LETS distribution, and thus a lower error floor, compared to the code of [27]. In fact, our simulations show that the most dominant class of trapping sets in the code of [27] is the (8,2) class, which is completely absent in the designed code.
Finally, in order to demonstrate the complexity reduction of the proposed search technique in comparison with the dpl search of [11], in Table XIV, we have listed the run-time of both algorithms for finding the solutions in the largest ranges of Tables IV, V, X, XI, and XII. As can be seen, in all cases, the proposed algorithm is much faster than that of [11] by up to
more than one order of magnitude.
VII Conclusion
In this paper, we proposed a systematic and efficient method to construct protograph-based QC-LDPC codes. We first examined
the trapping set structures of such codes, and demonstrated that some of the structures that can exist in a general (randomly constructed) code
cannot exist in codes that have QC structure. This was done through the transformation of the problem into a graph coloring problem and was
the first step in a series of steps devised to simplify the design of QC-LDPC codes. The next step was to develop an efficient layered dpl-based
search algorithm for finding a targeted set of trapping sets that are to be avoided in the code (for a good error floor performance).
The algorithm was devised as a backward recursion to minimize the number of intermediate structures and the expansions that were needed to search for the targeted trapping sets,
as well as to use structures that have a higher chance of having a lower multiplicity in the graph. Numerous codes were constructed using the proposed
design technique with superior performance compared to the existing codes in the literature. The systematic
approach of the design makes it applicable to codes with different node degrees (rate), girths and block lengths with the flexibility of selecting
any set of target trapping sets. The efficiency of the search algorithm makes it possible to design codes with larger degrees and block lengths which are
free of trapping sets in larger regions compared to what was achievable before.
We note that while our discussions in this paper are limited to QC-LDPC codes with fully-connected base graphs, many of the ideas can also be applied, in principle,
to the construction of other types of QC-LDPC codes including those with irregular or partially-connected base graphs. The details of such constructions can be an interesting
topic of future research. We also note that the proposed search algorithm of Section IV can be used in combination with any design technique that involves
searching a Tanner graph for certain targeted trapping set structures throughout the construction process. The construction technique of Section V is just one such example.
Moreover, the layered characterization/search algorithm of LETSs, proposed in Section IV, can also be used to construct LDPC codes with low error
floor that lack the QC structure. The only difference, compared to what is presented in this paper for QC-LDPC codes, is that for codes lacking the QC structure
the number of possible LETS structures is larger.
