 Research
 Open Access
 Published:
Lowcomplexity decoding of LDPC codes using reducedset WBFbased algorithms
EURASIP Journal on Wireless Communications and Networking volume 2020, Article number: 180 (2020)
Abstract
We propose a method to substantially reduce the computational complexity of iterative decoders of lowdensity paritycheck (LDPC) codes which are based on the weighted bitflipping (WBF) algorithm. In this method, the WBFbased decoders are modified so that the flipping function is calculated only over a reduced set of variable nodes. An explicit expression for the achieved complexity gain is provided and it is shown that for a code of block length N, the decoding complexity is reduced from O(N^{2}) to O(N). Moreover, we derive an upper bound for the difference in the frame error rate of the reducedset decoders and the original WBFbased decoders, and it is shown that the error performances of the two decoders are essentially the same.
Introduction
The iterative decoding schemes for lowdensity paritycheck (LDPC) codes fall into three main categories: softdecision methods such as belief propagation (BP) algorithm, harddecision methods such as bitflipping (BF) algorithm, and hybrid methods such as weighted bitflipping (WBF) algorithm [1, 2], with softdecision and harddecision methods having the highest and the lowest complexity, respectively. The BP algorithm provides the best performance at the cost of a high implementation complexity [3]. The error performance of BF decoding is inferior to that of the BP, but it is faster and much easier to implement [1, 4, 5]. Moreover, harddecoding methods like BF are the only option in some applications, such as highthroughput power fiberoptic communications [6, 7], NAND storage systems [8, 9], and McEliece cryptosystem [10],due to hardware limitations.
The WBF decoding algorithm offers a good error performance/decoding complexity tradeoff and enjoys an improved performance gained by introducing some measure of reliability (soft information) in the BF decoding algorithm [2]. The WBF algorithm flips some bits in each iteration based on the value of a flipping function and repeats the algorithm until all the paritycheck equations are satisfied or the maximum number of iterations is reached. The performance of the WBF method can be further improved by modifying the flipping function [11–19], and flipping several bits in each iteration can speed up the convergence of decoding [20–23]. However, calculating the flipping function for each variable node requires realnumber arithmetic and its computational complexity is much higher than the harddecision BF decoding.
In this paper, we propose a method to significantly reduce the computational complexity of WBFbased decoders with a negligible loss in the error performance. Our proposed method, named reducedset (RS) WBFbased decoding, reduces the complexity of obtaining the flipping function to a great extent and can be applied to all WBFbased decoders. Although simulation results do not show any loss in the error performance, we present an upper bound for the difference between the frame error rate (FER) of WBFbased decoders and their RS counterparts.
The rest of this paper is organized as follows. In the next section, some preliminaries about LDPC codes and WBFbased decodings are reviewed. In Section 3, we present the proposed algorithm to reduce the decoding complexity, followed by complexity and error performance analysis. Simulation results are presented in Section 4, and Section 5 concludes the paper.
Methods/experimental
The research content of this paper is mainly theoretical derivation and analysis, and specific experimental verification will be carried out in a future research.
WBFbased algorithms
In this section, we briefly review some preliminaries about LDPC codes and WBFbased decoders.
Preliminaries
A (d_{v},d_{c})regular LDPC code has a sparse paritycheck matrix whose column and row weights are exactly d_{v} and d_{c}, respectively. An LDPC code is irregular if its rows and/or columns have different weights. An LDPC code can be represented by a bipartite (Tanner) graph which consists of two subsets of nodes, namely, variable nodes (or bit nodes) and check nodes. Variable nodes represent the bits of the codeword and check nodes correspond to the paritycheck equations. An edge connects the nth variable node to check node m if and only if bit n is checked by the checksum m. The set of bits participating in the mth check (i.e., the set of variable nodes connected to the check node m in the Tanner graph) is denoted by \(\mathcal {N}(m)\). Similarly, \(\mathcal {M}(n)\) denotes the set of checks involving the nth bit. Hence, for an LDPC code with an M×N paritycheck matrix H=[h_{mn}], we have \(\mathcal {N}(m)=\left \{n:h_{mn}=1\right \}\) and \(\mathcal {M}(n)=\left \{m:h_{mn}=1\right \}\).
Let \({\mathbf {c}} = \left (c_{1}, c_{2}, \dots, c_{N}\right)\) be a codeword of a binary LDPC code C of block length N. After BPSK modulation, the transmitted sequence will be \({\mathbf {x}} = \left (x_{1},x_{2},\dots,x_{N}\right)\), with \(x_{i} = 2c_{i}1, i= {1,2,\dots,N}\). Assuming an additive white Gaussian noise (AWGN) channel, \({\mathbf {y}} = (y_{1},y_{2},\dots, y_{N})\) is the realvalued sequence at the output of the receiver matched filter, where y_{i}=x_{i}+n_{i}, with n_{i}’s being independent zeromean Gaussian random variables with variance σ^{2}. Let \({\mathbf {z}} = (z_{1}, z_{2}, \dots, z_{N})\) be the binary harddecision sequence obtained from y (i.e., z_{i}=1 if y_{i}>0 and z_{i}=0 if y_{i}≤0). The syndrome vector \({\mathbf {s}} = (s_{1}, s_{2}, \dots, s_{M})\) is then given by s=zH^{T}, i.e., the syndrome component s_{m} is computed by the checksum
Vector s is zero if and only if all paritycheck equations are satisfied and z is a codeword in C.
WBFbased decoding algorithms
The bitflipping (BF) algorithm is an iterative harddecision decoding algorithm that computes all the paritycheck equations and then flips a group of bits per iteration that is contained in a preset number of unsatisfied checksums. The weighted bitflipping (WBF) algorithm improves the performance of the BF decoding by including some reliability measures of the received symbols in their decoding decisions [2]. Reliability of all the paritycheck equations are computed via
and the flipping function is defined as
The WBF decoder first computes the reliability of all the paritycheck equations from (2). Next, the decoding algorithm is carried out as follows.

For \(m=1,2,\dots,M\), compute the syndrome components from (1). Break the algorithm if all the paritycheck equations are satisfied (s=0) or a preset maximum number of iterations is reached. Otherwise, continue.

For \(n=1,2,\dots,N\), compute the flipping function E_{n}.

Flip the bit z_{n} for n=argmax_{1≤n≤N}E_{n}, and go to Step 1.
In what follows, we review several WBFbased methods that improve the standard algorithm. In [12], the modified WBF (MWBF) is proposed, considering not only the reliability of the syndrome sequence for computing the flipping function, but also the reliability information of the received symbol. The flipping function in the MWBF is modified as
where the weighting factor a can be determined via MonteCarlo simulation at different SNRs. Reliabilityratio based WBF (RRWBF) proposed in [13] introduces a new quantity called the reliability ratio R_{m,n} and modifies the flipping function as
Lee et al. [14] proposed a new version of the RRWBF algorithm which simplifies the calculation. The flipping function in improved RRWBF (IRRWBF) is given by
where \(T_{m} = {\sum \nolimits }_{n \in \mathcal {N}(m)} y_{n}.\) In [15], Jiang et al. proposed the improved MWBF (IMWBF) algorithm where in computing the flipping function, the reliability of checksums involving a given bit should exclude that bit, and the reliability computation in (2) should be revised as \(w^{\prime }_{n,m} = \min _{i \in \mathcal {N}(m)/n} y_{i}, n\in \mathcal {N}(m),\) and the flipping function as
For a special class of highrate quasicyclic LDPC codes, LiuPados WBF (LPWBF) [16] and its improved version ShanZhaoJiang LPWBF (SZJLPWBF) [17] improve the computation of syndrome reliability and perform even better than the IMWBF algorithm at the high SNR regime.
The standard WBF algorithm selects and flips one bit in each iteration. However, to increase the speed of decoding, it can select and flip multiple bits in each iteration. In [20], a threshold adaptation scheme is applied to multibit flipping decoding algorithm, where in each iteration, variable nodes with flipping function greater than a predefined threshold are selected and flipped. If no flipping occurs, the threshold is reduced and the algorithm continues. A parallel version of IMWBF (PIMWBF) algorithm is proposed in [21] that converges significantly faster and often performs better than IMWBF. The threshold for PIMWBF must be optimized by simulation in each iteration. The proposed multibit algorithm in [22] flips multiple bits in each iteration based on a certain threshold that should be optimized by simulation, but the maximum number of bits that are to be flipped in an iteration is restricted. The adaptiveweighted multibitflipping (AWMBF) algorithm proposed in [23] adjusts the threshold in each iteration as
where w_{H}(s) denotes the Hamming weight of the syndrome vector s and \(E_{\max } = {\max } \ E_{n}, n = 1, \dots, N\). The flipping function used in AWMBF is the same as the flipping function proposed for MWBF (i.e., Eq. (4)). In AWMBF, the threshold in each iteration has a closedform expression and there is no need for timeconsuming simulations to determine the optimum thresholds. In this paper, we will use the AWMBF algorithm in simulations for multibit flipping decoders.
Recently, a twobit WBF (TBWBF) decoder was proposed in [24] for the binary symmetric channel (BSC) that produces reliability bits for both the bitdecision results at variable nodes and the syndrome values at check nodes and exchanges the reliability bits between variable and check nodes as the decoding proceeds.
Reducedset lowcomplexity decoders
In this section, we propose a method to significantly reduce the computational complexity of all WBFbased algorithms. The complexity of the decoder is also analyzed and an upper bound for its FER is presented.
Proposed algorithm
All of the WBFbased decoders use a flipping function E_{n} to select the bits to be flipped. These decoders compute the flipping function for all variable nodes in each iteration to detect the erroneous bits in the received sequence. As the flipping function calculation requires realnumber arithmetic, the computational complexity of WBFbased algorithms is essentially due to this part. The main idea behind our proposed algorithm is to reduce the number of flipping function calculations in each iteration by considering only those variable nodes which are likely to be in error. Denote this set of variable nodes in the lth iteration by \(\mathcal {A}_{l}\). In the first iteration, \(\mathcal {A}_{1}\) contains only the variable nodes that are connected to the unsatisfied check nodes. In the next iterations, \(\mathcal {A}_{l}\) contains the variable nodes that participate in the paritycheck equations involving the flipped bits in the last iteration. \(\mathcal {A}_{l}\) can thus be written as:
where \(\mathcal {B}_{1} = \left \{m: s_{m} \neq 0 \right \}\) and \(\mathcal {B}_{l} = \left \{m: m\in \mathcal {M}(n_{l1})\right \}\) for l≥2. n_{l−1} is the index of the flipped bit in the (l−1)th iteration. Note that a variable node might appear in several iterations of the decoding process, and variable nodes in the (l−1)th iteration are not excluded in the lth iteration.
A reducedset (RS) WBFbased algorithm is summarized below.

For \(m=1,2,\dots,M\), compute the syndrome components in (1). Break the algorithm if all the paritycheck equations are satisfied (s=0) or a preset maximum number of iterations is reached. Otherwise, continue.

Compute the flipping function E_{n} for \(n \in \mathcal {A}_{l}\) where \(\mathcal {A}_{l} = \left \{n: n \in \mathcal {N}(m), m \in \mathcal {B}_{l} \right \}\). If \(l=1, \mathcal {B}_{1} = \{m: s_{m} \neq 0 \}\), otherwise for \(l\geq 2, \mathcal {B}_{l} = \{m: m\in \mathcal {M}(n_{l1}) \}\). Update \(\mathbb {A}\) as \(\mathbb {A}\triangleq \bigcup \limits _{i=1}^{l} \mathcal {A}_{i}\).

Flip bit \(z_{n_{l}}\) for \(n_{l} = \text {argmax}_{n \in \mathbb {A}} E_{n}\). Increase the iteration number l by one and go to Step 1.
The standard WBF algorithm flips one bit in each iteration. In the following remark, the reducedset singlebit WBFbased algorithm is extended to reducedset multibit WBFbased algorithm.
Remark 1
In multibit WBFbased algorithms, the decoder selects and flips multiple bits in each iteration. In the first iteration, the set of variable nodes which are likely to be in error, i.e., the set of variable nodes that are connected to the unsatisfied check nodes, is the same for singlebit and multibit WBFbased decoders. Let γ_{l} denote the number of the flipped bits in the lth iteration and \(n_{i,l},\; i=1,\dots,\gamma _{l}\), denote the index of the flipped bits in the lth iteration. In multibit WBFbased algorithms, for l≥2 the set \(\mathcal {B}_{l}\) is modified as \(\mathcal {B}_{l} = \left \{m: m\in \bigcup \limits _{i=1}^{\gamma _{l1}} \mathcal {M}\left (n_{i,l1}\right)\right \}\).
Due to the sparsity of the LDPC paritycheck matrix H, the number of bits that participate in each check is small compared to N. So, each erroneous bit causes a small number of unsatisfied checksums, and for each unsatisfied checksum, there is a small number of bits that the decoder must decide whether to flip or not. Therefore, even for moderate values of SNR, the set of candidate variable nodes in each iteration constitutes a very small subset of all variable nodes which, in turn, leads to a substantial reduction in the computational complexity of step 2 of the WBFbased decoding algorithms. In the following subsections, we derive explicit expressions for this reduction in complexity and show that the incurred loss in the performance is indeed intangible.
Computational complexity analysis
In this subsection, we obtain the average number of flipping function calculations as a complexity measure of the RS decoding algorithms and show how the computational complexity of any of the WBFbased decoders is substantially reduced using the proposed algorithm.^{Footnote 1}
We now present a theorem.
Theorem 1
Consider a (d_{v},d_{c})regular LDPC code. For any of the singlebit and the multibit RS decoders, the average number of flipping function calculations in the first iteration (i.e., the average cardinality of \(\mathcal {A}_{1}\)) is
where p_{0} is the probability that a bit is received in error and \(\beta = \frac {1}{2}\left (1\left (12p_{0}\right)^{{d_{c}}1}\right)\). For the next iterations, i.e., l≥2, the average number of flipping function calculations for the singlebit RS decoders is given by
and for the multibit RS decoders it is upper bounded as
where γ_{l} is the number of flipped bits in the lth iteration.
Proof
We first obtain the cardinality of \(\mathcal {A}_{1}\), the selected set in the first iteration. As noted in Remark 1, the set of variable nodes that are connected to the unsatisfied check nodes in the first iteration is the same for both singlebit and multibit RS decoders. So, the cardinality of set \(\mathcal {A}_{1}\) (i.e., L_{1}) is the same for both singlebit and multibit RS decoders.
We define the indicator function \(\mathcal {I}_{i}\) of the ith variable node as
for 1≤i≤N. The cardinality of \(\mathcal {A}_{1}\), denoted by l_{1}, is a random variable and can be written as \(l_{1} = {\sum \nolimits }_{i=1}^{N} \mathcal {I}_{i}\). So, the average number of variable nodes in set \(\mathcal {A}_{1}\) is obtained as
and we have
The event \(i \notin \mathcal {A}_{1}\) occurs when all checks involving the ith bit are satisfied. Let μ_{m} be the event that the mth check involving the ith bit is satisfied. The ith bit participates in d_{v} checks, hence
where \(\mathcal {E}\) denotes the set of all erroneous bits in the received sequence. We assume that the code is 4cycle free, i.e., no two code bits are checked by the same two parity constraints. This structural property is imposed on almost all LDPC code constructions and is very important to achieve good error performance with iterative decoding [5, 25, 26]. If there are no cycles of length 4 in the Tanner graph, no two checks share more than one variable node. In other words, if more than one variable node appear at two different checksums, there will be at least one cycle of length 4 in the Tanner graph. On the other hand, in the first iteration, values of variable nodes are received directly from the channel output. Thus, in the first iteration, all variable nodes are independent (as the noise was assumed to be white). Therefore, assuming a 4cycle free graph, all checks involving the ith bit do not share any other bits, and conditioned on the ith bit all these checks will be independent in the first iteration. Thus,
\(\Pr \left \{\mu _{m} i \in \mathcal {E} \right \}\) is the probability that the number of erroneous bits participating in the mth check (except the ith bit) is an odd number and is given by [4]
Similarly, \(\Pr \left \{\mu _{m} i \notin \mathcal {E} \right \} = 1\beta \). Therefore,
Using equations (14), (15) and (19), we have
For \(l\geq 2, \mathcal {A}_{l}\) contains all the variable nodes that participate in the paritycheck equations involving the flipped bit in the last iteration. The number of variable nodes that participate in the paritycheck equations involving a given variable node is d_{v}(d_{c}−1) (see Fig. 1). Singlebit RS decoders flip only one bit in each iteration. Therefore, in this case, the cardinality of set \(\mathcal {A}_{l}\) for l≥2, will be
In multibit RS decoders, γ_{l} bits are flipped in the lth iteration, and for each flipped bit in the last iteration, the RS decoder must update d_{v}(d_{c}−1)+1 flipping functions. In general, paritycheck equations involving flipped bits in the last iteration may have some bits in common. So, the cardinality of the set \(\mathcal {A}_{l}, l \geq 2\), in multibit RS decoders is upper bounded as
□
End of Proof.
Plotted in Fig. 2 is L_{1} versus SNR for (3,6) and (4,32)regular codes. It is seen that the result of (20) matches the average number of variable nodes in \(\mathcal {A}_{1}\) obtained from MonteCarlo simulation.
If k is the number of iterations required in the decoding process, by using (22), the number of flipping function calculations in multibit RS decoders can be upper bounded as^{Footnote 2}
Assume that the decoder is in the waterfall region and is able to detect and correct some erroneous bits in each iteration and eventually corrects all of them. Therefore, \({\sum \nolimits }_{l=2}^{k} \gamma _{l1}\) is equal to the number of erroneous bits in the received sequence. For large block sizes, the number of erroneous bits is approximately Np_{0} and it can be easily verified that for p_{0}≪1 and large N, we have
For singlebit RS decoder, the inequality in Eq. (24) becomes equality (cf. (21) and (22)). From Eq. (24), it can be seen that the computational complexity is linear in the codeword length. This fact was checked by simulation and the results are presented in Table 1. The simulation results for several (3,6)regular LDPC codes of different codeword lengths are tabulated along with the theoretical results. The parity check matrices of the codes are given in [27], and the SNR is considered to be 6 dB. We observe that both the singlebit and multibit RS decoders need essentially the same average number of flipping function calculations, and the derived upper bound for L in (24) is quite tight. As expected, as N increases, the upper bound obtained from Eq. (24) get closer to the simulation results.
On the other hand, original WBFbased decoders compute the flipping function for all N variable nodes in each iteration. So, the number of flipping function calculations for WBFbased decoders is approximately kN. So, the ratio of the average number of flipping function calculations for WBFbased and RS decoders—which can be considered as the complexity gain—is lower bounded as
By assuming that the decoder is able to detect and correct one erroneous bit in each iteration, in singlebit decoders, the average number of iterations required to obtain the correct codeword is the same as the number of erroneous bits in the received sequence, i.e., k=Np_{0}, and the inequality in equation (25) becomes equality (cf. (21) and (22)). It should also be noted that the complexity gain is higher for a sparser paritycheck matrix.
For example, for a (3,6)regular code with N=10^{5} and at SNR=6 dB, G_{c} for the singlebit and multibit RS decoders is obtained as 3125 and 1279, respectively. Although the complexity gain is smaller for multibit RS decoders, it is still significant.
Performance analysis
To evaluate the performance of the proposed RS algorithm and compare it with the original WBFbased decoder,^{Footnote 3} we first note that if \(\mathbb {A}\triangleq \bigcup \limits _{i} \mathcal {A}_{i}\), the selected set by RS decoders, which contains all erroneous bits, both decoders will have the same performance. However, in general, some erroneous bits may happen not to be in the selected set and thus the RS decoders can never detect and correct them. Specifically, an erroneous bit will not be included in \(\mathcal {A}_{1}\) if all paritychecks in which this bit participates are satisfied (i.e., if these checks involve an even number of errors). This bit may never enter \(\mathbb {A}\) in the next iterations, and so the RS decoder will totally miss it. Therefore, the performance of RSbased decoders will generally be inferior to that of the original decoders. However, in the following theorem, we show that the difference between the FER of original WBFbased decoders P_{O} and RS decoders P_{RS} is indeed negligible.
Theorem 2
The difference between the FER of the original WBFbased and RS decoders for a (d_{v},d_{c})regular LDPC code is upper bounded as
where \( T=\left \{\theta ' \mid d_{v}\leq \theta '\leq \min \left \{{d_{v}}({d_{c}}1), \varepsilon _{0}1\right \} \:,\: \theta '\overset {2}{\equiv } d_{v} \right \},\)^{Footnote 4} and
with X_{i}’s being nonnegative integers. The sets Ψ_{θ} and Ψθ′ are defined as
and
Proof
Let b and \(\hat {{\mathbf {b}}}_{RS}\) be the transmitted message and the estimated message by the RS decoder, respectively. The FER of the RS decoder can then be written as
where \(\mathcal {E} = \left \{{j}_{i}, i=1,2,\dots,\varepsilon \right \}\) is the set of indices of erroneous bits in the received sequence and \(\mathbb {A}\triangleq \bigcup \limits _{i} \mathcal {A}_{i}\) is the selected set of variable nodes in the decoding process. By defining \(\hat {{\mathbf {b}}}_{O}\) as the estimated sequence by the original WBFbased decoder, we have
Therefore, using the Bayes rule,
By defining ΔP=P_{RS}−P_{O}, we have
The event \(\mathcal {E} \nsubseteq \mathcal {A}_{1}\) is the event that some erroneous variable nodes may not be in the selected set \(\mathcal {A}_{1}\). The number of erroneous bits ε in the received sequence (i.e., the cardinality of set \(\mathcal {E}\)) is a random variable with binomial distribution B(ε,p_{0}), i.e.,
Therefore, we have
By defining Θ as the number of erroneous bits participating in checks that involve bit j_{1}, we have
where K= min{d_{v}(d_{c}−1),ε_{0}−1}. For a (d_{v},d_{c})regular code
To compute \(\Pr \left \{{j}_{1} \notin \mathcal {A}_{1}  \Theta = \theta, \varepsilon =\varepsilon _{0}\right \}\), we define X_{i} as the number of erroneous bits participating in the ith check that involves bit j_{1}. Figure 1 shows an example in which d_{v}=3,d_{c}=6,θ=3 and the erroneous variable nodes are painted gray. It is seen that X_{1}=1,X_{2}=0 and X_{3}=2. Noting that a check is satisfied if an even number of erroneous bits are involved in it, and by defining
and
we have
From the definition of set Ψθ′, if d_{v} is an even (odd) number, then P_{1}(θ)=0 when θ is odd (even). Moreover, P_{1}(θ)=0 for θ<d_{v}. Therefore, using (29)(34), the upper bound of ΔP is obtained as (26), and from (28) the FER of the RS decoders can be upper bounded as
□
End of Proof.
The upper bound presented in Theorem 2 is general and is applicable to both singlebit and multibit WBFbased decoders. Indeed, as shown above, the difference between the FER of the original WBFbased decoders and their RS counterparts (ΔP) is upper bounded by the probability that some erroneous variable nodes may not be in the selected set \(\mathcal {A}_{1}\) in the first iteration (see Eq. (29)), and the set \(\mathcal {A}_{1}\) is the same in singlebit and multibit WBFbased decoders.
Remark 2
Noting that P_{1}(θ)<1, from (26) we have
By changing the order of the summations and modifying their bounds, we have
Making the substitution ε0′=ε_{0}−θ−1 and using \({\sum \nolimits }_{k = 0}^{n} {n \choose k} p^{k} (1p)^{nk} = 1\), after some simplification, (37) becomes
From the above inequality, it is clear that in the high SNR regime ΔP tends to zero at least as \(p_{0}^{d_{v}+1}\), and the upper bound will be tighter for a code with a larger degree of the variable nodes.
Results and discussion
In this section, we compare WBFbased and reducedset (RS) decoders in terms of computational complexity and the probability of error. In the simulations, we use (3,6) and (4,32)regular LDPC codes with rates \(\frac {1}{2}\) and \(\frac {7}{8}\), respectively. The paritycheck matrix for the (3,6)regular code is constructed with the progressive edge growth (PEG) method [28]. For the (4,32)regular code, we use the LDPC code considered in [29] for near earth applications which is a quasicyclic code. The maximum number of iterations is set to 100 in all simulations.
First, an analysis of the computational complexity of the decoders based on the average number of flipping function calculations (L) is presented. Plotted in Fig. 3 is L in the RS decoder versus SNR for the (3,6) and (4,32)regular LDPC codes with codeword length 10000 and 8176, respectively. Average number of flipping function calculations obtained by MonteCarlo simulation for singlebit and multibit WBFbased decoders, along with the upper bound of (24) are shown in this figure. As expected, in the high SNR regime, the upper bound becomes quite tight for both singlebit and multibit decoders.
In Fig. 4, the average number of flipping function calculations is plotted versus SNR for the RS and original WBFbased decoders. Both singlebit and multibit decoders are considered in this figure. As discussed in Section 3.2, the average number of flipping function calculations in singlebit RS and multibit RS decoders are almost the same, and this is confirmed by the results obtained by simulation in Fig. 4. It is clearly seen that using the RS algorithm results in about three orders of magnitude decrease in the decoding complexity in singlebit WBFbased decoders and at least two orders of magnitude decrease in the decoding complexity in multibit WBFbased decoders. Moreover, this reduction in the complexity is higher for the sparser codes (cf. (25)). It should also be noted that the number of flipping function calculations required in original (nonRS) multibit decoders at the medium SNR regime is less than those required in the singlebit decoders, while in the low and high SNR regimes the number of flipping function calculations required in the two decoding algorithms are the same. This behavior can be explained as follows. At low SNRs, neither decoding algorithms are able to correct the errors, so the decoding process continues until the predefined maximum number of iterations is reached, and thus the average number of flipping function calculations is the same for singlebit and multibit WBF decoders. At intermediate SNRs, the convergence speed of the multibit decoding algorithm is higher (i.e., the average number of required iterations is smaller), and therefore, the average number of flipping function calculations for the multibit decoder is lower. At the high SNR regime, either the received sequence is errorfree or the number of erroneous bits is very small. In this case, the number of required iterations in the decoding process in the singlebit and multibit decoders are almost equal. These results are shown in Fig. 5. In this figure, the average number of required iterations versus SNR is plotted to evaluate the convergence of the original and proposed RS singlebit and multibit decoders. As expected, the average number of iterations of the original and RS decoders are nearly identical, i.e., both decoders have similar convergence speeds.
To evaluate the probable performance loss incurred by using the RS decoders (compared to their original WBFbased counterparts), the FER and BER for both the RS and original WBFbased decoders are plotted in Figs. 6, 7, 8, and 9. In these figures, regular (3,6) and (4,32) LDPC codes with codeword length 10000 and 8176 are employed. In Fig. 6, the simulation results for the FER of the (3,6) and (4,32)regular codes for both the RS and original WBFbased decoders, along with an upper bound for the FER of the RS decoder are plotted. In this figure, P_{O} is obtained by MontCarlo simulations for both singlebit standard WBF decoder [2] and multibit AWMBF decoder [23], and the upper bound is given by equation (35). We observe that both the RS and the original WBFbased decoders have essentially the same performance, and the derived upper bound for the RS decoders are quite tight in both singlebit and multibit decoders. As can be seen in Fig. 6, the upper bound of ΔP for (4,32)regular LDPC code is tighter than the upper bound for (3,6)regular LDPC code, because as discussed in Section 3.3, the upper bound is tighter for a code with a larger degree of the variable nodes (recall that ΔP tends to zero at least as \(p_{0}^{d_{v}+1}\)).
In Figs. 7, 8, and 9, the error performance of the proposed RS and the original WBFbased decoders are shown. Figures 7 and 8 show the results over the AWGN channel and Fig. 9 over the BSC. In these simulations, we have employed the singlebit WBF, MWBF, IRRWBF, and TBWBF decoders and multibit AWMBF decoder and their RS counterparts. As expected, the error performance in terms of BER and FER of the original decoders and RS decoders are very close.
Conclusion
We proposed a method to reduce the computational complexity of iterative LDPC decoders based on the WBF algorithm. It was shown that the decoder computational complexity is significantly reduced, especially when the code length is large. Our method performs just as well as the existing WBFbased iterative decoding algorithms and the FER and BER of the two decoders are essentially the same. In the proposed method, instead of all variable nodes, the decoder considers only a subset of variable nodes that are potentially erroneous and thus the complexity of the flipping function calculation is significantly reduced.
Notes
 1.
The number of iterations in the original and the proposed algorithms are the same, but the number of calculations required to obtain the flipping function in a WBFbased decoder has been sharply decreased in the proposed method.
 2.
Note that when the codeword is received correctly, i.e., s=0, there is no need to calculate the flipping function, so L = 0.
 3.
By “original” WBFbased decoders, we mean all WBFbased decoders previously proposed in the literature (to differentiate them from their RS counterparts).
 4.
\( \theta '\overset {2}{\equiv } d_{v} \) means θ^{′} and d_{v} are congruent modulo 2, i.e., both are even or both are odd.
Abbreviations
 LDPC:

Lowdensity paritycheck
 RS:

Reduced set
 AWMBF:

Adaptiveweighted multibitflipping
 BF:

Bit flipping
 WBF:

Weighted bit flipping
 MWBF:

Modified weighted bit flipping
 IMWBF:

Improved modified weighted bit flipping
 RRWBF:

Reliabilityratio weighted bit flipping
 IRRWBF:

Improved reliabilityratio weighted bit flipping
 TBWBF:

Twobit weighted bit flipping
 BER:

Bit error rate
 FER:

Frame error rate
 AWGN:

Additive white Gaussian noise
 BSC:

Binary symmetric channel
 PEG:

Progressive edge growth
References
 1
R. Gallager, Lowdensity paritycheck codes. IRE Trans. Inf. Theory. 8(1), 21–28 (1962).
 2
Y. Kou, S. Lin, M. P. Fossorier, Lowdensity paritycheck codes based on finite geometries: a rediscovery and new results. IEEE Trans. Inf. Theory. 47(7), 2711–2736 (2001).
 3
T. Richardson, M. Shokrollahi, R. Urbanke, Design of capacityapproaching irregular lowdensity paritycheck codes. IEEE Trans. Inf. Theory. 47(2), 619–637 (2001).
 4
S. Lin, D. J. Costello, Error control coding (Pearson Education India, Upper Saddle River, 2004).
 5
W. Ryan, S. Lin, Channel codes: classical and modern (Cambridge University Press, Cambridge, 2009).
 6
A. Sheikh, A. G. i Amat, G. Liva, Achievable information rates for coded modulation with hard decision decoding for coherent fiberoptic systems. J. Light. Technol.35(23), 5069–5078 (2017).
 7
I. Djordjevic, W. Ryan, B. Vasic, Coding for optical channels (Springer, New York, 2010).
 8
F. Ghaffari, B. Vasic, in 2018 IEEE International Symposium on Circuits and Systems (ISCAS). Probabilistic gradient descent bitflipping decoders for flash memory channels (IEEEFlorence, 2018), pp. 1–5.
 9
K. Le, F. Ghaffari, in 2018 15th International MultiConference on Systems, Signals & Devices (SSD). On the use of harddecision LDPC decoders on MLC NAND flash memory (IEEEHammamet, 2018), pp. 1453–1458.
 10
M. Baldi, QCLDPC codebased cryptography (Springer, Heidelberg, 2014).
 11
A. Nouh, A. H. Banihashemi, Bootstrap decoding of lowdensity paritycheck codes. IEEE Commun. Lett.6(9), 391–393 (2002).
 12
J. Zhang, M. P. Fossorier, A modified weighted bitflipping decoding of lowdensity paritycheck codes. IEEE Commun. Lett.8(3), 165–167 (2004).
 13
F. Guo, L. Hanzo, Reliability ratio based weighted bitflipping decoding for lowdensity paritycheck codes. Electron. Lett.40(21), 1356–1358 (2004).
 14
C. H. Lee, W. Wolf, Implementationefficient reliability ratio based weighted bitflipping decoding for LDPC codes. Electron. Lett.41(13), 755–757 (2005).
 15
M. Jiang, C. Zhao, Z. Shi, Y. Chen, An improvement on the modified weighted bit flipping decoding algorithm for LDPC codes. IEEE Commun. Lett.9(9), 814–816 (2005).
 16
Z. Liu, D. A. Pados, in Communications, 2003. ICC’03. IEEE International Conference On, 4. Low complexity decoding of finite geometry LDPC codes (IEEEAnchorage, 2003), pp. 2713–2717.
 17
M. Shan, C. Zhao, M. Jiang, Improved weighted bitflipping algorithm for decoding LDPC codes. IEE Proc. Commun.152(6), 919–922 (2005).
 18
T. C. Y. Chang, Y. T. Su, Dynamic weighted bitflipping decoding algorithms for LDPC codes. IEEE Trans. Commun.63(11), 3950–3963 (2015).
 19
N. Miladinovic, M. P. Fossorier, Improved bitflipping decoding of lowdensity paritycheck codes. IEEE Trans. Inf. Theory. 51(4), 1594–1606 (2005).
 20
J. Cho, W. Sung, Adaptive threshold technique for bitflipping decoding of lowdensity paritycheck codes. IEEE Commun. Lett.14(9), 857–859 (2010).
 21
X. Wu, C. Zhao, X. You, Parallel weighted bitflipping decoding. IEEE Commun. Lett.11(8), 671–673 (2007).
 22
J. Jung, I. C. Park, Multibit flipping decoding of LDPC codes for NAND storage systems. IEEE Commun. Lett.21(5), 979–982 (2017).
 23
T. C. Chen, Adaptiveweighted multibitflipping decoding of lowdensity paritycheck codes based on ordered statistics. IET Communications. 7(14), 1517–1521 (2013).
 24
J. Oh, J. Ha, A twobit weighted bitflipping decoding algorithm for LDPC codes. IEEE Commun. Lett.22(5), 874–877 (2018).
 25
M. Esmaeili, M. Tadayon, T. Gulliver, Lowcomplexity girth8 highrate moderate length QCLDPC codes. AEUInt. J. Electron. Commun.64(4), 360–365 (2010).
 26
M. Gholami, M. Alinia, Z. Rahimi, An explicit method for construction of CTBC codes with girth 6. AEUInt. J. Electron. Commun.74:, 183–191 (2017).
 27
D. MacKay, Encyclopedia of sparse graph codes (2020). http://www.inference.phy.cam.ac.uk/mackay/codes/data.html. Accessed May 2020.
 28
X. Y. Hu, E. Eleftheriou, D. M. Arnold, in Proc. IEEE GLOBECOM Conf.Progressive edgegrowth tanner graphs (IEEESan Antonio, TX, 2001), pp. 995–1001.
 29
CCSDS 131.1O2, Low Density Parity Check Codes for Use in NearEarth and Deep Space Applications. The Consultative Committee for Space Data Systems, Orange book, Issue 2, September 2007 (2007).
Funding
Not applicable.
Author information
Affiliations
Contributions
SH contributed to the main idea and performed the numerical simulations. MF and MD contributed to the mathematical analysis. SH and MF wrote the paper. All authors read and approved the final manuscript.
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.
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
Haddadi, S., Farhang, M. & Derakhtian, M. Lowcomplexity decoding of LDPC codes using reducedset WBFbased algorithms. J Wireless Com Network 2020, 180 (2020). https://doi.org/10.1186/s13638020017915
Received:
Accepted:
Published:
Keywords
 Lowdensity paritycheck (LDPC) codes
 Iterative decoding
 Weighted bitflipping (WBF)