New Two-Stage Automorphism Group Decoders for Cyclic Codes in the Erasure Channel

Recently, error correcting codes in the erasure channel have drawn great attention for various applications such as distributed storage systems and wireless sensor networks, but many of their decoding algorithms are not practical because they have higher decoding complexity and longer delay. Thus, the automorphism group decoder (AGD) for cyclic codes in the erasure channel was introduced, which has good erasure decoding performance with low decoding complexity. In this paper, we propose new two-stage AGDs (TS-AGDs) for cyclic codes in the erasure channel by modifying the parity check matrix and introducing the preprocessing stage to the AGD scheme. The proposed TS-AGD has been analyzed for the perfect codes, BCH codes, and maximum distance separable (MDS) codes. Through numerical analysis, it is shown that the proposed decoding algorithm has good erasure decoding performance with lower decoding complexity and delay than the conventional AGD. For some cyclic codes, it is shown that the proposed TS-AGD achieves the perfect decoding in the erasure channel, that is, the same decoding performance as the maximum likelihood (ML) decoder. For MDS codes, TS-AGDs with the expanded parity check matrix and the submatrix inversion are also proposed and analyzed.


I. INTRODUCTION
Research on error correcting codes in the erasure channel is one of the major subjects in information theory. Erasure channel is a typical channel model for distributed storage systems and wireless sensor networks, where the locations of symbol errors are known.
Algebraic codes have a long history from Hamming codes to algebraic geometry codes. The decoders of algebraic codes are designed using the mathematical properties of the codes and thus it is difficult to implement practical decoders for algebraic codes. However, lots of research works for their decoding algorithms have been done to reduce the decoding complexity and delay. In cyclic codes, one-step majority decoding [3] and permutation decoding [4] schemes are exemplary methods which can be practically implemented using their cyclic property in the error channel.
A low complexity iterative decoder can be one of the solution as an implementable decoder and thus, the iterative decoding algorithms and error correcting codes with iterative The associate editor coordinating the review of this manuscript and approving it for publication was Zilong Liu . decoder such as turbo and low-density parity-check (LDPC) codes have been widely studied. In addition, low-complexity iterative erasure decoder (IED) for algebraic codes has also been studied [7]. However, IED has inherently inferior decoding performance compared to the maximum likelihood (ML) decoder and the gap between the decoding performances becomes larger for the algebraic codes, because the sparseness of their parity check matrices is not guaranteed contrary to the LDPC codes. Thus, a possible solution for decoding of algebraic codes is to modify the structure of the decoder in the erasure channel.
Recently, one approach to overcome the inferior decoding performance of IED for the algebraic codes in the erasure channel was proposed, called the automorphism group decoder (AGD) for cyclic codes [8]. AGD uses the permutations of the automorphism group in the middle of the IED procedure. For cyclic codes, the permutation operation can be substituted by the cyclic shift operation for codewords, which are also codewords. It was shown that for some cyclic codes, AGD improves the decoding performance but it requires higher decoding complexity and delay due to repeated decoding process. In addition, many similar concepts have been proposed for cyclic LDPC codes in the error channel such as multiple-bases belief-propagation (MBBP) [9] and revolving iterative decoding (RID) [10], [11].
In order to operate AGD efficiently, it is important to design the appropriate parity-check matrix. However, the conventional design method in [8] includes the problem to find codewords with minimum Hamming weight which is known as NP-hard problem in general. In this paper, we propose a new decoding algorithm, referred to as a two-stage AGD (TS-AGD) which includes a construction algorithm of good parity-check matrix with polynomial-time complexity and also has excellent decoding performance with low decoding complexity for cyclic codes. The proposed decoding process is done in two decoding stages. That is, the first decoding stage finds the cyclic shift values of the received vector for the successful erasure decoding while in the second decoding stage, the erasure decoding process is done for the received vectors cyclically shifted by the cyclic shift values found in the first decoding stage. Further, the proposed TS-AGD algorithm can be implemented by the modified parity-check matrix for the (n, k) cyclic code such that some of the (n − k)-tuple column vectors in the paritycheck matrix are standard vectors in the appropriate column indices and Hamming weight of the row vectors in the paritycheck matrix becomes as low as possible, which requires polynomial-time complexity. The numerical analysis shows that the proposed algorithms are advantageous for extended Golay codes and high-rate BCH codes, where they achieve near-ML decoding performance.
Interestingly, TS-AGD can also be applied to the error channel such as additive Gaussian channel using the motivation of ordered statistics decoding (OSD) [12]. In OSD, k most reliable bits are considered not to be erroneous and declare a decoded word as the codeword which has the same hard-decisioned bits as the received vector in the k most reliable bits, where k is code dimension. It is known that OSD outperforms hard-decision decoding (HDD) such as Euclidean decoder. For codelength n, most reliable k bits and the other n − k bits in OSD are considered as non-erasures and erasures in the erasure channel. respectively and thus, TS-AGD for erasure channel can also decode the errors as OSD can decode. Numerical analysis shows that TS-AGD has near-ML performance in the error channel as well as in the erasure channel. This paper is organized as follows. In Section II, AGD, IED, and OSD are reviewed. In Section III, the proposed TS-AGD for the binary cyclic codes in the erasure and error channels is introduced by modifying the paritycheck matrix and the AGD algorithm, referred to as TS-AGD. In Section IV, numerical analysis of the proposed TS-AGD schemes verifies the performance improvement for the extended Golay and high-rate BCH codes. Finally, the conclusion is given in Section V.

II. PRELIMINARY
In this section, several mathematical notations and abbreviations are defined. For a vector v v v, wt(v v v) denotes Hamming weight of vector v v v and supp(v v v) denotes the set of indices of the nonzero components in v v v. The i-th standard vector u u u i is the basis vector, where the i-th component of u u u i is equal to 1 and the other components are equal to 0. Let 0 0 0 and 1 1 1 denote the all-zero and all-one vectors. The decoding procedures of IED and AGD are explained and compared and several definitions are presented in the next subsection. Also suppose that (n, k) linear binary code C with codelength n and dimension k has an (n − k) × n parity-check matrix H .
A. ERASURE DECODER: IED AND AGD 1) IED FOR ERASURE CHANNEL In IED, H can be represented by a bipartite graph G with n variable nodes (VNs) and n − k check nodes (CNs). Let V and U be sets of variable nodes and check nodes and let d v i and d u j be degrees of a variable node v i ∈ V and check node u j ∈ U , respectively, for 0 ≤ i ≤ n − 1 and 0 ≤ j ≤ n − k − 1. The bipartite graph is then denoted by G=(V , U , H ). In the erasure channel, the variable nodes have two different states, i.e., erasure and non-erasure states, while the check nodes have three states, i.e., decodable, non-decodable, and nonerasure states. The decoding procedure of IED consists of several iterations, where each iteration performs check node update (CNU) and variable node update (VNU) operations sequentially.
The CNU operation is the procedure that each CN finds its state by counting the number of the erasure states of the variable nodes connected to itself. A decodable state of a CN is declared when the number of the connected VNs in the erasure state is 1. If the CN is connected to two or more VNs in the erasure state, then a non-decodable state is declared for the CN. The CNs which are not connected with VNs in the erasure state are called non-erasure states. The VNU operation is a procedure by which VNs in the erasure state are decoded using their connected decodable CNs.
2) AGD FOR ERASURE CHANNEL [8] AGD can be applied to cyclic codes, where AGD consists of the repeated IED and cyclic shift operations for the received vectors. That is, if there is no decodable check node, then the received vector is cyclically shifted until decodable check nodes are found. If it is found, the IED algorithm is repeatedly applied to the cyclically shifted received vectors.
It is known that the cyclic shift operation is easy to implement with negligible complexity and delay. In the AGD, IED should be performed for each cyclically shifted received vector until the decoding is successful or the number of cyclic shifts is equal to the length of codeword. Although the decoding complexity and delay of the AGD are much higher than those of the IED, the decoding performance of the AGD is much better than that of the IED.
The decoding performance and complexity of IED and AGD can be improved by using an optimized parity-check matrix. For binary case, Hehn uses cyclic orbit generator (cog) and cog family to construct parity-check matrix [8]. Two vectors v v v 1 and v v v 2 are said to be cyclically indistinguishable if the cyclic shift of v v v 1 is identical to v v v 2 , and otherwise, cyclically distinguishable. Then, the cog is defined as the cyclically distinguishable binary codeword of a dual code with minimum Hamming weight, which can be used as a row of the parity-check matrix. Cog family is the set of cogs that have the same Hamming autocorrelation property, where the Hamming autocorrelations of cog's are defined as where cog cog cog (τ ) is right cyclic shift of cog cog cog by τ and · denotes the inner product. Then, the parity-check matrix is constructed by n − k cogs, where it is desirable to select the n − k cogs from cog families minimizing the upper bounds of Theorem 3.9 in [8].

B. ERROR DECODER: OSD
Let c c c = (c 0 , . . . , c n−1 ) ∈ C be a binary codeword in a code C and binary phase shift keying (BPSK) modulation is assumed. Then, a received vector r r r = (r 0 , . . . , r n−1 ) is denoted as . Then, we select the k most reliable information (MRI) elements from the received vector, that is, the k elements with the largest values in |r r r| = (|r 0 |, . . . , |r n−1 |) that are linearly independent. Declare a decoded codeword as the codeword which has the same hard-decisioned bits as the received vector in the indices of the k MRI elements.
Procedure of OSD requires the following operations. In order to find the decoded codeword with the same elements as the hard-decisioned k MRI elements, matrix inversion of (n − k) × (n − k) submatrix with columns except the indices of k MRI bits from H is used. In fact, many of the n − k columns are linearly dependent actually and thus it is needed to reiterate the following procedure for k new MRI bits by removing the column with minimum reliability and adding the dependent column with maximum reliability among the columns except the indices of the k MRI bits. Thus, OSD requires high decoding complexity from these operations. In order to reduce the complexity, locality-aware OSD was introduced recently [16]. Similarly, we will show that lowcomplexity TS-AGD will be proposed in the error channel using the approach of OSD.

C. SOME DEFINITIONS
In this subsection, some definitions for the proposed TS-AGD algorithms are presented as follows. First, several definitions of binary sequences are presented. Let s D (t) denote a characteristic sequence of index set D such that s D (t) = 1 if t ∈ D and s D (t) = 0, otherwise. Two binary sequences frequently used in this paper are defined as follows.
Definition 1 (Erasure Sequence): Erasure sequence s e (t) is defined as a characteristic sequence of the erasure set S e , which is the set of indices of erasure symbols in the vector received over the erasure channel.
Definition 2 (Parity Check Sequence): Parity check sequence s p (t) of the (n − k) × n parity-check matrix H of the (n, k) cyclic code is a binary sequence of length n defined as where h h h t is the t-th column of H. Furthermore, let S p denote the support set of s p (t), i.e., the set of indices of column vectors with Hamming weight 1.
For column indices of the parity-check matrix H , the components of S p are called standard indices and otherwise, nonstandard indices. Thus, the number of 1's in a length of s p (t) is smaller than or equal to n−k. The Hamming cross-correlation of two binary {0, 1} sequences, s e (t) and s p (t), is defined as where In the next section, we propose a modification of paritycheck matrix, TS-AGD algorithm, and their analysis.

III. MODIFICATION OF PARITY-CHECK MATRIX AND TWO-STAGE AGD
In this section, we propose a new modification method of the parity-check matrix and a two-stage decoding algorithm, and the result of a numerical analysis for the proposed decoding algorithm is discussed.

A. MODIFICATION OF THE PARITY-CHECK MATRIX
First, we propose a method to modify the parity-check matrix for the proposed two-stage decoding algorithm because the decoding performance of the proposed two-stage decoding algorithm depends on the structure of the parity-check matrix. Here, the following criteria are used for the modification of the parity-check matrix using Definition 2.
Three criteria for modification of parity-check matrix (i) Modify the parity-check matrix such that as many of its column vectors as possible are the standard vectors. (ii) The parity check sequence of the parity-check matrix has Hamming autocorrelation values as low as possible. (iii) Each row of the parity-check matrix has as low Hamming weight as possible. In fact, the best criteria for the parity-check matrix of (n, k) cyclic codes can be described as: (i) n − k columns of the parity-check matrix are standard vectors. (ii) All Hamming autocorrelation values of the parity check sequence of the parity-check matrix are equal. (iii) The Hamming weights of all rows of the parity-check matrix are equal to the minimum Hamming weight of its dual code. It is easy to check that in order for the parity check sequences to satisfy the second criterion, they should be the characteristic sequences of cyclic difference sets D C with parameters (n, k, λ) for (n, k) cyclic codes, if their parameters are allowed for the cyclic difference sets. Note that k-subset D C of a cyclic group G with order n is an (n, k, λ) cyclic difference set if every nonzero component of G has exactly λ representations as a difference d c − d c with components from d c , VOLUME 8, 2020 d c ∈ D C [13]. It is known that some cyclic codes satisfy the above best criteria. The other criteria can be compromised if one criterion cannot be achieved due to the other criteria. The proposed decoding algorithms together with the proposed modification of the parity-check matrix will be explained in the next subsection.

B. A NEW TWO-STAGE AGD IN THE ERASURE CHANNEL
Using AGD algorithm, we propose a new two-stage AGD of (n, k) cyclic codes in the erasure channel as follows.

1) FIRST DECODING STAGE (PREPROCESSING STAGE)
Find a {0, 1} parity check sequence s p (t) of length n from the parity-check matrix H of an (n, k) cyclic code. Find a {0, 1} erasure sequence s e (t) of length n from the received vector r = (r 0 , r 1 , . . . , r n−1 ). Then, calculate a Hamming crosscorrelation as Clearly, R H (τ ) takes values of the nonnegative integers less than or equal to min{|S e |, |S p |} because |S e | is the number of erasure symbols and |S p | is the number of standard vectors of the parity-check matrix. It can be assumed that the decoding complexity of the preprocessing stage for each τ is analogous to the CNU of one check node. If there exists τ such that R H (τ ) = |S e |, then proceed to the second decoding stage.
If not found, cyclically shift the received vector and proceed to the second decoding stage for r (τ ) in the order of τ 's such that values of R H (τ ) are decreasing, where r (τ ) is a cyclic shift of r by τ .

2) SECOND DECODING STAGE (IED Stage)
In the second decoding stage, the IED algorithm is used for decoding of the cyclically shifted received vector according to the values of R H (τ ). Recall that S p is the support set of s p (t). Let r (τ ) = (r n−τ , r n−τ +1 , . . . , r n−1 , r 0 , . . . , r n−τ −1 ) be a received vector cyclically shifted by τ , where erasure symbols are located in the indices in S that is, all of the erasure symbols in r (τ ) are located in the indices of standard vectors. Note that the i-th component of the received vector r is expressed as the transmitted symbol c i for a non-erasure symbol andĉ i for an erasure symbol. Suppose that r (τ ) can be split into two n-tuple vectors as e and otherwise, 0 and the j-th component of r e and otherwise, 0. In general, the syndrome vector should be zero as where is a transpose of a vector and thus If the j-th column vector of H is the i-th standard vector u u u i ,ĉ j is equal to the i-th component of H (r (τ ) ne ) because R H (τ ) = |S e |. Clearly, each j-th column for j ∈ S e ⊂ S p has a different standard vector u u u i . In this case, we can recover all of the erasure symbols by H (r (τ ) ne ) in one iteration, which is described in Fig. 1. (ii) For τ such that R H (τ ) = |S e | − 1: In this case, we have one erasure symbol in the non-standard vector of H and the other erasure symbols are located in the column indices in S p . Here, the decoding process is done in two steps, that is, one for one erasure symbol in the nonstandard vector of H and the other for the other erasure symbols with indices in S p . Suppose that the set of erasure symbol indices is given as {e 0 , e 1 , . . . , e z−1 }, where z is the number of erasure symbols. Suppose that the e j -th column is the i j -th standard vector u u u i j , 0 ≤ j ≤ z−2, and the e z−1 -th column of H is a non-standard vector.
We also have |S p | − z + 1 standard vectors in H , where non-erasure symbols are located. In the first decoding step, assume that for z ≤ i j ≤ |S p |, some i j -th component of the e z−1 -th column of H is equal to 1. Then, using the   To decode the remaining erasure symbols, it is needed to return to the preprocessing stage to find the values of τ 's with higher values of R H (τ ). The second decoding stage of the proposed two-stage decoding algorithm is described in Fig. 3. Overall, the decoding procedure of TS-AGD is described in the flowchart of Fig. 4.

C. ANALYSIS OF MODIFICATION CRITERIA FOR THE PARITY-CHECK MATRIX
This subsection analyzes the modification criteria of H for (n, k) cyclic codes. The first criterion is related to the number of standard vectors, that is, the number of t's such that s p (t) = 1, which is less than or equal to n − k. As described in the previous subsection, the proposed TS-AGD procedure can be done for the cyclically shifted received vector r (τ ) such that R H (τ ) has higher values. As the number of 1's in s p (t) increases, it is more probable for R H (τ ) to have higher values. The second criterion is how to locate the standard vectors in the parity-check matrix. It is not easy to prove the second criterion and thus the following theorem replaces the proof of the second criterion. First, we need a lemma to prove the following theorem.  Proof: First, it is desirable for the proposed decoding algorithm to successfully decode more erasure patterns, which is possible if R H (τ ) ≥ |S e | − 1. Thus, we have to modify the parity-check matrix, for which R H (τ ) ≥ |S e | − 1 is most common for as many shift values τ as possible. The following two cases are considered.
(i) R H (τ ) = |S e |: This means that S (τ ) e ⊆ S p . It is easy to check that in R H (τ ), it is equivalent to cyclically shift s p (t) instead of s e (t). Let S (τ ) p be the support set of s p (t + τ ). Let E τ be the set of erasure patterns which can be successfully recovered by s p (t + τ ). Then, we have |E τ | = |S p | |S e | , which leads to It is easy to check that doubly counted erasure patterns are included in (9), which should be excluded. If the shaded parts in Fig. 5 include all the erasure symbols, those erasure patterns are doubly counted, where a(τ 1 , τ 2 ) denotes the number of pairs s p (t + τ 1 ), s p (t + τ 2 ) = (1, 1). Thus we have 2|S p |+a(τ 1 ,τ 2 )−n |S e | doubly counted erasure patterns. Using Lemma 1, the number of erasure patterns which are successfully decoded by s p (t) is bounded as  Fig. 6. a) Each of two erasure symbols is located in A 10 and A 01 , respectively and the other erasure symbols are located in A 00 , which are counted as b) One erasure symbol is located in A 11 and the other erasure symbols are located in A 00 , which are counted as . Similarly, from Lemma 1, the number of erasure patterns which are successfully decoded by s p (t) is given as In order to maximize the upper bounds in (10) and (11), the second terms of the right hand sides should be minimized, which can be solved by the convex optimization as described in Appendix. That is, it is derived in Appendix that maximizing the upper bound on the number of occurrences of R H (τ ) ≥ |S e | − 1 for 0 ≤ τ ≤ n − 1 by convex optimization occurs when the autocorrelation values of s p (t) are constant. Thus, we prove the theorem. The third criterion is related to the performance of the decoder, that is, H with the minimum Hamming weight of rows can have better decoding performance in IED as mentioned in [8] as cog, because more erasure symbols are removed in the inner product of the received vector and the rows with the minimum Hamming weight of H .

D. ANALYSIS OF DECODING COMPLEXITY OF TS-AGD IN THE ERASURE CHANNEL
Decoding complexity of TS-AGD in the erasure channel is analyzed as follows. In the decoding stage, it requires a large number of iterations and high decoding complexity. In the preprocessing stage, TS-AGD derives the order of decoding by computing cross-correlation of the parity check sequence and erasure sequence. TS-AGD decodes in order of more successful decoding cases of cyclic shift values τ but the conventional AGD decodes for all the possible τ without considering the decoding order.
We analyze the decoding complexity using integer addition and XOR operation. Complexities of each integer addition and each XOR operation between two binary integer values are considered as 1, respectively and then integer additions and XOR operations among l values are done by l − 1 serialized operations between two integers in the binary form. The complexity of preprocessing stage will be counted by occurrence of integer additions as in Fig. 7 and the complexity for search of τ s with high correlation values is ignored because it has low complexity. For each iteration of decoding process, both CNU and VNU operations are performed, where CNU operation requires (d c − 1)(n − k) integer additions as in Fig. 8 and VNU operation requires (d c − 2) XOR for each decodable erasure symbol as in Fig. 9. In order to compute the decoding complexity by the numerical analysis, we consider XOR and integer addition operations as 1, respectively, where numerical approach will be used for the following discussions including Figs. 11, 13, and 16 in Section IV.

E. TS-AGD IN THE ERROR CHANNEL
In this subsection, we propose a new method of lowcomplexity TS-AGD in the error channel motivated by OSD. In order to use TS-AGD in the erasure channel, we treat n − k bits except MRI bits as erasures regardless of their linearly independent columns. Then, TS-AGD decodes the codeword until decoding successfully or reaching a stopping set. If stopping set is found, the decoder treats one of the remaining erasures with the maximum reliability as nonerasure and it can proceed to erasure decoding. In this way, the decoder always obtain a decoded codeword.
Generally, many of the n − k columns are linearly dependent and thus, linearly independent n − k columns after many iterations in OSD should contain several less reliable bits as MRI bits. Instead, we consider an alternative method to decode the received codewords using the n − k bits as erasures and change the erasure bit to non-erasure bit only when stopping set exists after iterations.
For complexity of TS-AGD, it is definitely lower than OSD. As aforementioned in Section II-B, the operations related with high decoding complexity of OSD are matrix inversion and the iterations by searching n − k linearly independent columns. For the matrix inversion with O(n 3 ), TS-AGD is lower because it is based on the iterative decoding with O(n) for iterations. Also, the iterated operation by searching n − k linearly independent columns for matrix   inversion is not required in the TS-AGD. For FER performance in the error channel, TS-AGD has comparable performance to OSD for the codes that TS-AGD has near-ML performance such as extended Golay and high-rate BCH codes, which will be given in the numerical analysis of the next section.

IV. NUMERICAL ANALYSIS FOR TS-AGD
In this section, the proposed TS-AGD is shown to be near-ML performance for some cyclic codes in the erasure channel such as extended Golay codes and double and triple-error correcting BCH codes. For extended Golay codes, the proposed modification of parity-check matrix can achieve the decoding performance identical to that of the ML decoder. For doubleand triple-error correcting BCH codes, AGD and TS-AGD have the near-ML decoding performances. Regarding decoding complexity, additional complexity by preprocessing stage for TS-AGD may increase the decoding complexity but for long codelength, overall decoding complexity of TS-AGD becomes lower than that of AGD.

A. (24, 12, 8) EXTENDED GOLAY CODE
Extended Golay code is not a cyclic code, but it is cyclic except for the last parity bit. Thus, we can apply the AGD and the proposed TS-AGD. For comparison, we will use paritycheck matrix H [24,12], * in [8].
A systematic parity-check matrix H sys is constructed where the 12 × 12 submatrix by the first 12 columns is identity matrix, i.e., parity check sequence of H sys is s p (t) = (111111111111000000000000). The modified parity-check matrix based on the three proposed criteria can be given as 100010000000011000111010  010010100100001010100010  001000000010011010100110  000100100110011000010010  000011100010001000001110  000010110000010010010110  000010001110000000110110  000000100101010000101110  000000100010100010111010  000010000110010110001010  000000000100001011011110 where the first 11 standard column vector indices are determined by the cyclic difference set with parameters (23, 12, 5) and the last standard vector is located in the extended bit. The last row of H m has the Hamming weight of 12, which is larger than the minimum Hamming weight 8. Thus, we can further modify it by replacing the last row by sum of the first row and the last row as 100010000000011000111010  010010100100001010100010  001000000010011010100110  000100100110011000010010  000011100010001000001110  000010110000010010010110  000010001110000000110110  000000100101010000101110  000000100010100010111010  000010000110010110001010  000000000100001011011110 where the last row has the minimum Hamming weight 8 but the first column is not a standard vector. The further modifi- cation is done by replacing the i-th row with the sum of the i-th row and the last row of H m , 1 ≤ i ≤ 11 and the last row with the first row of H m as In In the (24, 12, 8) extended Golay code, any of the modified parity check matrices cannot achieve the same performance as that of the ML decoder. However, the TS-AGD by adding redundant check equations to H B can give us the same decoding performance as the ML decoder, which is given as where H A is a submatrix composed of nine rows out of the first 11 rows of H A . Fig. 10 shows the relationship among the various modified parity check matrices.  Fig. 11, where H C is the highest decoding complexity due to additional rows of the parity-check matrix. For the number of iterations of TS-AGD, H m and H A are lower than others because |S p | = n − k, which  is larger than the others. For decoding complexity, decoding complexity of TS-AGD is lower than that of AGD for low erasure probabilities. Among the modified H 's of TS-AGD, the decoding complexity is proportional to the number of iterations except H C .

B. HIGH-RATE BINARY BCH CODES
Binary primitive BCH codes are widely used due to large designed distance and guaranteed decoding performance for certain number of errors and erasures. However, BCH codes require inherently high decoding complexity and their performance is degraded for large n and k. VOLUME 8, 2020 The proposed TS-AGD can overcome the disadvantages of BCH codes by the low-complexity decoding with improved performance compared to AGD. Here, the proposed TS-AGD for the double-error correcting (n, k, d) = (63, 51, 5), (127, 113, 5), (255, 239, 5) and triple-error correcting (63, 45, 7), (127, 106, 7), (255, 231, 7) BCH codes is numerically analyzed in the erasure and error channel. In general, s p (t) of the BCH code is generated by the cyclic difference set but there are some cases that the cyclic difference set does not exist for the parameters of the BCH code. Instead S p can be constructed using the union of cyclotomic cosets of the finite field as an alternative construction method. In this case, s p (t) does not have constant but relatively low values of autocorrelation. Thus, this construction method of s p (t) also results in good decoding performance. For (63, 51, 5) and (63, 45, 7) BCH codes, S p is constructed using cyclotomic cosets whose coset leaders are {α, α 3 } and {α, α 3 , α 11 }, where α is a primitive element of F 2 6 . Similarly, S p 's of (127, 113, 5) and (127, 106, 7) BCH codes use cyclotomic cosets whose coset leaders are {α 3 , α 5 } and {α 3 , α 5 , α 11 }, where α is a primitive element of F 2 7 . Lastly, S p 's of (255, 239, 5) and (255, 231, 7) BCH codes use cyclotomic cosets whose coset leaders are {α 7 , α 11 }, and {α 7 , α 11 , α 13 }, where α is a primitive element of F 2 8 . For comparison of the codes with n = 63, 127, FER performance of ML is used as a numerical calculated values by Monte-Carlo method. However, we use a (260, 234) regular LDPC code for comparison of n = 255 because it requires high complexity to induce the FER performance of ML using Monte-Carlo method.

1) DOUBLE-ERROR CORRECTING BCH CODES
Here, we analyze FER performance and decoding complexity of AGD and TS-AGD for double error correcting BCH codes in the erasure channel. For the modification of paritycheck matrix, H m and H sys are compared, where the optimization of the upper bound by the second criterion leads to improve the decoding performance for these codes. First, FER performance is given in Fig. 12 showing that there is little difference among H m , H sys , and ML. Note that FER performance of AGD and TS-AGD are identical because both of them try all the cyclic shifted cases before they declare decoding failure. However, decoding complexity in Fig. 13 shows that H m has lower decoding complexity than H sys and their gap becomes larger for long codelength. For the decoding complexity of AGD and TS-AGD, TS-AGD has lower complexity than AGD and their gap becomes larger for long codelength. Therefore, the proposed TS-AGD with H m has lowest decoding complexity for these codes.
In the error channel, FER performance of OSD, TS-AGD, and HDD of (127, 113) BCH code is given in Fig.14, where TS-AGD has better performance than HDD but little degraded performance than OSD. However, TS-AGD can decode the code with lower complexity and thus, TS-AGD can be used for the lower complexity applications.

2) TRIPLE-ERROR CORRECTING BCH CODES
For FER performance of the triple-error correcting BCH codes, Fig. 15 shows that there is little difference among H m , H sys , and ML, but their gap is larger than that of the double-error correcting BCH codes. Note that FER performance of AGD and TS-AGD is identical because both of them try to all the cyclic shifted cases before they declare decoding failure. However, decoding complexity in Fig. 16    shows that H m has lower decoding complexity than H sys and their gap becomes larger for long codelength. For the decoding complexity of AGD and TS-AGD, TS-AGD has lower complexity than AGD and their gap becomes larger for long codelength. Therefore, the proposed TS-AGD with H m has lowest decoding complexity for these codes.
In the error channel, FER performance of OSD, TS-AGD, and HDD of (63, 45) BCH code is given in Fig. 17. TS-AGD has better performance than HDD but worse performance than OSD in low E b /N 0 . However, FER performance of HDD and TS-AGD outperforms that of OSD in high E b /N 0 contrary to (127, 113) BCH code because less reliable bits are included in k MRI bits in order to satisfy linear independence of the corresponding columns as n − k is larger. On the average, OSDs of (127, 113) and (63, 45) BCH codes treat (k + 1.588)-th and (k + 1.76)-th reliable bit as least reliable MRI bit. In contrary, TS-AGD firstly uses most reliable k bits and substitute other bits only when the stopping set exists and thus, TS-AGD is less influenced by less reliable bits. Also, TS-AGD can decode the code with lower complexity and thus, TS-AGD can be used for the lower complexity applications.

V. CONCLUSION
In this paper, a new TS-AGD for binary cyclic codes was proposed by modifying their parity-check matrix. Modification criteria of the parity-check matrix was proposed and the proposed TS-AGD algorithms were shown to be able to reduce the average number of iterations and the decoding complexity. The extended Golay and BCH codes were considered for the proposed TS-AGD algorithms, where they achieve the near-ML and OSD performances with low decoding complexity in the erasure and error channels.

APPENDIX PROOF OF MAXIMIZATION OF THE UPPER BOUNDS IN (10) AND (11)
The objective functions to be minimized are as follows: 1) For R H (τ ) = |S e |, the objective function is It is easy to check that the following constraints are used for optimization: (i) For all τ 1 and τ 2 , 0 ≤ a(τ 1 , τ 2 ) ≤ n − |S p |.