Abstract:
A method for recovery of lost data and for correction of corrupted data transmitted from a sending device to a receiver device, the method comprising the steps: encoding the data by an encoder connected to the sending device, transmitting the data from the sending device to the receiver device via a transmitting device, and decoding the data by a decoder connected to the receiver device, whereby lost and/or corrupted data is recovered during decoding is conducted by solving the system of equations of a parity check matrix H.

Description:
BACKGROUND 
       [0001]    1. Field of the Disclosure 
         [0002]    The disclosure relates to a method for recovery of lost data and for correction of corrupted data which are transmitted from a transmitter device to a receiver device. First, coding of said data is performed by means of an encoder connected to the transmitter device. Subsequently, said data is transmitted from the transmitter device to the receiver device via a transmission system, and said data is decoded preferably through application of a Low Density Parity Check method by means of a decoder connected to the receiver device, wherein lost data and for correction of corrupted data is restored during decoding. 
         [0003]    2. Discussion of the Background Art 
         [0004]    The transmitted data can be audio or video streams, for instance. From a transmitter device which makes these data available, the data is transmitted e.g. to a mobile receiver device. The mobile receiver device can be, for instance, a mobile phone, a PDA or another mobile end device. Alternatively, data can also be transmitted from a transmitter device to a stationary receiver device. 
         [0005]    Examples of standards used for the transmission of data to mobile end devices include DVB-H, MBMS and, to be expected in the near future, DVB-SH. The concept that is proposed works also in point-to-point communications. 
         [0006]    In order to guarantee a good transmission quality, it is required to verify the correct transmission of data or data packets to the receiver device. Various methods exist for recovery of lost data and for correction of corrupted data which were not correctly transmitted to the receiver device. 
         [0007]    A known method for recovery of lost data and for correction of corrupted data is the Low Density Parity Check (LDPC) method or the Low Density Parity Check Code. This method is applied on a so-called erasure channel. Apart from an application by coding on the level of the physical layer, further applications exist in the field of a Packet Erasure Channel (PEC). 
         [0008]      FIG. 1  schematically illustrates an example of the recovery of lost data and for correction of corrupted data according to the state of the art.  FIG. 1  depicts a case where it is desired to transmit a number k of information packets from a transmitter device (left-hand side) to a receiver device (right-hand side). Using a packet-level encoder on the transmitter side, the k information packets and the m parity packets will be assembled into n=m+k codeword packets. On the level of the physical layer, the packets are secured by an error correction code (e.g. a turbo code) and an error detection code (e.g. by a Cyclic Redundancy Check, CRC) so that corrupted packets can be removed. On the levels above the physical layer, packets are either correctly received or are considered lost in that they are erased because the CRC has detected a corrupted packet in the physical layer. Thus, from the layers thereabove, the transmission channel is seen as a so-called erasure channel, the packets representing the transmission units. However, in practice it happens that the CRC fails, leading to errors in packets that are marked as correct. This CRC failures cause a degradation in performance. 
         [0009]    On the receiver side, the received codeword packets are decoded by the packet-level decoder so that the lost packets are recovered and the corrupted data is corrected. 
         [0010]    The recovery of lost data and for correction of corrupted data can be realized by a redundancy of the data. The encoding process handled by the packet-level encoder is usually performed in a bit-wise (or byte-wise) manner using an encoder with a Generic Binary Linear Block Code. The decoding will subsequently be performed by solving the equation system which is defined by the parity-check matrix H of the code. 
         [0011]    In order to recover lost packets, maximum likelihood decoding (ML) can be used to recover the erasures. The problem that each decoder has to face after receiving the symbols from the erasure channel can be described by solving the following equation: 
         [0000]        H     K     ·x     K     =H   K   ·x   K .  (1)
 
         [0012]    Here, x   K   (x K ) denotes the set of erased (correctly received) symbols and H   K   (H K ) the sub matrix composed of the corresponding columns of the parity check matrix. A proper way to solve linear equations is to apply Gaussian elimination. For large block lengths however, this would require lot of operations (e.g. a lot of additions for the specific case of GF(2)) and hence would be too time consuming. Therefore, some smart Gaussian elimination techniques were proposed in DE 10 2009 017 540, that take advantage of the sparseness of the parity check matrix. The goal is to apply time consuming brute-force Gaussian elimination only on a small sub matrix P l . To this end H   K   is put into a lower triangular form just by row and column permutations. However, this step might be blocked by some columns and the corresponding symbols are named reference symbols or pivots. Next, these columns are moved from H   K    to a separate matrix P and the triangularization process can continue. As final outcome all erased symbols can be represented as a combination of reference symbols and hence it is sufficient to apply Gaussian elimination only on parts of P. If the number of pivots is low, P is small and Gaussian elimination is quick. Gaussian elimination has a complexity O(n 3 ) where n stands for the block length here. If for example, the block length of the code is doubled a decoding speed can be expected that is eight times lower (at least for large block lengths). 
         [0013]    The smart Gaussian elimination process is described in more detail now. The matrix H   K    can be divided into different sub-matrices as illustrated in  FIG. 2 . The main parts are A that represents the part in triangular form, B that is the part that has to be put in triangular form, D that is a sparse matrix in the beginning, but will be zeroed out in the end, Z that contains only zeroes and P that is made up of the columns that correspond to the reference symbols. In the end P can be divided into a sparse higher and a dense lower part. Now the following algorithm can be applied:
       1. Search for any degree on row in B. The degree of a row (column) is defined by the number of one entries it contains. At the start B is equal to H   K   . In case no degree one row can be found continue with 4.   2. Apply only column and row permutations to move the single one entry in the degree one row to the top left of B.   3. Increase i and k by one. This way A becomes bigger in each step while the dimension of B shrinks. At the beginning A does not exist.   4. In case no degree one row could be found (cf. step 1) move a defined column of B and Z to P. Thus, also j is decreased by one. At the very beginning P does not exist. Which column of B and Z is chosen to be moved to P is defined by the pivoting strategy.   5. Repeat steps 1 to 4 until dim(P)≠0×l, where l is an arbitrary positive integer number.   6. Zero out D. Now the lower part of P named P l  becomes dense.   7. Perform brute-force Gaussian elimination on P l . Brute-force Gaussian elimination consists of two steps (for the notation cf.  FIG. 3 ):
           a. A forward elimination step to put the matrix P l  in upper triangular form:    We consider the set of equations P l ·x′   K   =s*. Here, x′   K    are only the unknown pivots, thus a subset of the original unknowns x   K   . The vector s* is the corresponding known term which is made up of a multiplication of the corresponding part of the parity check matrix with the known code symbols H* K ·x′ K . Here, the known code symbols x′ K  are a permutation of those in equation (1).    Then we perform (weighted) row additions to put P l  in upper triangular form.    After the forward elimination step, we obtain a modified set of equations H′   K   ·x′   K   =s′. Here, the matrix H′   K   corresponds to P l  in upper triangular form. s′ is the known term, also called syndrome. It is made up of a multiplication of the known code symbols and the corresponding part of the parity check matrix H′ K ·x′ K .   b. A back substitution step, to get the pivots x′   K   .   
           8. If Gaussian elimination was successful, do another back substitution to recover the remaining unknowns. Otherwise, decoding failed.       
 
         [0024]    In case of undetected errors in the codeword symbols, the whole codeword will be corrupted due to the fact that the erroneous codeword symbol (or packet) will be involved in several additions. This leads to an error floor. This is illustrated in  FIG. 6   a , upper most curve, BEEC (no error correction). 
         [0025]    A drawback of the described smart Gaussian elimination process is that it is not able to detect errors, nor correct errors in the codeword, leading to a loss in performance. 
         [0026]    It is an object of the present disclosure to provide for a method for recovery of lost data and for correction of corrupted data which makes it possible to detect multiple errors and to correct single codeword errors. 
       SUMMARY 
       [0027]    The method for recovery of lost data and for correction of corrupted data comprises the following steps:
       Encoding the data by an encoder ( 14 ) connected to the sending device ( 10 )   Transmitting the data from the sending device ( 10 ) to the receiver device ( 12 ) via a transmitting device ( 18 ) and   Decoding the data by a decoder ( 16 ) connected to the receiver device ( 12 ), whereby lost and/or corrupted data is recovered during decoding is conducted by solving the system of equations of a parity check matrix H.       
 
         [0031]    A transmitted codeword is divided on the receiver side into a correctly received part and the erased part (see equation (1)). After that some manipulations (e.g. applying steps of smart Gaussian elimination) are performed. In general the disclosure can be applied on any set of equations as given by equation 1. However, as first step it is required to put the matrix H   K   in a form that the lower part (b−a rows) contains only zero entries. A triangular form is not necessary, but desirable in practice (→back substitution). We obtain a modified set of equations (see  FIG. 4 ): 
         [0000]        H′     K     *x′     K     =H′   K   *x′   K . 
         [0032]    H′   K   corresponds to H   K   after some operations on H   K   (e.g. steps of smart Gaussian elimination), whereby a result of these operations is that the lower part of H′   K   , namely H″   K   , consists of only zeros. x′ K  corresponds to known codeword symbols and x′   K   to some unknown codeword symbols, e.g. as a small fraction of all unknown (e.g. pivots in case of smart Gaussian elimination). 
         [0033]    Note again that the equation denoted here is already a transformation of the equations at the receiver side. Any transformation is allowed. However, as outcome we need a set of equations where the lower part of the matrix on the left side is zero (upper part is not necessarily triangular). 
         [0034]    The inventive method further comprises the following method steps:
       Multiplying correctly received symbols x′ K  with the corresponding part H′ K  of the parity check matrix H, whereby this multiplication yields in a (partial) syndrome s′,   Checking the lower b−a rows of the syndrome s′ for non-zero entries, whereby the rows containing non-zero entries are marked. Only the lower part of the syndrome is exploited, since contradictions can be observed only there.       
 
         [0037]    According to the disclosure the following method steps are applied for correcting a single erroneous symbol in the transmitted codeword:
       Checking which columns H′ K  are involved in the calculation of the identified rows with the non-zero entries in the syndrome s′,   whereby if exactly one column is identified the corresponding symbol in the codeword is identified and   the erroneous symbol in the codeword is corrected by subtraction of the identified non-zero syndrome value from the erroneous symbol. Note that in case of a single error all non-zero entries in the b−a lower rows of the syndrome are equal. If they are not equal, we must assume that multiple errors are present and the algorithm cannot be applied.       
 
         [0041]    The matrix H′   K   on which the inventive method is applied can be any matrix referring to the erased symbols, such as the one specified by equation (1). It is preferred that the inventive method is applied on a submatrix P l  of the parity check matrix H   K   which has been generated according to the method described in DE 10 2009 017 540. 
         [0042]    The main idea for error correction on which the disclosure is based lies in the fact that usually more parity check equations are available than needed to recover the erasures (b&gt;a). These parity check equations can then be used to check for inconsistencies, thus error in the packets. In case no or only a few additional parity check equations are available, the error might remain undetected. However, in this region of erasure probabilities close to capacity the BER/PER curves are not dominated by the residual errors due to falsely marked codeword symbols. A detailed description of a preferred embodiment of the enhanced decoder will be given hereafter. 
         [0043]    Let&#39;s assume no errors for the moment. After performing steps 1.-6. of smart Gaussian elimination, we obtain a dense matrix P l  (cf.  FIG. 2 ) of dimension a×b. In general this matrix contains more rows than columns (a≦b). If the number of rows is less than the number of columns, Gaussian elimination on the matrix is not possible and hence the system of equations cannot be solved. It is assumed that this is not the case. Then, decoding is possible. To do so standard Gaussian eliminations are performed. We start with (weighted) row additions to put the matrix in an upper triangular form (forward elimination step). Then we do a back substitution. Assuming that the matrix P l  is full rank, i.e. rank(P l )==a, we can resolve the erased code symbols, otherwise decoding fails. Since the rank of P l  is a we will obtain b−a equations with all zeros. Note that all row additions (and multiplications) have to be performed also on the known term. 
         [0044]    An efficient implementation of the single error multiple erasure decoding can be formalized in the following way:
       i) Given the set of equations H   K   ·x   K   =H K ·x K , where x   K   (x K ) denotes the unknown (known) vector of symbols and H   K   (H K ) the corresponding part of the original parity check matrix, compute if possible a reduced sized matrix on which brute-force Gaussian elimination can be applied. An efficient implementation for codes having sparse parity check matrices is represented by steps 1.-6. of smart Gaussian elimination. The matrix H   K    is reduced to P l  in  FIG. 2 . Let a be the number of columns and b be the number of rows P l .   ii) Perform forward Gaussian elimination step.
           a. In case rank(P l )=a, apply forward elimination on the matrix P l . We obtain a system of equations H′   K   ·x′   K   =H′ K ·x′ K =s′ (cf.  FIG. 3 ). Keep in mind that H′   K    corresponds to P l  in upper triangular form.
               i. If a==b, no error correction possible.    Continue with step 6.   ii. Otherwise proceed with step 3.   
               b. If rank(P l )≠a stop decoding and signal failure.   
           iii) Detect if the codeword contains errors.
           a. If a==b, no error detection possible. Continue with step 6.   b. If a&lt;b consider the vector s″ made up of the rows a+1, . . . , b of the syndrome vector s′. Note that the elements of the syndrome vector may be packets of a specific size. Check for non-zero entries in s″. Let e be a vector containing the row numbers of the detected non-zero entries in s″.
               i. If e is empty, no errors in the codeword found. Continue with step 6.   ii. If e is not empty, and the non-zero entries of the syndrome do not have the same value, we detected multiple errors. Correction is not possible. Stop decoding and signal decoding failure due to multiple errors.   iii. Otherwise, continue with 4.   
               
           iv) Identify the erroneous symbol. Therefore, consider the sub matrix H″ K  that is made up of the rows a+1, . . . , b of H′ K . Search for columns in H″ K  that have non-zero entries only at the rows specified by e.
           a. If no columns found, no error correction possible. Stop decoding and signal decoding failure due to error in the codeword.   b. If multiple columns found, no error correction possible. Stop decoding and signal decoding failure due to error in the codeword.   c. If a single column found, error correction is possible. Denote the number of the column by t. Continue with next step.   
           v) Perform single error correction. Therefore, take any non-zero entry of the reduced syndrome s′ and subtract it from the code symbol corresponding to the identified column t. For GF(2) and extension fields of GF(2), the subtraction corresponds to an addition.   vi) Correcting the syndrome s′ by the following method steps:
           a. Identify all elements of the syndrome s′ for which the erroneous code symbol has been considered in the calculation   b. Subtract the error pattern obtained from reduced syndrome s″ from the identified rows of s′, whereby the error pattern is given by any non-zero row of s″ in case of a single error.   
               
 
         [0065]    As an alternative it is possible to recompute the syndrome s′ from s′=H′ K *x′ K  considering the corrected value of the code symbol in x′ K . In the approach proposed above s″ is the lower part of s′.
       vii) Perform back substitution and get the unknown pivots x′   K   considering the corrected version of the syndrome s′.   viii) If Gaussian elimination was successful, do the back substitution, or alternatively an iterative decoding step to recover the remaining unknowns. Otherwise, decoding failed.       
 
         [0068]    It is further preferred that H′   K   corresponds to a submatrix P l  generated by the following steps:
       Bringing H   K   in triangular form by column and/or row permutations   Moving columns of a submatrix B of H   K   which block the triangularization process into a submatrix P of H   K   so that the triangularization process can be continued, until the parity check matrix H except the submatrix P is brought into triangular form,   whereby P l  corresponds to the dense lower part of submatrix P after zeroing out submatrix D of H   K   .       
 
         [0072]    In the following preferred embodiments of the invention are described in more detail with reference to the figures. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0073]      FIG. 1  is a flow diagram of the data transmission between a transmitter device and a receiver device as practicable also in the method of the disclosure, 
           [0074]      FIG. 2  shows the generation of submatrix P l  of parity check matrix H according to the state of the art, 
           [0075]      FIG. 3  illustrates the notation after forward elimination and back substitution are applied, 
           [0076]      FIG. 4  is an illustration of the submatrices H′ K  and H′   K   as well as of their respective submatrices, 
           [0077]      FIGS. 5 ,  6   a  and  6   b  show the erasure probability versus the codeword error rate. 
       
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
       [0078]      FIGS. 1 and 2  have been described in the introduction of the present application. 
         [0079]    Due to row additions as part of smart Gaussian elimination the matrix P l  (H* K ) changes to H′   K   (H′ K ). 
         [0080]    An illustration of the matrices H′ K ,H′   K   and their sub matrices H″ K  and H″   K    is given in  FIG. 4 . For single error correction the sub matrices play a key role. 
         [0081]    An example for a binary system of equations after the forward elimination step (Step 2.) is described below. The matrix corresponding to H′   K   is the 8×3 matrix on the left here. Note that the lower part contains only zero entries. On the right we see the 8×5 matrix H′ K  describing the combinations of the known packets to obtain the unknowns. We introduce a new, simplified notation: x 1 , . . . , x 5  represent the correctly received code symbols, x 6 , . . . , x 8  the erased symbols which correspond to the pivots. This yields to: 
         [0000]    
       
         
           
             
               
                 [ 
                 
                   
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       1 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                 
                 ] 
               
               · 
               
                 [ 
                 
                   
                     
                       
                         x 
                         6 
                       
                     
                   
                   
                     
                       
                         x 
                         7 
                       
                     
                   
                   
                     
                       
                         x 
                         8 
                       
                     
                   
                 
                 ] 
               
             
             = 
             
               
                 [ 
                 
                   
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       1 
                     
                     
                       1 
                     
                   
                   
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       1 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                 
                 ] 
               
               · 
               
                 [ 
                 
                   
                     
                       
                         x 
                         1 
                       
                     
                   
                   
                     
                       
                         x 
                         2 
                       
                     
                   
                   
                     
                       
                         x 
                         3 
                       
                     
                   
                   
                     
                       
                         x 
                         4 
                       
                     
                   
                   
                     
                       
                         x 
                         5 
                       
                     
                   
                 
                 ] 
               
             
           
         
       
     
         [0082]    If we set the correctly received symbols/packets to [0 0 0 0 0] T  we can compute the syndrome on the right. For sake of simplicity the packets only consist of bit here, but all considerations also hold for packets with larger sizes. 
         [0000]    
       
         
           
             
               
                 [ 
                 
                   
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       1 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                 
                 ] 
               
               · 
               
                 [ 
                 
                   
                     
                       
                         x 
                         6 
                       
                     
                   
                   
                     
                       
                         x 
                         7 
                       
                     
                   
                   
                     
                       
                         x 
                         8 
                       
                     
                   
                 
                 ] 
               
             
             = 
             
               
                 
                   [ 
                   
                     
                       
                         1 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         1 
                       
                       
                         1 
                       
                     
                     
                       
                         1 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                   
                   ] 
                 
                 · 
                 
                   [ 
                   
                     
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                     
                   
                   ] 
                 
               
               = 
               
                 [ 
                 
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                 
                 ] 
               
             
           
         
       
     
         [0083]    As it can be seen we still have 5 equations in excess, which are zero on both sides. 
         [0084]    Now let&#39;s assume that one of the known symbols contains an error. Here, this corresponds to flipping a bit in the known term. 
         [0085]    In case the erroneous symbol is x 1 , we get: 
         [0000]    
       
         
           
             
               
                 [ 
                 
                   
                     
                       1 
                     
                     
                       1 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       1 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                 
                 ] 
               
               · 
               
                 [ 
                 
                   
                     
                       
                         x 
                         6 
                       
                     
                   
                   
                     
                       
                         x 
                         7 
                       
                     
                   
                   
                     
                       
                         x 
                         8 
                       
                     
                   
                 
                 ] 
               
             
             = 
             
               
                 
                   [ 
                   
                     
                       
                         1 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         1 
                       
                       
                         1 
                       
                     
                     
                       
                         1 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                   
                   ] 
                 
                 · 
                 
                   [ 
                   
                     
                       
                         1 
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                     
                   
                   ] 
                 
               
               = 
               
                 [ 
                 
                   
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       1 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       0 
                     
                   
                   
                     
                       1 
                     
                   
                 
                 ] 
               
             
           
         
       
     
         [0086]    The equations above are no longer consistent. We see that for row 4 and 8 we get contradictions. (0=1) Hence we exploit the excess of equations to detect the error. Error correction can be now performed in the following way. We identified rows 4 and 8 of the syndrome to be affected by the error. Taking the matrix H′ K  we search for code symbols that are involved in the calculation of the 4 th  and 8 th  row of the syndrome, but not in rows 5, 6 and 7. This means that we look for columns of H′ K  for which rows 4 and 8 contain non-zero entries and rows 5, 6 and 7 contain zero entries. In case we are able to identify such a column, it is possible to identify the erroneous code symbol. In our case we identify column 1. To correct the erroreous code symbol, here one can xor the identified code symbol x 1  and the non-zero syndrome entry in row four of the syndrome. Alternatively the non-zero syndrome entry in row 8 could also be used. 
         [0087]    Furthermore before resolving the system of equations, the syndrome has to be corrected. This can be done here by xor-ing row one (optionally also row 4 and 8) of the syndrome with the non-zero syndrome entry in row 4 (or row 8) of the syndrome. This leads to our original set of equations (first example with no errors) that can be solved, e.g. by back substitution. 
         [0088]    Since a CRC is applied in practice the probability that an error occurs (CRC failure) in a codeword is very low and can be for example in the order of 10 −6  to 10 −8 . Thus, the probability that more than one error is present in one codeword is very low. 
         [0089]    In  FIG. 5  simulation results are provided for a (2048, 1024) generalized irregular repeat-accumulate (GeIRA) code designed for ML decoding. The code performance has been simulated over the BEC under efficient ML decoding, and over the BEEC under SEME decoding and without error correction. The simulation results illustrate how LDPC codes can approach the average random code ensemble performance in the three cases, at least down to moderate to low block error probabilities. The performance for the same LDPC code under more complex iterative (IT) decoding using soft values is provided too, for three cases: On the BEC (i.e., p=0), on the BEEC with IT erasure decoding (i.e., no error correction), and on the BEEC with soft input log likelihood ratios (LLRs) set according to the channel error/erasure probabilities. The performance under IT decoding on the BEC shows clearly the coding gain loss with respect to (w.r.t.) the ML decoder case. A block error rate P e =10 −4  is achieved by the IT decoder at e≅0.39, whereas under ML decoding the target is achieved at e≅0.46. On the BEEC channel, the SEME decoder outperforms the IT one down to moderate error rates (P e ≅10 3 ). However, as the erasure probability decreases, the performance of the SEME algorithms converges to a block error probability P e ≅2*10 4 , due to the limited (single) error correction capability of the algorithm itself. Since IT decoder is not limited to correct single errors, at low erasure probabilities IT decoding outperforms the SEME algorithm. This effect may be exploited by an hybrid SEME/IT decoder, e.g. the IT decoder might used whenever multiple errors are detected by the SEME decoder. Still, in many practical cases, the BEEC error probability may be quite below p=10 −5 , resulting in a (much) lower error floor for the SEME algorithm, reducing hence the need of an IT decoding stage. In fact, the gain in the error floor due to the single error correction capability of the SEME algorithm is amplified at lower error probabilities p. In  FIG. 6(   a ) and  FIG. 6(   b ), the bounds for the average random ensemble block error probability are displayed for the case of n=1000, k=500 and for two BEEC error probabilities, p=10 −6  and p=10 −8 . While in the former case, the floor is reduced by 3 orders of magnitude, in the latter case under SEME decoding the block error probability meets the floor at P e &gt;10 −10 , nearly 5 order of magnitude lower w.r.t. the case when no error correction is performed. Note that the bound (13) in the error floors under SEME decoding provides an accurate estimation of the block error probability for e→0. In fact, for n=1000, k=500, p=10 −6 , the error floor estimated by appears at  P   e,R(nk)   SEME,BEEC ≈4.99*10 −7  as depicted in  FIG. 6(   a ), while for n=1000, k=500, p=10 −8    P   e,R(n,k)   SEME,BEEC ≈5*10 −11 , as in  FIG. 6(   b ). 
         [0090]    The method proposed here can be applied in all types of commercial wireless and wired transmission systems. Usually, the assumption that error detection on physical layer does fail with low probability is realistic for most communication systems. As demonstrated this causes a non negligible error floor. The proposed modifications of the efficient ML decoder permit to perform single error correction also on platforms with low computational power and hence to reduce the error floor. The decoding algorithm can be used with any linear block code. Nevertheless, the main target for the presented decoder is low density parity check codes (LDPC) due to their efficient encoding and decoding properties.