{'fraction_non_alphanumeric': 0.0328812470663801, 'fraction_numerical': 0.01138862126040663, 'mean_word_length': 4.365853658536586, 'pattern_counts': {'":': 0, '<': 4, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Construction of Near-Optimum Burst Erasure Correcting Low-Density Parity-Check Codes

In this paper, a simple, general-purpose and effective tool for the design of low-density parity-check (LDPC) codes for iterative correction of bursts of erasures is presented. The design method consists in starting from the parity-check matrix of an LDPC code and developing an optimized parity-check matrix, with the same performance on the memory-less erasure channel, and suitable also for the iterative correction of single bursts of erasures. The parity-check matrix optimization is performed by an algorithm called pivot searching and swapping (PSS) algorithm, which executes permutations of carefully chosen columns of the parity-check matrix, after a local analysis of particular variable nodes called stopping set pivots. This algorithm can be in principle applied to any LDPC code. If the input parity-check matrix is designed for achieving good performance on the memory-less erasure channel, then the code obtained after the application of the PSS algorithm provides good joint correction of independent erasures and single erasure bursts. Numerical results are provided in order to show the effectiveness of the PSS algorithm when applied to different categories of LDPC codes.


I. INTRODUCTION
Recently, the problem of designing low-complexity codes for transmission on burst erasure channels, especially low-density parity-check (LDPC) codes [1], has gained a certain interest (e.g. [2]- [14]). This demand for burst erasure correcting codes can be explained by the fact that such codes are quite interesting for several applications, including magnetic storage, wireless communications on correlated fading channels, and even space communications. For instance, LDPC codes with good properties in terms of correction of single bursts of erasures have been shown in [2] and [3] to represent a promising solution, respectively, for the error control system in magnetic recording applications, and for communication on correlated Rayleigh fading channels. Furthermore, it is currently under investigation the possibility to implement LDPC-like codes at the upper layers of the communication stack, for correcting bursts of packet erasures in space and satellite communication links [4], [5], in order to heavily reduce the use of automatic repeat request (ARQ) protocols.
It has been shown in [15] that practically any (n, k) linear block code can be used to correct any single burst of n − k or less erasures, thus achieving the optimal correction capability of single bursts of erasures. More specifically, it has been proved that, under very mild assumptions, it is possible to obtain a (redundant) representation of the parity-check matrix for the code (called parity-check matrix in burst correction form) that permits to recover from any pattern of n−k or less contiguous erasures, by applying a decoding algorithm whose computational complexity is quadratic in the codeword length n. The same code can be then used in a communication system for erasure recovery both in scenarios with independent bit erasures and in scenarios where the erasures occur in bursts. The decoding is performed according to a two-step process: the received sequence is first processed by the burst correcting algorithm operating on the parity-check matrix in burst correction form, and then by the decoding algorithm for independent erasures correction, operating on a different parity-check matrix representation. This very general technique can be in principle applied also to LDPC codes. In this case, in the first step of the decoding process, the burst erasure correcting decoder is applied, with quadratic complexity, to the parity-check matrix in burst correction form; in the second step of the decoding process, the iterative decoding [16] is performed on a low-density representation of the parity-check matrix.
In this paper, the possibility to construct LDPC codes, capable to perform recovery of both independent erasures and bursts of erasures by exploiting only the iterative decoder, is investigated. More specifically, the approach consists in starting from an LDPC code parity-check matrix, usually designed in order to achieve good performance on the (memory-less) binary erasure channel (BEC 1 ), and then properly modifying it in order to make it suitable also for the iterative correction of single bursts of erasures.
The performance of this single-step LDPC iterative decoding process is in general suboptimal, in burst scenarios, with respect to the two-step technique proposed in [15], because of the suboptimal iterative burst correction. However, avoiding the quadratic complexity burst correction step (which becomes an issue for long LDPC codes) it only requires linear in n decoding complexity [16]. Furthermore, the proposed algorithm used for making the parity-check matrix suitable to iterative correction of bursts of erasures, besides being extremely simple, turns out to be also extremely effective, generating finite length LDPC codes whose erasure burst correction capability is very close to its maximum possible value. Moreover, if the input parity-check matrix is designed for achieving good performance on the (memory-less) BEC, the optimized code can be used for transmission in both burst and independent erasure scenarios.
The present paper is strictly related to a number of recent works, i.e. [2], [3], [6], [9], [10]. In [2], a key parameter is proposed as a measure of the robustness of an LDPC code to single bursts of erasures, namely the maximum guaranteed resolvable erasure burst length, denoted by L max . A general definition of the parameter L max , valid for any code, can be given as follows.
Definition 1: For a given code, a given parity-check matrix representation, and a given decoding algorithm, the maximum guaranteed resolvable erasure burst length (L max ) is the maximum length of an erasure burst which is correctable independently of its position within the codeword.
As explicitly remarked in this definition, L max is not unique for a given code, heavily depending on both the decoding algorithm and the parity-check matrix representation. For instance, for a given parity-check matrix representation of an LDPC code, the value of L max is not the same with respect to the standard iterative decoding algorithm or to the improved decoding algorithm proposed in [17]. In the sequel, the standard iterative decoder for LDPC codes will be always considered. In [2], an algorithm for the efficient computation of L max for LDPC codes under iterative decoding is developed.
An estimate of the optimal value of L max for LDPC codes, under standard iterative decoding, has been proposed in [3]. Consider an LDPC code, and let p * denote the associated asymptotic decoding threshold [18] on the BEC. Then, for sufficiently large codeword length n, there exists some proper permutation of the parity-check matrix columns such that L max /n ≃ p * . Then, ⌊p * n⌋ can be used as an estimate of the maximum value of L max that can be obtained for the length-n LDPC code, by permuting the parity-check matrix columns.
The maximum guaranteed resolvable erasure burst length for an LDPC code, under iterative decoding, has a strong dependence on the stopping sets present in the bipartite graph. The concept of stopping set has been first introduced in [19]. By definition, a stopping set is any set of variable nodes such that any check node connected to this set is connected to it at least twice. In [19], it is also proved that the union of stopping sets is a stopping set, so that it is possible to define a maximal stopping set included in a subset of the variable nodes, as the union of all the stopping sets included in the subset. The residual erased variable nodes (after iterative decoding) constitute the maximal stopping set included in the original erasure pattern. Hence, a decoding failure takes place whenever the erasure pattern due to the channel contains a stopping set.
The relation between stopping sets and L max has been addressed in [6]. Let G be the LDPC code bipartite graph, and let V = {V 0 , V 1 , . . . , V n−1 } be the set of the variable nodes. If S = {V i 1 , V i 2 , . . . , V it }, with i 1 < i 2 < · · · < i t , is a stopping set, then the span of S is defined as 1 + |i t − i 1 |. Denoting by µ(G) the minimum span of stopping sets (i.e. the minimum among the spans of all the stopping sets of G), it follows that L max = µ(G) − 1. The span of the stopping sets, a concept of no interest on the BEC, heavily affects the code performance when the erasures occur in bursts.
The concept of span of stopping sets is considered in [8], where a lower bound is found for the minimum span of stopping sets for any regular LDPC code. More specifically, it is proved that the minimum span of stopping sets satisfies µ(G) ≥ δ, where δ is the minimum zero span in the parity-check matrix. A zero-span is defined as a sequence of consecutive zeroes in a parity-check matrix row; in terms of L max the bound is L max ≥ δ − 1. In [8], a technique for constructing regular LDPC codes with good L max is also presented. A class of protograph-based LDPC codes whose minimum stopping set size increases linearly with the codeword length n, and hence suitable for transmission over burst erasure channels, has been presented in [9].
The main contribution of this paper is the development of a greedy algorithm, which is able to modify the parity-check matrix of an LDPC code, designed for erasure correction on the BEC, in order to make it suitable also for the iterative correction of single erasure bursts. The present work extends and improves some results from [10], where a former version of the algorithm was presented. The developed algorithm is called pivot searching and swapping (PSS) algorithm, since it is based on the search and swap of the pivots of stopping sets. The novel concept of pivot of a stopping set will be introduced in the next section. According to the proposed approach, the parity-check matrix for iterative burst correction is generated by only performing column permutations on the input parity-check matrix. Hence, the sparseness of the matrix is not altered by the algorithm, and the iterative decoder applied to the new parity-check matrix leads, on the BEC, to exactly the same performance as the original one. If the parity-check matrix received in input by the algorithm is designed for achieving good performance on the BEC, then the code obtained after the application of the PSS algorithm provides good joint correction of independent erasures and single erasure bursts, within a single-step decoding scheme, only exploiting the iterative decoder.
A related algorithm, developed in [13], combines column permutations with column eliminations to improve the code L max . On the other hand, as remarked above, only column permutations are performed by the algorithm proposed in this paper, based on the concept of stopping set pivot. A second related algorithm, based on permutations of the parity check matrix columns, has been developed in [12] for obtaining improved LDPC codes for the correction of two or more bursts of erasures. The metric adopted in [12] to measure the code performance is based on the concepts of average distance between elements and minimum distance between elements, and is different from L max . We also point out the LDPC code construction technique, based on circulant matrices, proposed in [14] and aimed at obtaining LDPC codes with a good compromise between correction of random erasures and erasure bursts. Differently from the approach in [14], the algorithm developed in this paper can be applied to improve the robustness to a single erasure burst of any LDPC code.
The paper is organized as follows. In Section II the concept of pivot of a stopping set is presented, some properties of the pivots of stopping sets are proved, and an efficient algorithm for finding some pivots of a given stopping set is proposed. Section III is devoted to the detailed description of the PSS algorithm. In Section IV some numerical results are presented, showing the improvement in terms of L max achievable by applying the PSS algorithm to different types of LDPC codes. Finally, Section V concludes the paper.

II. PIVOTS OF STOPPING SETS
In this section, the novel concept of pivots of a stopping set is introduced. It is given proof that the minimum number of pivots for any stopping set is two, and an efficient algorithm for finding some pivots of a given stopping set is developed.
For any LDPC code, and for any stopping set of the LDPC code, we define subgraph induced by the stopping set the bipartite graph composed of the variable nodes which are part of the stopping set, the check nodes connected (necessarily at least once) to these variable nodes, and the edges connecting such variable nodes and such check nodes. The key concept of pivot of a stopping set is defined next.
Definition 2: Let G be the subgraph induced by a stopping set S of an LDPC code. A variable node V is called pivot of the stopping set if the following property holds: if the value of V is known and the value of all the other variable nodes of G is unknown, then the iterative decoder applied to G is able to successfully recover from the erasure pattern.
According to this definition, if the variable node V is pivot for a stopping set S, then the set of variable nodes S/{V } is not a stopping set for the LDPC code and contains no stopping sets.
As recalled in the previous section, the iterative decoder is not able to recover from a starting erasure pattern caused by the channel when this erasure pattern includes at least one stopping set. In particular, the set of variable nodes which remain uncorrected at the end of the decoding process is the maximal stopping set included in the starting erasure pattern, i.e. the union of all the stopping sets included in it. The residual graph at the end of the decoding process is the subgraph induced by the stopping set. What we point out with the above definition is that, among the variable nodes in this residual graph, one should distinguish between pivot and non-pivot variable nodes: if the value of at least one of the pivots was known, then the decoding would be successful. This is the basic idea exploited in the optimization algorithm presented in the next section.
It is important to underline that not all the stopping sets have pivots. For instance, the stopping set of size 6 with the induced subgraph depicted in Fig. 1 has no pivots, while the stopping set of size 4 with the induced subgraph depicted in Fig. 2 has two pivots, V 1 and V 2 . The concept of span of pivots, defined next, will be used in Section III.
Definition 3: Let S be a stopping set with pivots, and let V p and V q be, respectively, the pivot of S with minimum index and the pivot of S with maximum index. Then, the span of the pivots of S is then defined as q − p + 1 2 .
The next lemma points out an important property of the structure of stopping sets characterized by the presence of pivots.

Lemma 1:
No stopping set S with pivots exists whose induced subgraph is composed by disjoint graphs.
Proof: It is well known that the union of stopping sets is a stopping set [19]. Hence, the union of stopping sets with unconnected induced subgraphs is a stopping set. Let G be the subgraph induced by a stopping set, and let G = G 1 ∪ G 2 , with G 1 and G 2 unconnected. In such a condition, even if a variable node V α is pivot with respect to G 1 , it cannot be pivot for the whole stopping set, because no variable node in G 2 can be corrected from the knowledge of the value of V α only. Analogously, even if a variable node V β is pivot with respect to G 2 , it cannot be pivot for the whole stopping set. Hence, the stopping set has no pivots.
For a given stopping set of an LDPC code, the problem of finding all the stopping set pivots could be in principle solved by considering the subgraph induced by the stopping set, and by trying, for each variable node, whether the property expressed by Definition 2 is verified. However, there are some complexity issues when following this approach. In fact, this technique would be computationally onerous, especially for stopping sets with large size, and when iteratively used as a subroutine of some algorithm (like that one proposed in the next section). The complexity of this pivot searching algorithm could be reduced by exploiting the following lemma, which defines a necessary condition for a variable node to be a stopping set pivot.
Lemma 2: Necessary condition for a variable node belonging to a stopping set S to be pivot for S, is that the variable node is connected to at least one check node with degree 2 in the subgraph induced by S.
Proof: If no such check node is connected to the variable node, even if the value of the variable node is known, no further correction can be performed by the iterative decoder. In fact, after the elimination from the graph of the variable node and of all the edges connected to it, every check node continues to have a degree at least 2.
According to Lemma 2, the search can be restricted only to the variable nodes which are connected to at least one check node of degree 2 in the subgraph induced by the stopping set.
We propose next an alternative and more efficient algorithm for the search of stopping set pivots. This algorithm is in general not able to find all the pivots of a given stopping set, and its success is bound to the condition that at least one pivot for the stopping set is already available. However, for the purposes of the optimization algorithm of LDPC on burst erasure channels described in the next section, where two pivots for each stopping set are always available, this algorithm comes out to be extremely effective. The proposed pivot searching algorithm is based on the following lemma. It defines a simple, sufficient condition for a variable node to be a stopping set pivot.
Lemma 3: Sufficient condition for a variable node V α belonging to a stopping set S to be pivot for S, is that there exists some V β ∈ S and some check node such that V β is pivot for S, the check node has degree 2 in the subgraph induced by S and it is connected to V α and V β .
Proof: Let C be the check node connected to V α and V β , with degree 2 in the subgraph induced by S. If the value of the variable node V α is known, and the value of all the other variable nodes in S is unknown, then C is capable to correct the variable node V β . Since V β is a pivot of S by hypothesis, then all the variable nodes of the stopping set will be corrected.
Combining Lemma 2 and Lemma 3 it is possible to prove the following result.
Theorem 1: If a stopping set S has pivots, then it has at least two pivots.
Proof: Let the variable node V α be a pivot of S. For Lemma 2, V α must have at least one connection towards a check node C, with degree 2 in the subgraph induced by S. Let V β be the second variable node connected to C. From Lemma 3, this is sufficient to conclude that V β is a pivot of S. Thus, the number of pivots is at least two.
The variable nodes V α and V β in the statement of Lemma 3 will be referred to as neighboring pivots. If it is known that the variable node V is a pivot of a certain stopping set, then all its neighboring pivots can be found by looking, among the check nodes connected to V , for check nodes with degree 2 in the subgraph induced by the stopping set. Based on Lemma 3, we propose the following pivot searching algorithm for a stopping set S of an LDPC code. As remarked above, the hypothesis is that at least one pivot of the stopping set is already available at the beginning of the algorithm.
Pivot Searching Algorithm.
If only one pivot is available at the beginning of the algorithm (|P (0) | = 1), since at least one neighboring pivot must exist for the available pivot, the minimum number of pivots returned by the algorithm is 2. At each step of the algorithm, the sufficient condition expressed by Lemma 3 is applied to the new pivots found at the previous step. The algorithm is stopped as soon as no new pivots are found. For instance, consider the stopping set of size 8 whose induced subgraph is depicted in Fig. 3, where the variable nodes V 2 , V 4 , V 6 , V 7 and V 8 are supposed to be the stopping set pivots. In this figure, the check nodes with degree 2 in the subgraph induced by the stopping set, and connecting the neighboring pivots, have been depicted as filled square nodes, while the other check nodes have been depicted as non-filled square nodes.
The set of pivots P (2) is returned by the algorithm. Note that the pivots V 7 and V 8 cannot be found by the algorithm, for This pivot searching algorithm is exploited in the optimization algorithm for LDPC codes on burst erasure channels, presented in the next section. The key for the application of the pivots searching algorithm is the following observation: if for a given LDPC code with maximum guaranteed resolvable burst length L max , a burst of length L max + 1 is non-resolvable, then two pivots of the maximal stopping set included in the burst can be always immediately found.

III. OPTIMIZATION ALGORITHM FOR LDPC CODES ON BURST ERASURE CHANNELS
After having defined the concept of stopping set pivots, in this section we present the LDPC codes optimization algorithm for burst erasure channels.
For an LDPC code with maximum guaranteed resolvable erasure burst length L max , any single erasure burst of length L ≤ L max can be corrected by the iterative decoder independently of the burst position within the codeword of length n. On the contrary, there exists at least one erasure burst of length L max +1, starting on some variable node V j , which is non-correctable by the iterative decoder. This implies that this erasure burst includes some stopping sets. Next, it is proved that the maximal stopping set included in the burst (defined as the union of all the stopping sets included in the burst) has at least two pivots. Specifically, the variable nodes V j and V j+Lmax , i.e. the first and the last variable nodes in the burst, are pivots.
Theorem 2: Let L max be the maximum guaranteed resolvable burst length of an LDPC code under iterative decoding, and let the erasure burst of length L max + 1 starting on the variable node V j and ending on the variable node V j+Lmax , be non-correctable. Then, V j and V j+Lmax are pivots for the maximal stopping set included in the burst.
Proof: Let S be the maximal stopping set included in the non-correctable erasure burst of length L max + 1, and let G be the subgraph induced by S. By hypothesis, an erasure burst of length L max , starting on the variable node V j and ending on the variable node V j+Lmax−1 , can be corrected by the iterative decoder. This implies that if the value of the variable node V j+Lmax is known, then the iterative decoder applied to G is able to successfully correct all the variable nodes in the maximal stopping set. Hence, V j+Lmax is a pivot of S.
Analogously, an erasure burst of length L max , starting on the variable node V j+1 and ending on the variable node V j+Lmax , can be corrected by the iterative decoder. By reasoning in the same way, it is proved that V j is a pivot of S.
The theorem implies that the pivots' span of the maximal stopping set included in the erasure burst of length L max + 1 is equal to L max + 1. By combining Lemma 1 with Theorem 2 we also obtain the following result on the structure of the maximal stopping set included in a non-correctable erasure burst of length L max + 1.
Corollary 1: Let L max be the maximum guaranteed resolvable burst length of an LDPC code under iterative decoding. Let the erasure burst of length L max + 1, starting on the variable node V j , be noncorrectable, and let S be the maximal stopping set included in the burst. Then, the subgraph G induced by S is composed of non-disjoint bipartite graphs, i.e. a path exists from any variable node in G to any other variable node in G.
The optimization algorithm for LDPC codes on burst erasure channels is described next. It receives an LDPC code parity-check matrix in input, and returns an LDPC code parity-check matrix with improved performance in environments where erasures occur in bursts. This algorithm performs some permutations of the input LDPC code variable nodes, in order to increase its maximum guaranteed resolvable burst length, thus improving its burst erasure correction capability. Neither the input code degree distribution nor the connections between the variable and the check nodes are modified by the algorithm. As a consequence, the input LDPC code and the LDPC code returned by the algorithm have the same degree distribution and the same performance on the memory-less erasure channel.
Consider an LDPC code with maximum guaranteed resolvable burst length L max , let V denote the ensemble of all its variable nodes, and suppose that the iterative decoder is not able to successfully recover from a number N B of erasure bursts of length L max + 1 (some of the non-correctable erasure bursts might be partly overlapped). Let V (i, f ) and V (i, l) be, respectively, the first and the last variable node of the i-th uncorrectable burst, with i = 1, . . . , N B , and let B (i) be the set of all variable nodes included in the i-th burst. According to Theorem 2, the i-th uncorrectable burst contains a maximal stopping set S (i) max which includes V (i, f ) and V (i, l) among its pivots, and other pivots of this stopping set can be eventually found by the pivot searching algorithm presented in the previous section. Suppose that one of these pivots is swapped with a variable nodeṼ (i) not included in B (i) such that, after the swapping, the pivots' span of S (i) max becomes larger than L max + 1 (see Fig. 4). For any starting erasure pattern given by an erasure burst of length L max + 1, the value of at least one pivot of S (i) max is now known, and the considered stopping set will be resolvable for any possible position of such burst.
If this procedure is applied to each uncorrectable erasure burst, each maximal stopping set S (i) max (i = 1, . . . , N B ) becomes resolvable for any possible burst position. This does not necessarily imply that the erasure burst length L max +1 will be resolvable at the end of the swapping procedure, since any swap could in principle reduce the pivots' span of some other stopping set. On the other hand, all our numerical results reveal that this approach is indeed very effective up to values of the erasure burst length L extremely close to ⌊p * n⌋.
If the sequence of N B variable node permutations makes the erasure burst length L max + 1 resolvable for any position of the burst, then the new burst length L max + 2 is considered. On the contrary, a failure is declared, all the permutations are refused, and a new sequence of N B permutations is performed. The algorithm ends when a maximum number F max of subsequent failures is reached, for the same burst length. The L max optimization algorithm is formalized in the following. The algorithm input is an LDPC code with maximum guaranteed resolvable burst length L max . 1-Randomly choose a pivot V , l) , then randomly choose a variable nodẽ

Pivot Searching and Swapping (PSS) Algorithm
and swap V , f ) , then randomly choose a variable nodeṼ (i) as from (3), and such that the index ofṼ (i) is smaller than the index of , l) , then randomly choose a variable nodeṼ (i) as from (3), and such that the index ofṼ (i) is larger than the index of • [Stopping criterion] If the erasure burst length is not resolvable, set F = F + 1. If F = F max , stop and return the new LDPC code with L max = L − 1. If F < F max goto Pivot swapping step. Else, if the erasure burst length L is resolvable, set L = L + 1 and goto Pivot searching step.
For each non-resolvable burst, the randomly chosen pivot V (i) p is swapped with a variable nodeṼ (i) in order to guarantee that pivots' span of S (i) max after the swapping is greater than L max + 1. If V , with the exclusion of the available pivots for the maximal stopping sets of the other non-correctable bursts, and of the variable nodes already swapped for the previously considered bursts. If V (i) p = V (i, f ) , there are some cases where the pivots' span of S (i) max after the swapping might be not greater than L max + 1, i.e. when the index ofṼ (i) is larger than, and sufficiently close to, the index of V (i, l) . For this reason, if V (i, f ) is selected,Ṽ (i) is chosen among the variable nodes with index smaller than V (i, f ) . Analogously, if V (i, l) is selected,Ṽ (i) is chosen among the variable nodes with index larger than V (i, l) .
The PSS algorithm is extremely flexible and can be in principle applied to any LDPC code, independently of its structure, code rate and codeword length. For instance, it can be applied to either regular or irregular LDPC codes, both computer generated (e.g. IRA [20], eIRA 3 [21] [22] or GeIRA [23] codes generated according to the PEG algorithm [24]- [26], protograph codes [27], [28]) and algebraically generated (e.g. LDPC codes based on finite geometries [29], [30]). The optimized code returned by the algorithm has the same performance as the input code on the memory-less erasure channel, but is characterized by an increased capability of correcting single erasure bursts. Then, the PSS algorithm can be used within a two-step design approach, consisting in first generating a good LDPC code for the memory-less erasure channel, and then improving it for burst correction. This approach leads to LDPC codes with good performance in environments where the erasures are independent, and where the erasures occur in bursts. The algorithm can be also applied to already implemented LDPC codes: in this case, it can be interpreted as a tool for the design of an ad hoc interleaver which will increase the robustness of the code to erasure bursts.

IV. NUMERICAL RESULTS
In this section, some numerical results on the L max improvement achievable by applying the PSS algorithm are shown. Five examples are provided. The first four examples are given for LDPC codes with rate R = 1/2 and different construction methods; the fifth one for a rate R = 0.8752 LDPC code. The four rate-1/2 codes are, respectively, a (3, 6)-regular (2640, 1320) LDPC code with Margulis construction [31], [32], an irregular (1008, 504) LDPC code generated with the PEG algorithm, a (2000, 1000) IRA code generated with the PEG algorithm and a (2048, 1024) GeIRA code generated with the PEG algorithm. The IRA and GeIRA codes construction was performed by first generating, respectively, the double-diagonal and multi-diagonal part of the parity-check matrix corresponding to the parity bits, and then generating the systematic part with the PEG algorithm, also considering the 1s already positioned in the parity part. The IRA code is characterized by uniform check node distribution and by a regular systematic part of the parity-check matrix, with all the variable nodes corresponding to the systematic bits having degree 5. The GeIRA code is characterized by feedback polynomial (for the recursive convolutional encoder) g(D) = 1 + D + D 420 , and by uniform check node distribution. The degree multiplicity for the variable nodes corresponding to the parity bits is 1(1), 419(2), 604(3), while the degree multiplicity of the variable nodes corresponding to the systematic bits is 885(3), 85(13), 54 (14). Finally, the rate 0.8752 code is a (4, 32)-regular (4608, 4033) LDPC code generated with the PEG algorithm (the parity-check matrix for this code is (256 × 4608), with one redundant row). The bipartite graphs of the (2640, 1320) Margulis code and of the (1008, 504) irregular code are both available in [33], where the degree distribution of the irregular code is also specified. The bipartite graph of the (2000, 1000) IRA code, (2048, 1024) GeIRA code and high rate code were generated independently.
The results obtained with the application of the PSS algorithm (with F max = n) to the five codes are summarized in Table I. In this table, n − k represents the maximum possible value for L max , which can be obtained by generating the parity-check matrix in burst correction form and applying to it the quadratic complexity decoding algorithm, as explained in [15]. For each code, the value of L max for the original code, and the estimate of the maximum value of L max achievable with column permutations (⌊p * n⌋, as suggested in [3]), are also shown. At the bottom of the table, L PSS max denotes the maximum guaranteed resolvable burst length for the code returned by the algorithm.
The starting value of L max for the Margulis code (1033) was already quite close to ⌊p * n⌋. On the contrary, the values of L max exhibited by the other codes (86, 403, 495 and 287 respectively) were quite poor with respect to ⌊p * n⌋, especially for the irregular (1008, 504) PEG code. When applied to the Margulis code, the PSS algorithm returned a code with an excellent value of L PSS max , even larger than ⌊p * n⌋. This result leads to a relevant conclusion: it is possible to construct finite length LDPC codes with moderate codeword length, such that L max > ⌊p * n⌋. Furthermore, for the irregular PEG code, the IRA code, the GeIRA code and the high rate regular code, the values of L PSS max produced by algorithm were quite close to (though lower than) ⌊p * n⌋. These examples reveal the extreme effectiveness of the PSS algorithm for a wide range of LDPC construction methods. As a comparison, in [7, Example 3], a (4, 32)-regular (4608, 4033) quasi cyclic LDPC code, whose construction is based on circulant permutation matrices, is proposed for burst erasure correction. This code is characterized by L max = 375. As it can be observed in Table I, the original (4, 32)-regular code generated by the PEG algorithm has a value of L max smaller than 375; however, the PSS algorithm was able to improve this value beyond 375, up to 425.
It should be observed that for LDPC codes characterized by systematic IRA-like encoding, the doublediagonal structure allowing efficient encoding is lost due to the column permutations executed by the algorithm. In this case, the variable node permutation can be interpreted as an extra interleaving step to be performed on the transmitter side prior of encoding. An alternative approach for such codes consists in limiting the algorithm permutations to the systematic variable nodes only, in order to avoid the extra interleaving step. In this case, however, the achievable values of L max are smaller than those which can be obtained by applying the permutation to all the parity-check matrix columns. For example, we obtained L max = 607 for the (2000, 1000) IRA code of Table I. In order to give a more precise idea about the L max improvement capability of the PSS algorithm, consider Table II, where the details of how the algorithm worked for the (4, 32)-regular code are provided. In each table entry two integer numbers are shown: the integer on the top is a value of erasure burst length, while the integer on the bottom is the number of uncorrectable positions registered for that erasure burst length (denoted by N B in the formalization of the algorithm proposed in the previous section). The burst lengths not shown in the table are those ones for which N B = 0 was registered. Hence, for instance, the first erasure burst length that was recognized as non-resolvable for some burst position, was L = 288: for this length, one non-resolvable burst position was found. By applying the pivot searching and swapping principle, a column permutation was obtained which made the length L = 288 resolvable for any burst position. Assuming this permuted version of the parity-check matrix, the burst length L = 289 was investigated, and three burst positions where recognized as non-resolvable (N B = 3). Again, a column permutation was found that guaranteed the length L = 289 to be resolvable for any burst position, and so on up to the burst length L = 426, for which the algorithm failed. As it can be observed from Table II, for some values of L the algorithm was able to correct a relatively large number of uncorrectable burst positions, e.g. N B = 12 for L = 395 and L = 400, N B = 13 for L = 389 and N B = 18 for L = 403.
V. CONCLUSION In this paper, a simple and effective algorithm for the optimization of LDPC codes on burst erasure channels, under iterative decoding, has been developed. The application of the proposed algorithm to a given LDPC parity-check matrix leads to a new parity-check matrix, characterized by properly permuted columns, with a notable improvement in terms of maximum guaranteed resolvable burst length. At each step of the algorithm, the columns to be permuted are carefully chosen on the basis of a local stopping set pivot analysis for the uncorrectable burst positions. The optimized code has the same performance as the original code on the BEC. Hence, if the input parity-check matrix is optimized in order to achieve good performance on the memory-less erasure channel, then the resulting code can be used for communication both in scenarios with independent erasures and in scenarios where the erasures occur in bursts, by only exploiting the linear complexity iterative decoder. Numerical results have been presented, showing the effectiveness of the proposed approach for a wide range of LDPC code constructions.

APPENDIX ALGORITHM COMPLEXITY
In this appendix, we discuss some complexity issues for the PSS algorithm. Specifically, given an LDPC code with maximum guaranteed resolvable burst length L max = L, we evaluate the complexity to obtain an improved code for which the erasure burst length L + 1 is resolvable. As from the algorithm formalization given in Section III, we see that the operations required for making the burst length L + 1 resolvable are: 1. Search of the unresolvable length-(L+1) burst positions within the codeword (their number is denoted by N B ). 2. Search of the pivots for each of the N B unresolvable burst positions. 3. Selection of N B pivots. 4. Selection of N B variable nodes. 5. Variable node swapping. 6. Search of the possible unresolvable length-(L + 1) burst positions within the codeword. 7. Variable node swapping back if the erasure burst length L + 1 is non-resolvable. The steps 1 and 2 are performed only once. Denoting by F act the actual number of trials needed to obtain the code for which the erasure burst length L + 1 is resolvable, the steps 3 to 6 are performed F act times, while the step 7 is performed F act − 1 times (since the permutation is accepted at the trial F act ).
The overall complexity is the summation of the complexities and is dominated by the complexity of the steps 1 and 6, both requiring to perform n − L iterative decoding operations, each one with a starting erasure pattern of size L + 1. The complexity involved with the other steps is negligible from a practical perspective, due to the very simple operations performed (variable node selection or variable node swapping) and to the fact that the number N B of uncorrectable bursts of length L max + 1 is typically on the order of a few units, as shown for instance in Table II for the (4608, 4033) code. The overall complexity is then given by the complexity required to perform (F act + 1)(n − L) iterative decoding operations, each one for L + 1 unknown bits. The number F act of trials needed to succeed is usually quite small, typically ranging from a few units to a few tens. For example, in the optimization of the (2000, 1000) code of Table I, F act was above 50 in one case only and typically less than 10. Being the LDPC iterative decoder complexity linear, the complexity required for generating a code with L max > L starting from a code with L max = L is then quadratic in the codeword length n.
For the codes presented in Table I, the overall time to obtain the code with L max = L PSS max starting from the original code ranged from less than three minutes for the (1008, 504) code to about one hour and ten minutes for the (4608, 4033) code (whose parity-check matrix is the least sparse).    max is swapped with the variable nodeṼ (i) (not in B (i) ) in order to make the pivots' span greater than Lmax + 1.