 Research
 Open Access
 Published:
Optimizing quasicyclic spatially coupled LDPC codes by eliminating harmful objects
EURASIP Journal on Wireless Communications and Networking volume 2023, Article number: 67 (2023)
Abstract
It is well known that some harmful objects in the Tanner graph of lowdensity paritycheck (LDPC) codes have a negative impact on their error correction performance under iterative messagepassing decoding. Depending on the channel and the decoding algorithm, these harmful objects are different in nature and can be stopping sets, trapping sets, absorbing sets, or pseudocodewords. Differently from LDPC block codes, the design of spatially coupled LDPC codes must take into account the semiinfinite nature of the code, while still reducing the number of harmful objects as much as possible. We propose a general procedure, based on edge spreading, enabling the design of good quasicyclic spatially coupled LDPC (QCSCLDPC) codes. These codes are derived from quasicyclic LDPC (QCLDPC) block codes and contain a considerably reduced number of harmful objects with respect to the original QCLDPC block codes. We use an efficient way of enumerating harmful objects in QCSCLDPCCs to obtain a fast algorithm that spans the search space of potential candidates to select those minimizing the multiplicity of the target harmful objects. We validate the effectiveness of our method via numerical simulations, showing that the newly designed codes achieve better error rate performance than codes presented in previous literature.
1 Introduction
Lowdensity paritycheck (LDPC) convolutional codes or (SCLDPCCs), which have been introduced in [1] as the convolutional counterpart of LDPC block codes [2], have attracted much interest from the scientific community in recent years. Efforts have been expended in order to make them suitable for wireless communications [3, 4]. This is due to the fact that while LDPC block codes are known to approach the channel capacity [5], terminated SCLDPCCs have been shown able to achieve the channel capacity under belief propagationbased iterative decoding, for a wide range of channels, owing to the convolutional structure of their paritycheck matrix, which triggers the wellknown threshold saturation phenomenon [6,7,8].
The performance of such iterative decoders, however, is significantly affected by the code representation, in addition to its structural properties. In fact, iterative decoding is performed on a bipartite graph known as Tanner graph [9], which has a small number of edges corresponding to the small number of ones in the sparse paritycheck matrix of an LDPC code. It is well known that some properties of the Tanner graph, like short cycles, negatively affect the performance of iterative decoders. Other wellknown harmful objects in the Tanner graph are called stopping sets [10], which determine the failure of iterative decoding algorithms over the binary erasure channel. Different families of harmful objects are of interest to characterize the performance of these decoders over different channels, such as trapping sets for the additive white Gaussian noise (AWGN) channel [11]. A special subclass of trapping sets, known as absorbing sets, was shown to strongly affect the performance of bitflipping iterative decoders [12]. In many cases, there is a strong connection between these harmful objects and cycles in the Tanner graph of a code [13,14,15]. In particular, in [13, 14] it has been shown that starting from a cycle, or a cluster of cycles in the Tanner graph of a regular or irregular LDPC block code, any trapping set can be obtained by means of some graph expansion technique.
The presence of the aforementioned harmful objects may yield an important degradation of the error correction performance of an iteratively decoded code, especially in the socalled errorfloor region, i.e., the high signaltonoise ratio region. Although the effect of harmful objects on the performance of iterative decoders depends on both the specific decoding algorithm and the channel, reducing the number of harmful objects generally is an important target to optimize the performance of LDPC codes. Two main approaches can be adopted to this end: i) avoiding or reducing harmful objects during code design [15,16,17] and ii) modifying the decoding algorithm in such a way as to be less affected by harmful objects [18, 19]. Solutions combining both approaches have also been proposed [20]; however, the former approach has generally received more attention than the latter, because working at design stage provides more degrees of freedom than acting on the decoding algorithm and thus opens more avenues for performance optimization. For this reason, we focus on the former approach to optimize the performance of SCLDPCCs.
One common method for the design of SCLDPCCs starts from LDPC block codes and exploits an edgespreading procedure to achieve a convolutional version of the block code [21]. This is a generalization of the unwrapping technique introduced in [1, 22]. When SCLDPCCs are designed following this approach, the harmful objects of the SCLDPCC derive from the corresponding objects of the underlying LDPC block code, and their multiplicity depends on the adopted edgespreading technique. Thus, for a given LDPC block code, the problem of designing good SCLDPCCs from the harmful objects reduction standpoint translates into the problem of finding good spreading matrices. For the sake of brevity, in the rest of the paper we denote quasicyclic SCLDPCCs (QCSCLDPCCs) obtained from quasicyclic lowdensity paritycheck (QCLDPC) block codes by edge spreading as QCSC codes. The matrix according to which spreading is performed is called spreading matrix and denoted as \(\textbf{B}\). The edgespreading procedure can also be displayed graphically by means of protographs, which are Tanner graphs with a relatively small number of variable and check nodes. We remark that the matrix and the graphical interpretations are completely equivalent. Protographbased codes with excellent asymptotic and finitelength performance have been designed; see, for example, [23,24,25].
1.1 Previous work
A straightforward approach to the aforementioned optimization problem is that of exhaustively exploring the space of spreading matrices, which obviously poses complexity issues. Some previous works have addressed the problem of reducing the search space of candidate spreading matrices. A basic approach was proposed in [26], where the authors minimize the number of (3, 3) absorbing sets (ASs) in (m, n)regular (AB) QCSC codes with \(m=3\), obtained through cutting vectors, which are a subclass of spreading matrices (see [27] for further details). Such an approach is very efficient, since it relies on an integer optimization procedure, but the spanned search space is very small. In fact, the cutting vectors, as defined in [26, 27], only support QCSC codes with memory \(m_s=1\) and they only cover \(\left( {\begin{array}{c}n\\ 3\end{array}}\right)\) spreading matrices, instead of the total \(8^n\). This yields a nonnegligible probability that some optimal matrices are left out of the search.
In [28], a guided random search is used to find optimal spreading matrices for (m, n)regular AB QCSC codes with \(m=3\), where a small subset of all the possible columns is considered in such a way that the spreading matrix is “balanced.” Although this approach can result in a reasonably fast search, especially if the subset contains a small number of elements, it is expected to be suboptimal, since it spans a search space which is considerably smaller than the whole space, without considering any optimization criterion. In particular, when \(m_s=1\) (\(m_s=2\), respectively), given that \(m=3\), the guided random search in [28] includes \(5^n\) out of the total \(8^n\) (\(27^n\), respectively) possible spreading matrices.
The method proposed in [29] is similar to that proposed in [28]. In fact, only a subset of all the possible spreading matrices is considered, such that each possible entry of \(\textbf{B}\), which is in \(\{0,1,\ldots ,m_s\}\), appears \(\frac{nm}{m_s+1}\) times. This also results in a type of balanced spreading matrix. Nevertheless, in this case, the search may again be nonoptimal, since a large number of spreading matrices are excluded a priori (more details on the computation of the exact number of candidates are provided in [29] and are omitted here for saving space).
The approach in [30] relies on a searching algorithm which is not described in the original paper. For this reason, we are not able to estimate the number of candidates it considers. Nevertheless, the authors of [30] mention that the search is limited, implying that it suffers from similar limitations as the methods proposed in [28, 29]. Finally, in [31, 32], a twostage procedure is proposed: First, an optimal partitioning is applied; then, the shifts of the circulant matrices are adapted in order to minimize the number of harmful objects. However, the adaption of the shifts alters the initial code. Our focus is on the first stage of the approach proposed in [31], since our method assumes that the underlying block code is fixed. Under such an assumption, our method outperforms the approach proposed in [31], as we will show in Sect. 4. Combining our method with a preliminary optimization stage of the starting block code is an avenue for further optimization, but is beyond the scope of this paper.
As summarized above, most of the previous approaches consider only certain code structures and certain harmful objects to make their search feasible. Namely, for (m, n)regular codes, only \((3,3(m2))\) trapping sets (i.e., cycles of length 6 for the considered codes), whose minimization is shown to be beneficial also to the minimization of (4, 2), (4, 4) and (5, 3) trapping sets (among others), are the target of the minimization algorithms in [26,27,28,29,30,31]. In [32], \((4,4(m2))\) trapping sets are also targeted. Furthermore, many possible solutions are excluded a priori. In [28, 29, 31, 33], for example, it is shown that the multiplicity of harmful objects can be significantly reduced by increasing the memory of SCLDPCCs. However, the computational complexity of the aforementioned approaches makes them unsuitable for the design of SCLDPCCs with moderate and large memories.
A quite different approach has been proposed in [34]. In that work, the authors deal with the construction and performance of SCLDPCCs with finite memory (expressed as smoothing parameter w, such that \(w=m_s1\)), showing through asymptotic analysis that nonuniform coupling yields to faster decoding convergence with respect to uniform coupling. Such a method differs from ours in that it is tailored to the binary erasure channel (BEC), relies on asymptotic analysis (and therefore does not take into account the harmful objects influencing finitelength performance), and is restricted to small values of the memory.
To the best of the authors’ knowledge, except for the method concurrently proposed in [35], a general scheme enabling the construction of optimized QCSC codes (in terms of minimization of harmful objects) with moderate memories is still missing in the literature.
1.2 Our contribution
We propose an algorithm that, given any QCLDPC block code, exploits a smart strategy to construct a QCSC code containing the smallest possible number of target objects (or combinations of objects), which are the most harmful ones for the given channel and decoding algorithm. We generalize the algorithm proposed in [36], which takes the target length of cycles as input without distinguishing those that are actually harmful from those that are not. The approach in [36] is efficient when the most harmful objects are cycles, or combination of a few short cycles, and if their multiplicity is relatively small. However, when the most harmful objects have a more complicated structure, targeting all the cycles with a given length for removal may not be an efficient approach. Moreover, for a given value of the memory of the convolutional code, a solution allowing the elimination of all the cycles with a given length may not exist, and the algorithm in [36] is unable to identify the subset of cycles that should be removed in order to eliminate as many harmful objects as possible. In this work we overcome such a limitation and improve over [36] in that:

we provide new theoretical results on spreading matrices and trapping sets;

we propose an algorithm which starts from any set of objects as input and tries to minimize their multiplicity. These objects are not necessarily cycles and do not necessarily have the same size;

the proposed algorithm is not necessarily exhaustive, in that it does not necessarily target all the objects in the set of interest;

we estimate the complexity of the new algorithm and verify that, based on the aforementioned theoretical results, when targeting cycles, it is significantly faster than the exhaustive search and than that in [36].
We demonstrate the effectiveness of the proposed procedure for several exemplary code constructions with variable code memories via enumeration of the target harmful objects and computer simulations. Such a procedure is shown to be particularly effective for harmful objects that correspond to relatively large combinations of short cycles in the code Tanner graph and on codes with a large multiplicity of harmful objects. Even though the analysis carried out in this paper is limited to regular codes, in principle the proposed algorithm also works for irregular codes. However, irregularity yields an increase of the degrees of freedom in the exponent matrix design which, in turn, leads to a larger number of elementary structures forming the harmful objects. Therefore, the computational complexity of their enumeration would inevitably increase.
We also prove that the average number of cycles per node in the unterminated version of the paritycheck matrix can be assessed with the sole knowledge of the spreading matrix and of the list of the corresponding cycles in the underlying block QCLDPC code, which, in turn, can be determined by means of the code exponent matrix. A similar analysis is carried out in the concurrent work [35]. This yields a significant reduction in the computational effort, as the most costly procedure is carried out on a relatively small matrix, i.e., the exponent matrix of the block QCLDPC code, compared to the semiinfinite exponent matrix of the QCSC codes. This is the main reason of the speedup achieved by the algorithm we propose with respect to that in [36], when it targets sets of cycles. Instead, when trapping sets are targeted by our algorithm, with the aim of reducing their multiplicity as much as possible, the counting algorithm we employ is the one proposed in [14], which is already very efficient. Note that, alternatively, elementary trapping sets can be characterized through edgecoloring techniques exploiting the base matrix, as reported in [37].
We remark that the result of the spreading matrix optimization is tied to the choice of the initial QCLDPC block code. The focus of this paper is not on the optimization of the original QCLDPC block code, for which a great amount of literature already exists, but rather on the optimization of the corresponding convolutional version. Thus, in order to show the effectiveness of the proposed algorithm, we stick to block code designs leading to spreading matrices with a simple structure, such as array codes [38] and Tanner codes [22], whose properties are well known and allow us to perform a fair comparison with previous literature.
1.3 Outline of the paper
The paper is organized as follows. In Sect. 2, we introduce the notation used throughout the paper and some basic concepts regarding QCLDPC block codes and SCLDPCCs derived from them. In Sect. 3, we focus on edgespreading matrices and the corresponding cycle properties and describe the proposed algorithm. In Sect. 4, we discuss some code examples and assess the corresponding performance. In Sect. 5 we provide a complexity estimate for our algorithm. Finally, in Sect. 6 we draw some conclusions.
2 Notation and definitions
In this section we introduce the notation and definitions we use throughout the paper, and we present the edgespreading procedure we consider to obtain QCSC codes from QCLDPC block codes.
2.1 QCLDPC codes
We consider QCLDPC block codes defined through a paritycheck matrix \(\textbf{H}\) in the form of an \(m \times n\) array of \(N \times N\) circulant permutation matrices (CPMs) or allzero matrices. We do not consider circulant matrices with weight larger than 1, since largeweight circulants yield short unavoidable cycles [39, 40], which are likely to form harmful objects. We denote a CPM of size \(N\times N\) as \(\textbf{I}(p_{i,j})\), \(i\in \{0,1,\ldots ,m1\}\), \(j\in \{0,1,\ldots ,n1\}\), where \(p_{i,j}\in \{\infty , 0, 1, \ldots , N1 \}\) and N is the lifting degree of the code. When \(p_{i,j} \ne \infty\), \(\textbf{I}(p_{i,j})\) is obtained from the identity matrix through a cyclic shift of its rows to the left by \(p_{i,j}\) positions. Conventionally, we denote the allzero matrix by \(\textbf{I}(\infty )\). The code length is \(L=nN\). The exponent matrix of a code is the \(m \times n\) matrix \(\textbf{P}\) containing the values \(p_{i,j}\) corresponding to the CPM forming the code paritycheck matrix. A bipartite graph \({\mathcal {G}}(\textbf{H})\), known as Tanner graph, is associated to any paritycheck matrix \(\textbf{H}\) as follows:

any column of \(\textbf{H}\) corresponds to a variable node;

any row of \(\textbf{H}\) corresponds to a check node;

there is an edge between the ith check node and the jth variable node if and only if the (i, j)th entry of \(\textbf{H}\) is 1.
The set of \(L=nN\) variable nodes is denoted as \({\mathcal {V}}\), and the set of mN check nodes is denoted as \({\mathcal {P}}\). The set of edges is denoted as E. Thus, \(\textbf{H}\) coincides with the biadjacency matrix of \({\mathcal {G}}(\textbf{H})\) and we also denote \({\mathcal {G}}(\textbf{H})\) as \({\mathcal {G}}({\mathcal {V}} \cup {\mathcal {P}},E)\).
Definition 1
Two bipartite graphs \({\mathcal {G}}_1\left( {\mathcal {V}}_1 \cup {\mathcal {P}}_1, E_1\right)\) and \({\mathcal {G}}_2\left( {\mathcal {V}}_2 \cup {\mathcal {P}}_2, E_2\right)\) are isomorphic if there is a bijection \(f: {\mathcal {V}}_1 \cup {\mathcal {P}}_1 \rightarrow {\mathcal {V}}_2 \cup {\mathcal {P}}_2\) such that \(e_1 = \left\{ v_1, p_1 \right\}\) is an element of \(E_1\) if and only if \(e_2 = \left\{ f\left( v_1\right) , f\left( p_1\right) \right\}\) is an element of \(E_2\).
Definition 2
Equivalently, if \(\textbf{H}_1\) and \(\textbf{H}_2\) are the biadjacency matrices of the isomorphic graphs \({\mathcal {G}}_1(\textbf{H}_1)\) and \({\mathcal {G}}_2(\textbf{H}_2)\), respectively, we say that \(\textbf{H}_1\) and \(\textbf{H}_2\) are graphisomorphic.
If two paritycheck matrices are graphisomorphic, then also their exponent matrices are graphisomorphic.
Definition 3
For the sake of conciseness, with a slight mathematical abuse, we say that graphisomorphic paritycheck matrices define isomorphic codes.
Isomorphic graphs have the same girth and performance under iterative decoding.
Let us consider the subgraph induced by a subset \({\mathcal {D}}\) of \({\mathcal {V}}\) and the corresponding set of neighboring check nodes. We define \({\mathcal {E}}({\mathcal {D}})\) and \({\mathcal {O}}({\mathcal {D}})\) as the set of neighboring check nodes with even and odd degree in such a subgraph, respectively. The girth of \({\mathcal {G}}(\textbf{H})\), noted by g, is the length of the shortest cycle in the graph.
Definition 4
An (a, b) absorbing set (AS) is a subset \({\mathcal {D}}\) of \({\mathcal {V}}\) of size \(a > 0\), with \({\mathcal {O}}({\mathcal {D}})\) of size \(b\ge 0\) and with the property that each variable node in \({\mathcal {D}}\) has strictly fewer neighbors in \({\mathcal {O}}({\mathcal {D}})\) than in \({\mathcal {P}} {\setminus } {\mathcal {O}}({\mathcal {D}})\). We say that an (a, b) AS \({\mathcal {D}}\) is an (a, b) fully AS (FAS) if, in addition, all nodes in \({\mathcal {V}} \setminus {\mathcal {D}}\) have strictly more neighbors in \({\mathcal {P}} {\setminus} {\mathcal {O}}({\mathcal {D}})\) than in \({\mathcal {O}}({\mathcal {D}})\).
For a QCLDPC block code defined by the paritycheck matrix \(\textbf{H}\), a necessary and sufficient condition on the entries of \(\textbf{P}\) for the existence of N cycles of length 2k in \({\mathcal {G}}(\textbf{H})\) is [41]
where \(n_{k}=n_{0}\), \(m_{i} \ne m_{i+1}\), \(n_{i} \ne n_{i+1}\). In the rest of the paper, we refer to cycles in \({\mathcal {G}}(\textbf{H})\) and cycles in \(\textbf{H}\) interchangeably. Hence, for some given values of m and n, and for a fixed value of N, one has to find a matrix \(\textbf{P}\) whose entries do not satisfy (1) for any value of \(k < g/2\) and for any possible choice of the row and column indexes \(m_i\) and \(n_i\) in order to achieve a certain girth g.
2.2 QCSC codes based on QCLDPC codes
The edgespreading procedure we consider to obtain QCSC codes from QCLDPC block codes exploits an \(m \times n\) spreading matrix \(\textbf{B}\) with entries in \({\mathbb {Z}}_{m_s+1}\), where \(m_s\) represents the memory of the resulting QCSC code. The spreading matrix \(\textbf{B}\) can also be represented as an integer spreading vector \(\textbf{b}\) of length n, where the ith element (\(b_i\)) is obtained by replacing the ith column of \(\textbf{B}\), which is a vector in \({\mathbb {Z}}_{m_s+1}^m\), with its decimal representation, i.e., \(b_i=\sum _{j=0}^{m1} b_{j,i} (m_s+1)^{m1j}\). Conversely, \(\textbf{B}\) can be obtained from \(\textbf{b}\) by replacing each decimal entry with the associated \((m_s+1)\)ary column vector of length m with entries in \({\mathbb {Z}}_{m_s+1}\). Without loss of generality, we assume that in any column of \(\textbf{B}\) the most significant symbols are those with the smallest row indices. A straightforward conversion from \(\textbf{B}\) to \(\textbf{b}\) will be shown in Example 1.
A convolutional exponent matrix derived from \(\textbf{B}\) has the following form
where each matrix \(\textbf{P}_k\), \(k\in \{0,1,\ldots , m_s\}\), has the entry at position (i, j) equal to
and \(B_{i,j}\) is the (i, j)th entry of \(\textbf{B}\). Let us remark that \(\infty\) represents void entries in the convolutional exponent matrix and corresponds to the \(N\times N\) allzero matrix in the associated binary paritycheck matrix. Notice that the entries of \(\textbf{P}_{[0,\infty ]}\) which are outside the main diagonals are \(\infty\) and have been omitted from (2) for the sake of readability. The paritycheck matrix of the QCSC code is then obtained as
where the appropriate \(N\times N\) CPM is substituted for the entries of \(\textbf{P}_{[0,\infty ]}\) which have values in the set \(\{ 0,1,\ldots , N1 \}\), and the \(N\times N\) allzero matrix is substituted for the entries of \(\textbf{P}_{[0,\infty ]}\) equal to \(\infty\). The constraint length of the code is defined as \(\nu _s=L(m_s+1)\). Any set of columns of \(\textbf{H}_{[0,\infty ]}\) with indexes in \(\{jnN,\ldots ,(j+1)nN1\}\), \(j=0,1,\ldots\), is named the jth column block. \(\textbf{H}_{[\alpha ,\beta ]}\) represents a terminated version of \(\textbf{H}_{[0,\infty ]}\), obtained by considering the columns of the semiinfinite paritycheck matrix with indexes in \(\{\alpha nN,\ldots ,\beta nN1\}\), i.e., by considering the consecutive column blocks from the \(\alpha\)th to the \((\beta 1)\)th.
Let us introduce a straightforward result on the maximum possible span of a cycle.
Lemma 1
A cycle with length \(\lambda\) is contained within \(\textbf{H}_{[k,k+\lfloor \frac{\lambda }{4}\rfloor m_s]}\), where k is arbitrary.
Proof
Consider that a cycle with length \(\lambda\) has \(\frac{\lambda }{2}\) horizontal edges and \(\frac{\lambda }{2}\) vertical edges and any horizontal edge can span at most \(m_s+1\) column blocks of \(\textbf{H}_{[0,\infty ]}\). Any cycle spanning the largest number of column blocks of (4) has horizontal edges spanning \(m_s+1\) columns. In this scenario, starting from any of the leftmost nodes, \(\frac{\lambda }{2}\) edges are required to reach any of the rightmost nodes, and as many edges are needed to return to the not visited leftmost node. Thus, the number of spanned column blocks is at most
\(\square\)
We remark that, for finite n, the girth of regular timeinvariant codes, such as those considered in this paper, is upper bounded by a value that does not depend on the code memory [42]. In sight of this, and of the finite circulant size of the starting QCLDPC code, asymptotic analysis density evolution techniques such as those in [5, 6, 43], which rely on the assumption of infinite girth, may not be the most suited tools to predict the performance of designed codes.
Example 1
Consider the (3, 5)regular array LDPC block code with the exponent matrix
and \(N=5\). Consider also the \(m_s=2\) spreading matrix \(\textbf{B}\) with columns with entries in \({\mathbb {Z}}_{3}\) corresponding to the spreading vector \(\textbf{b}\), where
Then the constituent blocks of \(\textbf{P}\) are
and
where, for simplicity, \(\infty\) has been expressed as –. \(\square\)
2.3 Exhaustive analysis of spreading matrices
According to the definition given in Sect. 2.2, there are \((m_s+1)^{mn}\) possible spreading matrices. However, some of them define isomorphic codes. When performing an exhaustive analysis, the size of the search space can be reduced, without loss of completeness, using the following property (from [44]):
Lemma 2
Let \(\textbf{P}_1\) and \(\textbf{P}_2\) be exponent matrices. If \(\textbf{P}_1\) can be obtained by permuting the rows or the columns of \(\textbf{P}_2\), or if \(\textbf{P}_1\) can be obtained by adding or subtracting (modulo N) the same constant to all the elements of a row or a column of \(\textbf{P}_2\), then the corresponding codes are isomorphic.
It follows from Lemma 2 that the set of exponent matrices that contain at least one zero in each column represents, without loss of generality, the entire space of exponent matrices. Similarly, it is straightforward to show that the set of spreading matrices containing at least one zero in each column represents, without loss of generality, the entire space of spreading matrices. Each of the m entries of a column of \(\textbf{B}\) can assume values in \(\{0,1,\ldots ,m_s\}\), and thus, there are \((m_s+1)^m\) possible column choices. However, we can remove the \(m_s^m\) columns which do not contain any zero entries. It follows that
spreading matrices cover the whole search space. It is straightforward to notice from (7) that the number of candidate spreading matrices becomes very large as the values of m, n and \(m_s\) increase. For this reason, in Sect. 3.2 we propose a novel procedure which allows one to efficiently distinguish “good” candidates from “bad” candidates. Such an algorithm, based on a treesearch, does not exclude any candidate spreading matrix a priori.
3 Methods/experimental
In this section we introduce some theoretical results and propose a novel search algorithm for counting the average number of cycles in QCSC codes. Moreover, we introduce the spreading matrix search algorithm we use to minimize as much as possible the number of target harmful objects.
3.1 Spreading matrices selection criteria
As mentioned in Sect. 2, trapping sets (and therefore absorbing and fully absorbing sets) often originate from cycles, or clusters of cycles. In this section we prove conditions on the existence of cycles in \(\textbf{H}_{[0,\infty ]}\); this allows us to derive the number of equations that must be checked for each candidate spreading matrix in order to verify if it is a good or bad candidate. The goodness of a candidate is measured by the number of harmful objects of the underlying block code that are eliminated in the corresponding QCSC code.
Definition 5
Let us consider a block code described by \(\textbf{P}\), such that entries
satisfy (1). Then, we say that the code contains a block cycle with length \(\lambda =2k\) in the Tanner graph corresponding to the paritycheck matrix and we represent such a block cycle through a matrix \(\textbf{P}^{\lambda }\), such that
Definition 6
The blockcycle distribution (or spectrum) of \(\textbf{H}_{[0,{\mathcal {L}}]}\) is denoted as \(\textbf{D}^{{\mathcal {L}},\Lambda }\) and is a vector such that its ith entry \(D_i^{{\mathcal {L}},\Lambda }\) represents the multiplicity of block cycles with length \(2i+4\le \Lambda\) in \({\mathcal {G}}(\textbf{H}_{[0,{\mathcal {L}}]})\).
The propositions below easily follow from [31, Theorem 1] and [42, Theorem 1].
Proposition 1
The number of block cycles of length \(\lambda\) spanning exactly i sections, \(i \in \{2,3,\ldots , \lfloor \frac{\lambda }{4}\rfloor m_s+1\}\) is
where \(K_1^\lambda = D^{1,\lambda }_{\frac{\lambda 4}{2}}\).
Proposition 2
The average number of block cycles with length \(\lambda\) per node, considering a terminated version of \(\textbf{H}_{[0,\infty ]}\), \(\textbf{H}_{[0,{\mathcal {L}}]}\), is
Lemma 3
In the case of unterminated paritycheck matrix \(\textbf{H}_{[0,\infty ]}\), we have that the average number of block cycles with length \(\lambda\) per node is
Proof
Equation (9) follows from the following chain of equations
\(\square\)
A similar reasoning can be used to compute the average number of (a, b) ASs, \(E_{(a,b)}\), which is indeed
where \(\kappa _i^{(a,b)}\) is the number of considered ASs spanning exactly i column blocks of the convolutional paritycheck matrix, obtained similarly to (8), and \(L_{(a,b,m_s)}\) is introduced next. The superscript of the sum in (9) represents the maximum span of the (a, b) ASs under consideration [27, 28] that we call \(L_{(a,b,m_s)}\). The latter does not only depend on a and b and \(m_s\), but also on the topology of the considered ASs. Let the shortest path that connects any two variable nodes of an (a, b) AS (or generic trapping set) include at most \(\Sigma\) variable nodes (including the nodes at the start and end of the path). Then, it is possible to compute \(L_{(a,b,m_s)}=(\Sigma 1)m_s+1\), as shown in [31, Lemma 1]. \(\Sigma\) can be computed by means of Dijkstra’s algorithm [45].
From (9) and (10) we notice that the average number of objects per node does not depend on \({\mathcal {L}}\), but only on the number of objects spanning exactly a certain number of column blocks. Based on the above premises, we have the following results:
Lemma 4
One, and only one, block cycle (except for trivial replicas) satisfying (1) exists in \(\textbf{P}_{[0,\infty ]}\) only if a block cycle in \(\textbf{P}\) exists, satisfying the same equation.
Proof
Let us consider a block cycle with length \(\lambda =2k\) in \(\textbf{P}_{[0,\infty ]}\), described by the following equation of type (1)
where \(z_0, z_1, \ldots , z_{k1} \in \{0,1,\ldots , m_s\}\) are not necessarily different integers. By the definition of edge spreading, given by (3), \(P^{(m_0,n_0)}_{z_0}=p_{m_0,n_0}\), \(P^{(m_0,n_1)}_{z_1}=p_{m_0,n_1}\), \(\cdots\), \(P^{(m_{k1},n_{k1})}_{z_{k1}}=p_{m_{k1},n_{k1}}\) and \(P^{(m_{k1},n_0)}_{z_0}=p_{m_{k1},n_0}\). Therefore, there also exists a block cycle with length \(\lambda =2k\) in \(\textbf{P}\) described by
Therefore each block cycle in \(\textbf{P}_{[0,\infty ]}\) corresponds to a block cycle in \(\textbf{P}\). Moreover, if \(P^{m_{i},n_{i}}_{z_j}\ne \infty\) for \(j\in \{0,1,\ldots ,m_s\}\), then \(P^{m_{i},n_{i}}_{z_{j'}}= \infty\) for all \(j'\ne j\). This means that there cannot be more than one cycle in \(\textbf{P}_{[0,\infty ]}\) corresponding to the same cycle in \(\textbf{P}\), except for shifted replicas. In fact, given the timeinvariant structure of \(\textbf{P}_{[0,\infty ]}\), all the block cycles described by
where \(s>0\), are simple replicas of the block cycle described by (11), since \(P^{(m_i+sm,n_i+sn)}=P^{(m_i,n_i)}\), \(\forall i,s\).
\(\square\)
In other words, Lemma 4 states that any block cycle in the convolutional code can be unambiguously associated to a block cycle in the block code. However, the converse is not necessarily true, as proved in the following lemma:
Lemma 5
Consider a block cycle with length \(\lambda\), described by \(\textbf{P}^{\lambda }\), existing in the Tanner graph \({\mathcal {G}}(\textbf{H})\) corresponding to the paritycheck matrix of the block QCLDPC code described by \(\textbf{P}\). Then, after the edgespreading procedure based on \(\textbf{B}\) is applied, such a block cycle also exists in \({\mathcal {G}}(\textbf{H}_{[0,\infty ]})\) if and only if \(\textbf{B}^{\lambda }\) satisfies (1) over \({\mathbb {Z}}\), where
Proof
Let us consider the matrix \(\textbf{R}\), derived from \(\textbf{P}\), with entries
Suppose that a simple cycle \({\mathcal {C}}\) with length \(\lambda\) exists in \({\mathcal {G}}(\textbf{R})\). The spreading operation defined by \(\textbf{B}\) yields a matrix \(\textbf{R}_{[0,\infty ]}\) such that \({\mathcal {G}}(\textbf{R}_{[0,\infty ]})\) will still contain \({\mathcal {C}}\) if and only if the entries of \(\textbf{B}\) that are in the same positions as the 1’s involved in the cycle satisfy (1) over \({\mathbb {Z}}\). It is clear that any block cycle in \({\mathcal {G}}(\textbf{H}_{[0,\infty ]})\) corresponds to a simple cycle in \({\mathcal {G}}(\textbf{R}_{[0,\infty ]})\) (although the converse, in general, is not true). Since we assumed that \(\textbf{P}^{\lambda }\) describes a block cycle with length \(\lambda\), \({\mathcal {G}}(\textbf{H}_{[0,\infty ]})\) will also contain this block cycle if and only if the \(\lambda\) entries of \(\textbf{B}\) that are in the same positions as the \(\lambda\) entries of \(\textbf{P}^{\lambda }\) different from \(\infty\) satisfy (1) over \({\mathbb {Z}}\). \(\square\)
Let us suppose that the code defined by an exponent matrix \(\textbf{P}\) contains \(\nu\) block cycles \(\textbf{P}^{\lambda _{0},0},\ldots ,\textbf{P}^{\lambda _{\nu 1},\nu 1}\). Given \(\textbf{B}\), we can extract all the matrices \(\textbf{B}^{\lambda _i,i}\), \(i \in \{0,\ldots ,\nu 1\}\), that correspond to the block cycles in the QCLDPC code and check if (1) is satisfied. If so, then the block cycle also exists in the QCSC code; otherwise, the block cycle does not exist in the QCSC code. In other words, given an exponent matrix and a spreading matrix, checking as many equations as the number of block cycles in the exponent matrix allows determining the number of block cycles in the convolutional exponent matrix. We also remark that a single block cycle in an exponent matrix corresponds to N cycles in the binary paritycheck matrix.
Example 2
Consider the same code and the same spreading matrix as in Example 1 (see (5) and (6), respectively). \({\mathcal {G}}(\textbf{H})\) contains twenty block cycles with length \(\lambda =6\). For the sake of brevity, we only consider the following three, along with the corresponding entries of the spreading matrix
Notice that any \(\textbf{P}^{\lambda _i,i}\) complies with (1), as it represents a block cycle in the array LDPC block code. Moreover, (1) is satisfied for \(\textbf{B}^{6,2}\) but not for \(\textbf{B}^{6,0}\) and \(\textbf{B}^{6,1}\). In other words, \({\mathcal {G}}(\textbf{H}_{[0,\infty ]})\) contains the block cycles of length 6 corresponding to \(\textbf{P}^{6,2}\), but not those associated to \(\textbf{P}^{6,0}\) and \(\textbf{P}^{6,1}\). The same procedure can be applied to test whether the remaining 17 block cycles are also contained in \({\mathcal {G}}(\textbf{H}_{[0,\infty ]})\) or not. \(\square\)
The above reasoning permits us to derive an efficient procedure to count the average number of cycles per node in the paritycheck matrix of the QCSC code that is obtained by edge spreading an exponent matrix \(\textbf{P}\) with the edgespreading matrix \(\textbf{B}\). Such a procedure is described in Algorithm 1 and provides a significant boost with respect to the counting algorithm used in [36].
Let us suppose that cycles of length \(\lambda\) are the most harmful objects; then, Algorithm 1 returns \(E_{\lambda }\). In Algorithm 1, the function \(\mathrm {edge\_spread}(\textbf{P},\textbf{B},N)\) performs the edgespreading procedure as described in Sect. 2.2; the function \(\mathrm {list\_cycles}(\textbf{H},\lambda )\) lists cycles of length \(\lambda\) of block codes. Clearly, \(\textbf{B}^{\lambda _j,j}\) can be associated to \(\textbf{P}^{\lambda _j,j}\) as described in Lemma 5. Moreover, we have denoted the ith entry of \({\mathcal {H}}\) as \({\mathcal {H}}(i)\).
Notice that Lemmas 4 and 5 cannot be straightforwardly extended to general ASs. Let us suppose that an (a, b) AS exists in the paritycheck matrix of the initial block code. Let us suppose that none of the cycles contained in the AS are eliminated during the edgespreading procedure. This is not sufficient to ensure that the (a, b) AS exists in the convolutional version of the matrix, since the edgespreading procedure may transform it into an \((a,b')\) AS, with \(b\ne b'\). So, when the most harmful objects are not cycles, but general (a, b) ASs, we resort to the trapping sets search algorithm proposed in [14] to the convolutional case, considering that the search can be limited to a finite number of column blocks of the paritycheck matrix, \(L_{(a,b,m_s)}\). Different sets of harmful objects can also be considered. The number of column blocks to be considered is then the largest span for the considered set of harmful objects. Once the considered ASs are enumerated with the algorithm in [14], their average number per node can be obtained using (10).
So, we have devised two different procedures: The first one should be used when the targets of the proposed algorithm are simple cycles; the second one should be used when the target harmful objects are general ASs.
3.2 Design of good QCSC Codes
In this section we describe a general algorithm, named MInimization of HArmful Objects (MIHAO), which can be applied to an arbitrary harmful object (or set of objects) of interest to find a good QCSC code. Given the exponent matrix of a QCLDPC block code, the most harmful objects causing an error rate performance degradation in the associated QCSC code have to be determined. Such a preliminary analysis depends on the considered decoding algorithm, channel and code, whereas our algorithm is general and works for any group of objects, regardless of their harmfulness, without requiring the knowledge of the decoding algorithm and the channel. We first describe the proposed optimization algorithm. Then, its application is described in Sect. 4 through some examples including the evaluation of the target harmful objects.
The pseudocode describing the proposed recursive procedure is reported in Algorithm 2. Let us denote the set of target harmful objects as \({\mathcal {H}}=\{{\mathcal {H}}_0,\ldots , {\mathcal {H}}_{\nu 1}\}\). The MIHAO algorithm exploits a treebased search: The root node of the tree is the allzero spreading matrix, which characterizes a QCLDPC block code; the lth tier contains all the spreading matrices with l nonzero entries which reduce the multiplicity of harmful objects with respect to their parent node. If a parent node has no children nodes with better properties than its own, it is discarded, and the algorithm backtracks. Therefore, bad candidates and their children are discarded by the algorithm during the search. If no early stopping criterion is included, after all the survivor candidates are tested, the node corresponding to the spreading matrix yielding the smallest number of harmful objects is the output of the algorithm. On the other hand, some early stopping criteria can be, for example, related to the maximum number of times the algorithm backtracks or the maximum number of tiers it spans.
In Algorithm 2, the function \(\mathrm {count\_avg\_HO}(\textbf{B},{\mathcal {H}})\) determines the average number of harmful objects per node of the QCSC code obtained by spreading \(\textbf{P}\) with \(\textbf{B}\). This is accomplished by running lines 4 to 12 of Algorithm 1 if the harmful objects are cycles, and by running the search algorithm in [14] otherwise. Then, the candidate spreading matrices are those maximizing the multiplicity of removed harmful objects. In fact, the metric we consider to determine whether a candidate is good or bad is the average number of harmful objects per node, as defined above. Note that the algorithm does not guarantee to find the absolute optimal solution, but, as will be shown in Sect. 4 with the help of many examples, it provides better solutions than the best ones available in the literature.
4 Results and discussion
We assess the benefit in terms of structural properties of the codes designed through the proposed approach considering array codes [38] and Tanner codes [22] as a benchmark. Then, we confirm the expected error rate performance improvement via Monte Carlo simulations.
4.1 Optimization results
It is known that the performance of (3, n)regular array codes is adversely affected by (3, 3) ASs and (4, 2) FASs [12]. It can be shown that (3, 3) ASs and (4, 2) FASs derive from a cycle with length 6 and a cluster of two cycles with length 6, respectively [27]. The results in [28, 29] show that these objects are extremely detrimental also for their QCSC versions, when used in coded transmissions over the AWGN channel.
Therefore, we have applied Algorithm 2 to minimize their multiplicity in AB QCSC codes when \(m_s=1\) and \(m_s=2\). Notice that the proposed algorithm, differently from those proposed in [28, 29], has also been used to target harmful objects which are not cycles. The results are shown in Tables 1 and 2, respectively. For \(m=3\), any cycle of length 6 is a (3, 3) AS and, thus, we can feed Algorithm 2 with all the block cycles of length 6 in the AB code. Instead, the search of (4, 2) AS is slightly more complex, as, in this case, Algorithm 2 cannot be fed with simple cycles, but its inputs are combinations of cycles. For (4, 2) FASs of QCSC codes with \(m=3\), we have that their maximum span is \(L_{(4,2,m_s)}=2m_s+1\). Notice that the (3, 5)regular array code is the one considered in Examples 1 and 2. We remark that it is the only (3, n)regular AB QCSC code allowing for the removal of all the (3, 3) ASs and (4, 2) FASs when \(m_s=1\).
All the spreading vectors returned by Algorithm 2 are reported in “Appendix 1.” Note that, even though the algorithm does not guarantee to find the absolute optimal solution, it provides better solutions than the best ones available in the literature in most cases.
We have also considered the (3, 5)regular Tanner QCLDPC code with \(L=155\) and \(g = 8\), described by
The dominant trapping sets of this code are known to be (8, 2) ASs [46]. It is shown in [17] that there are 5 different types of (8, 2) ASs in (3, n)regular codes. All of them contain at least one cycle of length 8. In particular, the (8, 2) ASs identified in [46] as the most dangerous ones for the (3, 5)regular Tanner code consist of clusters of 15 cycles: 3 of length 8, 4 of length 10, 2 of length 12, 4 of length 14 and 2 of length 16. The simplest approach to eliminate all the (8, 2) ASs consists in removing the shortest cycles they contain, i.e., all the cycles of length 8. In this case, feeding Algorithm 2 with \(\textbf{P}_{\frac{2}{5}}\), \(N=31\), all the cycles of length 8 in \(\textbf{P}_{\frac{2}{5}}\) and \(m_s=1\), we obtain
This spreading matrix allows the elimination of all cycles of length 8 and, thus, also \(E_{(8,2)}=0\).
As a further example, we consider the (3, 7)regular Tanner code with blocklength \(L=301\), \(g=8\) and
Even though we might have simply assumed that the dominant trapping sets of this code are the same (8, 2) ASs as for the (3, 5)regular Tanner code, we have analyzed the error patterns returned by the Monte Carlo simulations aimed at estimating the bit error rate (BER) of this block code, over the AWGN channel, using the loglikelihood ratio sumproduct algorithm (LLRSPA) decoder. The results are shown in “Appendix 2” and confirm that the most dangerous objects are indeed (8, 2) ASs, but of a different type than those considered in [46]. In fact, the (8, 2) ASs which are harmful for the (3, 7)regular Tanner code are formed by clusters of 14 cycles: 3 of length 8, 4 of length 10, 2 of length 12, 4 of length 14 and 1 of length 16. Again, we note that if we are able to remove all the cycles of length 8 we will also remove all the (8, 2) ASs, whereas the converse is not true, in general. Clearly, removing all the cycles with length 8 is preferable, as they may combine together and form other harmful objects; unfortunately, however, this is not always possible.
For example, the approach of eliminating all the cycles with length 8 for the (3, 7)regular Tanner code with MIHAO using \(m_s=1\), is not successful. In fact, by performing an exhaustive analysis of the spreading matrices, we have verified that no solution free of cycles with length 8 exists for these parameters. Therefore, since we aim to remove all the (8, 2) ASs, we need to target the cycles composing them, including those with length larger than 8. Notice that this is not equivalent to targeting all the cycles with length 8, but rather a (small) subset of them has to be considered. In order to reach this goal, we need to list the (8, 2) ASs and, for each of them, find the cycles contained in the corresponding subgraph. Consequently, we feed Algorithm 2 with \(\textbf{P}_{\frac{4}{7}}\), \(N=43\), \(m_s=1\), all the (8, 2)ASs in the paritycheck matrix associated to \(\textbf{P}_{\frac{4}{7}}\) and obtain
which indeed eliminates all the (8, 2) ASs.
If, instead, we consider \(m_s=2\), we do not need to target the absorbing sets directly, since, in this case, the MIHAO algorithm can easily find a spreading matrix which removes all the cycles with length 8. In fact, if we feed Algorithm 2 with \(\textbf{P}_{\frac{4}{7}}\), \(N=43\) and all the block cycles of length 8 in \(\textbf{P}_{\frac{4}{7}}\) we obtain
which yields no cycles of length 8 and, thus, no (8, 2) ASs.
We have also considered the code proposed in [31, Example 6], with exponent matrix
and considered two scenarios:

\(L=98\), \(g=6\) and spreading vector as in [31], i.e.,
$$\begin{aligned} \textbf{b}_{4}=\left[ \begin{matrix} 5&\quad 9&\quad 6&\quad 9&\quad 6&\quad 10&\quad 10 \end{matrix} \right] ; \end{aligned}$$(16) 
\(L=49\), \(g=6\) and spreading vector obtained with MIHAO algorithm, with the aim of minimizing the same objects as in [31] (6 cycles), i.e.,
$$\begin{aligned} \textbf{b}_{5}=\left[ \begin{matrix} 55&\quad 241&\quad 36&\quad 73&\quad 2&\quad 78&\quad 84 \end{matrix} \right] . \end{aligned}$$(17)
The resulting QCSC codes have \(m_s=1\) and \(m_s=3\), respectively, but the same constraint length \(\nu _s=196\), and are therefore comparable. They will be addressed to as \({\mathcal {C}}_O\) and \({\mathcal {C}}_M\), respectively.
4.2 Monte Carlo simulations
In this section we assess the error rate performance of the newly designed Tanner codes in terms of BER via Monte Carlo simulations of binary phase shift keying (BPSK)modulated transmission over the AWGN channel. All the considered codes are terminated and have block length 120, 000. We have used a sliding window (SW) decoder with window size (in column blocks) \(W=5(m_s+1)\) performing 100 iterations per window position. The SW decoder performs belief propagation over a window including W blocks of L bits each, after which this window slides forward by L bits before starting over again. For each decoding window position, the SW decoder returns the first L decoded bits, usually called target bits, as its output. As in [26,27,28,29,30,31,32, 36], we assume that the most harmful objects of a QCLDPC code are also harmful for its QCSC version, even when decoded with a large sliding window decoder, such as that used in this paper. This assumption is corroborated by the fact that QCSC codes have a reduced number of the same harmful object(s) with respect to their block counterparts and also a significantly better performance under sliding window decoding with respect to their block version (see, for example, Fig. 2).
We have first considered the (3, 5)regular Tanner code and simulated the QCSC codes obtained by edgespreading (13) with \(\textbf{b}_1\), reported in Sect. 4.1, and with a random spreading matrix. The results are shown in Fig. 1. The QCSC code corresponding to \(\textbf{b}_1\) has \(g=10\), whereas that obtained by using a random spreading matrix has \(g=8\) (\(E_8=0.12\)), some residual (8, 2) trapping sets (\(E_{(8,2)}=0.37\)) and also a larger multiplicity of cycles with length 10 and 12. While, as expected, the code designed through MIHAO shows improvement over the random code in the region from 0.75 dB to 2 dB, the simulation curves converge at higher signaltonoise ratios (SNRs) as a result of the remaining dominant objects. So, Fig. 1 is meaningful, since it shows that the QCSC code suffers the presence of harmful objects which are not immediately deducible from the analysis of the error patterns of the belief propagation decoder for the initial block code, since they are not dominant in that case. In order to improve the performance at a higher SNR, MIHAO should be employed with different target harmful objects, specifically tailored to the SW decoder. An indepth analysis of this behavior is left for future works, in which the aspects introduced in [47, Section V] should also be accounted for. The error propagation phenomenon suffered by sliding window decoders, as discussed in [48, 49], might also be considered.
We have also simulated the error rate performance of the QCSC codes obtained by edge spreading the (3, 7)regular Tanner block code with \(\textbf{b}_2\), which yields a code with \(m_s=1\), and \(\textbf{b}_3\), which yields a code with \(m_s=2\), as detailed in Sect. 4.1. We have compared the performance of these two QCSC codes with that of the QCSC codes obtained by edge spreading the (3, 7)regular Tanner block code with random spreading matrices, and the results are shown in Fig. 2. Also in this case, we notice that the increase of the memory yields a gain in the error rate performance and, above all, that the optimization performed by Algorithm 2 improves the error rate performance of the considered codes, especially in the error floor region.
As a final example, we have simulated the error rate performance of the QCSC codes obtained from (15) in the two scenarios described in Sect. 4.1. The results are shown in Fig. 3. Also in this last case, the code obtained by edge spreading \(P_{\frac{3}{7}}\) with the spreading matrix obtained through the MIHAO algorithm outperforms that obtained with the spreading matrix proposed in [31], from an error rate performance point of view.
Alternative input QCLDPC codes of girth 8, with potential performance improvements over Tanner codes, especially in the error floor region, are those proposed in [15, 50,51,52], among many others. We leave the performance analysis of the corresponding optimized QCSC codes as a spark for future research.
5 Complexity of the algorithm
In this section, we briefly discuss how the complexity of the proposed procedure grows asymptotically with n and \(m_s\). We also provide complexity estimations in the finitelength regime by considering some examples.
5.1 Asymptotic complexity
Looking at the whole optimization process, we can separate two phases and the corresponding complexity: i) finding the harmful objects in a matrix with finite size (which is either a paritycheck matrix or a portion of it) and ii) executing the MIHAO algorithm. Clearly, the first contribution depends on the nature and size of the searched harmful objects. By using the search method proposed in [53], the complexity of the search of trapping sets in a block code with blocklength L, excluding the initial cycle search, increases as O(L). For completeness, we must also consider that the complexity of the search of cycles with length \(\lambda\), for QCLDPC codes with column weight equal to m, increases as \(O(m^{\lambda +1})\). Obviously, when this is performed on the block code, \(m_s\) does not play any role.
The complexity of the MIHAO algorithm, when targeting cycles, can be estimated as follows. Assuming that picking a value from or changing an entry in a matrix has negligible computational complexity, we can estimate the complexity of the MIHAO algorithm as the complexity of evaluating (1), multiplied by the number of tested spreading matrices (denoted as \(N_{\textbf{B}}\)) and multiplied by the number of cycles per test (that is, \({\mathcal {H}}\)). The complexity of computing (1) is the same as the cost of the sum of \(\lambda\) elements, where \(\lambda\) is the length of the considered cycle. Conservatively assuming that all the cycles have the same length, i.e., the length of the longest cycle in \({\mathcal {H}}\), denoted as \(\lambda _{\max }\), the complexity of evaluating (1) increases as \(O((\lambda _{\max }1)\log _2(m_s))\). Combining these results, we finally obtain that the complexity of the whole procedure asymptotically increases as
Note that in (18), \({\mathcal {H}}\) does not depend on \(m_s\), whereas \(N_{\textbf{B}}\) depends on \(m_s\), m, and on the specific code considered.
When, instead, the target harmful objects are general (that is, not cycles) (a, b) ASs, we refer the interested reader to the complexity analysis in [14, Section IVE], where the blocklength should be substituted with \(L_{(a,b,m_s)}L\), being L the blocklength of the starting QCLDPC code, and \(L_{(a,b,m_s)}\) the maximum span (in terms of column blocks) of any harmful object of interest.
5.2 Complexity examples for the finitelength scenario
In order to assess the efficiency of the MIHAO algorithm in a finitelength scenario, we have evaluated the average number of spreading matrices the novel algorithm tests before finding a solution, for the codes with the smallest spreading matrices (so that comparison with exhaustive search is feasible).
Let us consider the (3, 5)regular array code. Running the MIHAO algorithm with (3, 3) ASs as input, required testing an average of 21 spreading matrices out of the total \(8^5=32,768\) possible ones (\(0.06\%\) of the search space) before finding a solution which eliminates such ASs in the QCSC code with \(m_s=1\), over 1000 trials. A smart exhaustive search on the reduced search space described in Sect. 2.3 found 80 different solutions, out of the 16,807 possible spreading matrices and, therefore, the expected value of tested spreading matrices before finding a valid solution is 211 (\(1.26\%\) of the search space). If a (nonsmart) exhaustive search is performed, the search space has \(2^{15}\) elements, out of which 100 elements have been found to be solutions of the problem of eliminating all (3, 3) ASs. Therefore, the expected percentage of the solution space that has to be spanned to find a solution is \(1\%\) (328 spreading matrices). By applying the minimum overlapping (MO) method proposed in [29], the search space contains 1000 spreading matrices. However, this reduced search space does not contain any of the 100 solutions found by means of the exhaustive search.
Let us also consider the (3, 7)regular array code. Running the MIHAO algorithm 1000 times, with (3, 3) ASs as input, required testing an average of 1, 350 spreading out of the total \(27^7\) possible choices before finding a spreading matrix which eliminated all such sets in the QCSC code with \(m_s=2\) (\(1.3 \cdot 10^{5}\%\) of the search space). Spanning the entire search spaces of the conventional exhaustive search and the smart exhaustive search is too complex, since they would require testing \(3^{21}\) and \(19^7\) spreading matrices, respectively, and for this reason the total number of solutions in the respective search spaces is not known.^{Footnote 1} In order to set up a fair comparison with MIHAO, we have randomly generated spreading matrices using the above methods until a solution was found and repeated the experiment 1000 times, counting the average number of tested matrices before finding it. Namely, the exhaustive search requires testing an average of 4227 matrices before finding a solution and the smart exhaustive search 1709 matrices, on average. The MO method considers a reduced search space containing 9261000 spreading matrices. We have verified that it contains 3928 solutions and, therefore, the expected number of spreading matrices to be tested before finding a solution is 2358.
(3, 5) Tannerbased QCSC codes with \(m_s=1\) and no cycles of length 8 have been found by the MIHAO algorithm by testing an average of 14 spreading matrices out of the total 32768 possible ones (\(0.04\%\) of the search space), over 1000 attempts. The smart exhaustive search found 540 solutions out of 16807; the expected value of tested matrices before finding a solution is thus 32. The exhaustive search found 570 solutions out of the \(2^{15}\) spreading matrices, therefore needing to test an expected value of 58 matrices before finding a solution. In this case, the MO method considers a reduced space of 1000 spreading matrices containing 45 solutions; therefore, the expected value of spreading matrices to be tested before finding a solution is 23.
Finally, (3, 7) Tannerbased QCSC codes with \(m_s=2\) and no cycles of length 8 were found by the MIHAO algorithm by testing an average of 5292 spreading matrices out of the total \(27^7\) possible choices. The smart exhaustive search, the exhaustive search and the MO method would again require testing \(19^7\), \(3^{21}\) and 9261000 spreading matrices when \(m_s =2\), respectively; these tasks, also due to the increase in the computational complexity of the single test with respect to the previous cases (finding cycles with length 8 is more costly than finding (3, 3) ASs), require a too long processing time and, for this reason, were not performed. Still, just as for the (3, 7)regular array code, we have randomly searched for solutions in the search spaces of these approaches, stopping when a solution was found. The average number of tested matrices before finding a solution, over 1000 attempts, was 12493, 18396 and 5941, respectively.
Table 3 summarizes the above results. Between round brackets we report the number of spreading matrices in the considered search space and the number of solutions within the considered search space, separated by the symbol /, when it is possible to find them; if the search space is too large to be spanned entirely, we have reported a lower bound on the number of solutions when the algorithms search (3, 3) ASs, and the symbol—if cycles with length 8 are the target. Obviously, for MIHAO we only report the average number of tested matrices before finding a solution, since the novel algorithm stops as soon as it finds a solution. We notice (see bold values) how MIHAO is, in all the considered cases, the algorithm requiring the smallest average number of tested matrices before finding a solution.
The speedup of the novel MIHAO algorithm with respect to its previous version [36], and to the random search (when feasible), can be found in “Appendix 1,” referred to array codes. The speedup is quantified in relative terms and is therefore independent of the specific computer used to obtain the results.
6 Conclusions
We have proposed an efficient algorithm that enables the construction of good QCSC codes based on QCLDPC block codes from the perspective of harmful objects. The algorithm is flexible and allows the analysis of codes with different structure and values of memory and rate. The algorithm assumes many classes of harmful objects as the target of a searchandremove process aimed to eventually optimize codes in terms of error rate performance. Through several examples, we have verified that our algorithm can outperform those available in previous literature, in terms of reduced number of harmful objects, and simulation of the newly designed codes has given evidence of the performance gain achievable. Finally, we have shown with many examples that MIHAO presents advantages in terms of computational complexity over competitive solutions.
Availability of data and materials
Not applicable.
Notes
We have empirically found a lower bound for the smart exhaustive search: Its search space contains more than 673 solutions.
Abbreviations
 AB:

Arraybased
 AS:

Absorbing sets
 AWGN:

Additive white Gaussian noise
 BER:

Bit error rate
 BPSK:

Binary phase shift keying
 CPM:

Circulant permutation matrix
 LDPC:

Lowdensity paritycheck
 LLRSPA:

Loglikelihood ratio sumproduct algorithm
 MIHAO:

MInimization of harmful objects
 QCLDPC:

Quasicyclic lowdensity paritycheck
 QCSC codes:

Quasicyclic spatially coupled LDPC codes from quasicyclic lowdensity paritycheck block codes
 QCSCLDPC:

Quasicyclic spatially coupled lowdensity paritycheck
 SCLDPCC:

Spatially coupled LDPC code
 SW:

Sliding window
References
A. Jiménez Felström, K.S. Zigangirov, Timevarying periodic convolutional codes with lowdensity paritycheck matrix. IEEE Trans. Inf. Theory 45(6), 2181–2191 (1999)
R.G. Gallager, Lowdensity paritycheck codes. IRE Trans. Inform. Theory IT8, 21–28 (1962)
Z. Yang, Y. Fang, G. Zhang, F.C.M. Lau, S. Mumtaz, D.B. da Costa, Analysis and optimization of tailbiting spatially coupled protograph LDPC codes for BICMID systems. IEEE Trans. Veh. Technol. 69(1), 390–404 (2020). https://doi.org/10.1109/TVT.2019.2949600
Q. Wang, S. Cai, W. Lin, S. Zhao, L. Chen, X. Ma, Spatially coupled LDPC codes via partial superposition and their application to HARQ. IEEE Trans. Veh. Technol. 70(4), 3493–3504 (2021). https://doi.org/10.1109/TVT.2021.3065052
T.J. Richardson, R.L. Urbanke, The capacity of lowdensity paritycheck codes under messagepassing decoding. IEEE Trans. Inf. Theory 47(2), 599–618 (2001)
M. Lentmaier, A. Sridharan, D.J. Costello, K.S. Zigangirov, Iterative decoding threshold analysis for LDPC convolutional codes. IEEE Trans. Inf. Theory 56(10), 5274–5289 (2010)
S. Kudekar, T.J. Richardson, R.L. Urbanke, Threshold saturation via spatial coupling: why convolutional LDPC ensembles perform so well over the BEC. IEEE Trans. Inf. Theory 57(2), 803–834 (2011)
S. Kudekar, T.J. Richardson, R.L. Urbanke, Spatially coupled ensembles universally achieve capacity under belief propagation. IEEE Trans. Inf. Theory 59(12), 7761–7813 (2013)
R. Tanner, A recursive approach to low complexity codes. IEEE Trans. Inf. Theory 27(5), 533–547 (1981)
C. Di, D. Proietti, I.E. Telatar, T.J. Richardson, R.L. Urbanke, Finitelength analysis of lowdensity paritycheck codes on the binary erasure channel. IEEE Trans. Inf. Theory 48(6), 1570–1579 (2002)
T. Richardson, Error floors of LDPC codes, in Proceedings of 41st Annual Allerton Conference, Monticello, IL (2003)
L. Dolecek, Z. Zhang, V. Anantharam, M.J. Wainwright, B. Nikolic, Analysis of absorbing sets and fully absorbing sets of arraybased LDPC codes. IEEE Trans. Inf. Theory 56(1), 181–201 (2010)
Y. Hashemi, A. Banihashemi, On characterization of elementary trapping sets of variableregular LDPC codes. IEEE Trans. Inf. Theory 60(9), 5188–5203 (2014)
Y. Hashemi, A. Banihashemi, New characterization and efficient exhaustive search algorithm for leafless elementary trapping sets of variableregular LDPC codes. IEEE Trans. Inf. Theory 62(12), 6713–6736 (2016)
X. Tao, Y. Li, Y. Liu, Z. Hu, On the construction of LDPC codes free of small trapping sets by controlling cycles. IEEE Commun. Lett. 22(1), 9–12 (2018). https://doi.org/10.1109/LCOMM.2017.2679707
R. Asvadi, A.H. Banihashemi, M. AhmadianAttari, Lowering the error floor of LDPC codes using cyclic liftings. IEEE Trans. Inf. Theory 57(4), 2213–2224 (2011)
D.V. Nguyen, S.K. Chilappagari, M.W. Marcellin, B. Vasic, On the construction of structured LDPC codes free of small trapping sets. IEEE Trans. Inf. Theory 58(4), 2280–2302 (2012)
Y. Han, W.E. Ryan, Lowfloor decoders for LDPC codes. IEEE Trans. Commun. 57(6), 1663–1673 (2009). https://doi.org/10.1109/TCOMM.2009.06.070325
J. Kang, Q. Huang, S. Lin, K. AbdelGhaffar, An iterative decoding algorithm with backtracking to lower the errorfloors of LDPC codes. IEEE Trans. Commun. 59(1), 64–73 (2011). https://doi.org/10.1109/TCOMM.2010.101210.090628
S. Kang, J. Moon, J. Ha, J. Shin, Breaking the trapping sets in LDPC codes: check node removal and collaborative decoding. IEEE Trans. Commun. 64(1), 15–26 (2016)
D.G.M. Mitchell, M. Lentmaier, D.J. Costello Jr., Spatially coupled LDPC codes constructed from protographs. IEEE Trans. Inf. Theory 61(9), 4866–4889 (2015)
R.M. Tanner, D. Sridhara, A. Sridharan, T.E. Fuja, D.J. Costello, LDPC block and convolutional codes based on circulant matrices. IEEE Trans. Inf. Theory 50(12), 2966–2984 (2004)
A.K. Pradhan, A. Thangaraj, A. Subramanian, Construction of nearcapacity protograph LDPC code sequences with blockerror thresholds. IEEE Trans. Commun. 64(1), 27–37 (2016). https://doi.org/10.1109/TCOMM.2015.2500234
Y. Fang, S.C. Liew, T. Wang, Design of distributed protograph LDPC codes for multirelay codedcooperative networks. IEEE Trans. Wireless Commun. 16(11), 7235–7251 (2017). https://doi.org/10.1109/TWC.2017.2743699
Y. Fang, P. Chen, G. Cai, F.C.M. Lau, S.C. Liew, G. Han, Outagelimitapproaching channel coding for future wireless communications: Rootprotograph lowdensity paritycheck codes. IEEE Veh. Technol. Mag. 14(2), 85–93 (2019). https://doi.org/10.1109/MVT.2019.2903343
B. Amiri, A. Reisizadehmobarakeh, H. Esfahanizadeh, J. Kliewer, L. Dolecek, Optimized design of finitelength separable circulantbased spatiallycoupled codes: an absorbing setbased analysis. IEEE Trans. Commun. 64(3), 918–931 (2016)
D.G.M. Mitchell, L. Dolecek, D.J. Costello, Absorbing set characterization of arraybased spatially coupled LDPC codes, in Proceedings of IEEE ISIT 2014, Honolulu, HI, USA, pp. 886–890 (2014)
D.G.M. Mitchell, E. Rosnes, Edge spreading design of high rate arraybased SCLDPC codes, in Proceedings of IEEE ISIT 2017, Aachen, Germany, pp. 2940–2944 (2017)
H. Esfahanizadeh, A. Hareedy, L. Dolecek, A novel combinatorial framework to construct spatiallycoupled codes: minimum overlap partitioning, in Proceedings of IEEE ISIT 2017, Aachen, Germany, pp. 1693–1697 (2017)
A. Beemer, S. Habib, C.A. Kelley, J. Kliewer, A generalized algebraic approach to optimizing SCLDPC codes, in Proceedings of 55th Annual Allerton Conference, Monticello, IL, pp. 672–679 (2017)
H. Esfahanizadeh, A. Hareedy, L. Dolecek, Finitelength construction of high performance spatiallycoupled codes via optimized partitioning and lifting. IEEE Trans. Commun. 67(1), 3–16 (2019). https://doi.org/10.1109/TCOMM.2018.2867493
A. Hareedy, R. Wu, L. Dolecek, A channelaware combinatorial approach to design high performance spatiallycoupled codes. IEEE Trans. Inf. Theory 66(8), 4834–4852 (2020). https://doi.org/10.1109/TIT.2020.2979981
S. Mo, L. Chen, D.J. Costello, D.G.M. Mitchell, R. Smarandache, J. Qiu, Designing protographbased quasicyclic spatially coupled LDPC codes with large girth. IEEE Trans. Commun. 68(9), 5326–5337 (2020). https://doi.org/10.1109/TCOMM.2020.3001029
L. Schmalen, V. Aref, F. Jardel, Nonuniformly coupled LDPC codes: Better thresholds, smaller rateloss, and less complexity, in 2017 IEEE International Symposium on Information Theory (ISIT), pp. 376–380 (2017). https://doi.org/10.1109/ISIT.2017.8006553
S. Yang, A. Hareedy, R. Calderbank, L. Dolecek, Breaking the computational bottleneck: Probabilistic optimization of highmemory spatiallycoupled codes. IEEE Trans. Inf. Theory 69(2), 886–909 (2023). https://doi.org/10.1109/TIT.2022.3207321
M. Battaglioni, F. Chiaraluce, M. Baldi, D.G.M. Mitchell, Efficient search and elimination of harmful objects for the optimization of QCSCLDPC codes, in Proceedings of IEEE GLOBECOM 2019, Waikoloa, Hawaii, USA (2019)
M.R. Sadeghi, F. Amirzade, Edgecoloring technique to analyze elementary trapping sets of spatiallycoupled LDPC convolutional codes. IEEE Commun. Lett. 24(4), 711–715 (2020). https://doi.org/10.1109/LCOMM.2019.2962671
J.L. Fan, Array codes as lowdensity paritycheck codes, in Proceedings of 2nd Interenational Symposium Turbo Codes, Brest, France, pp. 543–546 (2000)
H. Zhou, N. Goertz, Unavoidable cycles in polynomialbased timeinvariant LDPC convolutional codes, in Proceedings of Wireless Conference on Sustainable Wireless Technology 2011, Vienna, Austria, pp. 1–6 (2011)
Y. Wang, S.C. Draper, J.S. Yedidia, Hierarchical and highgirth QC LDPC codes. IEEE Trans. Inf. Theory 59(7), 4553–4583 (2013). https://doi.org/10.1109/TIT.2013.2253512
M.P.C. Fossorier, Quasicyclic lowdensity paritycheck codes from circulant permutation matrices. IEEE Trans. Inf. Theory 50(8), 1788–1793 (2004)
M. Battaglioni, F. Chiaraluce, M. Baldi, M. Lentmaier, Girth analysis and design of periodically timevarying SCLDPC codes. IEEE Trans. Inf. Theory 67(4), 2217–2235 (2021). https://doi.org/10.1109/TIT.2021.3059414
G. Liva, M. Chiani, Protograph LDPC codes design based on EXIT analysis, in IEEE GLOBECOM 2007—IEEE Global Telecommunications Conference, pp. 3250–3254 (2007). https://doi.org/10.1109/GLOCOM.2007.616
M. Battaglioni, A. Tasdighi, G. Cancellieri, F. Chiaraluce, M. Baldi, Design and analysis of timeinvariant SCLDPC convolutional codes with small constraint length. IEEE Trans. Commun. 66(3), 918–931 (2018)
E.W. Dijkstra, A note on two problems in connexion with graphs. Numer. Math. 1(1), 269–271 (1959)
S. Zhang, C. Schlegel, Causes and dynamics of LDPC error floors on AWGN channels, in Proceedings of 49th Annual Allerton Conference, Monticello, IL, pp. 1025–1032 (2011)
A. Beemer, C.A. Kelley, Avoiding trapping sets in SCLDPC codes under windowed decoding, in Proceedings of ISITA 2016, Monterey, CA, pp. 206–210 (2016)
L. Schmalen, D. Suikat, V. Aref, D. Roesener, On the design of capacityapproaching unitmemory spatially coupled LDPC codes for optical communications, in ECOC 2016; 42nd European Conference on Optical Communication, pp. 1–3 (2016)
K. Klaiber, S. Cammerer, L. Schmalen, S.t. Brink, Avoiding burstlike error patterns in windowed decoding of spatially coupled LDPC codes, in 2018 IEEE 10th International Symposium on Turbo Codes & Iterative Information Processing (ISTC), pp. 1–5 (2018). https://doi.org/10.1109/ISTC.2018.8625312
G. Zhang, R. Sun, X. Wang, Several explicit constructions for (3, L) QCLDPC codes with girth at least eight. IEEE Commun. Lett. 17(9), 1822–1825 (2013). https://doi.org/10.1109/LCOMM.2013.070913.130966
M. Majdzade, M. Gholami, On the class of highrate QCLDPC codes with girth 8 from sequences satisfied in GCD condition. IEEE Commun. Lett. 24(7), 1391–1394 (2020). https://doi.org/10.1109/LCOMM.2020.2983019
G. Zhang, Y. Hu, Y. Fang, D. Ren, Relation between GCD constraint and fulllength rowmultiplier QCLDPC codes with girth eight. IEEE Commun. Lett. 25(9), 2820–2823 (2021). https://doi.org/10.1109/LCOMM.2021.3096386
Y. Hashemi, A.H. Banihashemi, Characterization and efficient search of nonelementary trapping sets of LDPC codes with applications to stopping sets. IEEE Trans. Inf. Theory 65(2), 1017–1033 (2019). https://doi.org/10.1109/TIT.2018.2865385
Acknowledgements
The work of Dr. Mitchell is supported by the National Science Foundation under Grant Nos. CCF2145917 and HRD1914635. Michele Pacenti acknowledges the support of National Science Foundation under Grants CIF1855879, CIF2106189, CCSS2027844, CCSS2052751 and CCF2100013, as well as the support of the Jet Propulsion Laboratory, California Institute of Technology, under a contract with the National Aeronautics and Space Administration and funded through JPL’s Strategic University Research Partnerships (SURP) program.
Author information
Authors and Affiliations
Contributions
All the authors participated in writing the article and revising the manuscript. MB and MP developed the software of the MIHAO algorithm. DM ran the Monte Carlo simulations. MB assessed the complexity comparisons.
Corresponding author
Ethics declarations
Competing interests
The authors declare that they have no competing interests.
Additional information
Publisher's Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Appendices
Appendix 1
In this appendix, we list all the spreading vectors returned by Algorithm 2 that achieve the results shown in Tables 1 and 2 and the speedup of the newly proposed algorithm with respect to a random search and to the previous version of the algorithm (the algorithms are implemented in MATLAB and are executed on a standard laptop computer with an Intel(R) Core(TM) i54210U CPU @ 1.70GHz and 4 GB RAM). In the speedup expression, we have denoted the running time of the random search, of the version of the algorithm in [36] and of the proposed version of the algorithm as \(t_{\textrm{ran}}\), \(t_{\mathrm {[1]}}\) and \(t_{\textrm{MIHAO}}\), respectively. These results are reported in Tables 4 and 5. A time limit of one week has been considered for the running time of the algorithms. When the random search (or the previous version of MIHAO) required more than a week to find the same solution as the newly proposed algorithm, the speedup cannot be computed and the corresponding entry of the table is a –. It is interesting to note that for most of the considered values of n, the spreading vector yielding the smallest multiplicity of (3, 3) ASs, denoted as \(\textbf{b}\rightarrow E_{(3,3)}\), is also the one yielding the smallest multiplicity of (4, 2) FASs, denoted as \(\textbf{b}\rightarrow E_{(4,2)}\).
Appendix 2
In this appendix we show the error patterns that cause the failures of a loglikelihood ratio sumproduct algorithm performing 100 iterations on the (3, 7)regular block Tanner QCLDPC code considered in Sects. 4.1 and 4.2, with \(L=301\) and \(g = 8\), described by the following exponent matrix
For the sake of brevity, we only give the error patterns for \(\frac{E_b}{N_0}=4.85\ \text {dB}\), which is the largest \(\frac{E_b}{N_0}\) for which we were able to collect a sufficiently large number of error patterns (more than 100) in a reasonable time. In this case, all the decoding failures were caused by the same initial pattern (inducing set), whose support (variable node indexes) is
We show its evolution throughout the 100 decoding iterations in Fig. 4. This figure shows that, even though the inducing set is not an (8, 2) AS, the decoder mostly gets stuck at bit positions
which indeed correspond to the most “solid” columns in Fig. 4 and are an (8, 2) AS. Thus, we consider these classes of harmful objects as the most dangerous ones for the (3, 7)regular Tanner code under the considered decoding algorithm and, therefore, as the input of Algorithm 2. In this case, in order to guarantee results reproducibility, it is important to specify that, for each entry \(p_{i,j}\) of \(\textbf{P}_{\frac{4}{7}}\), the corresponding circulant permutation matrix was obtained by cyclic shifts of the rows of the identity matrix toward left by \(p_{i,j}\) positions.
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
Battaglioni, M., Chiaraluce, F., Baldi, M. et al. Optimizing quasicyclic spatially coupled LDPC codes by eliminating harmful objects. J Wireless Com Network 2023, 67 (2023). https://doi.org/10.1186/s13638023022730
Received:
Accepted:
Published:
DOI: https://doi.org/10.1186/s13638023022730
Keywords
 Convolutional codes
 Cycles
 Harmful objects
 Iterative decoding
 LDPC codes
 Spatially coupled codes
 Trapping sets