Abstract:
A method is for generating, for each check node related to a parity check equation of a LDPC code, signals representing a first output table of corrected values of symbols of a word received through a communication channel and transmitted according to the LDPC code, and signals representing a second output table of the logarithm of the ratio between the respective probability of correctness of the values of same coordinates in the first output table and their corresponding maximum probability of correctness. The method is implemented by processing the components of a first input table of values of a Galois Field of symbols that may have been transmitted and of a second input table of corresponding probability of correctness of each value.

Description:
FIELD OF THE INVENTION 
       [0001]    This invention relates to decoding digital communications, and, more particularly, to a method of generating signals corresponding to a first output table of corrected values of symbols of a word transmitted according to a LDPC code and a second output table representing the corresponding probability values, and a LIST decoder that implements it. 
       BACKGROUND OF THE INVENTION 
       [0002]    Low Density Parity Check (LDPC) coding is an Error Correction Code (ECC) technique that is being increasingly regarded as a valid alternative to Turbo Codes. LDPC codes have been incorporated into the specifications of several real systems, and the LDPC decoder may turn out to constitute a significant portion of the corresponding digital transceiver. 
         [0003]    Non-Binary Low Density Parity Check (LDPC) codes are defined by a sparse parity check matrix  H  in a finite Galois field GF(2 p ). The check matrix  H  include a number M of rows, equal to the number of parity check nodes, and a number N of columns, equal to the number of symbols of each received word (codeword). The value of each symbol of a codeword belongs to the Galois field GF(2 p ) and is represented by a string of p bits. 
         [0004]    Every valid codeword  c  that may be transmitted satisfies the following check equation in the Galois field GF(2 p ): 
         [0000]    
       
      
         H ·  c = 
       0 
      
     
         [0000]    with  c  being a column vector and  0  a null column vector, whilst invalid codewords do not satisfy it. More specifically, the code is described by a set of j=0, . . . nc−1 parity check equations: 
         [0000]    
       
         
           
             
               
                 ∑ 
                 
                   i 
                   ∈ 
                   
                     VC 
                      
                     
                       ( 
                       j 
                       ) 
                     
                   
                 
               
                
               
                 
                   H 
                   ji 
                 
                 · 
                 
                   c 
                   i 
                 
               
             
             = 
             
               
                 0 
                 ⇒ 
                 
                   
                     H 
                     
                       _ 
                       _ 
                     
                   
                   · 
                   
                     c 
                     _ 
                   
                 
               
               = 
               0 
             
           
         
       
     
         [0000]    where both the codeword symbols c i  and the parity check coefficients H ji  belong to the GF(2 p ) and VC(j) is the set of variables (symbols c i ) involved in the j-th check. 
         [0005]    The transmitter transmits a valid codeword  c  over a noisy channel. Alternatively, the valid codeword can be written on a storage support (like the magnetic disk of a Hard Disk Drive). The receiver receives a noisy and distorted signal  c  representing a stream of symbols  c . The receiver is capable of delivering a first probabilistic estimate of the transmitted symbols through the PMF (Probability Mass Function) by means of a demodulator or a detector that are not part of the invention. The PMF are the probability that a received symbol X i  is equal to one of the possible symbol over GF(2 p ): P(X i =φ q ) φεGF(2 p ). The stream of most likely received symbols is  x =[{circumflex over (X)} 0 , {circumflex over (X)} 1 , . . . {circumflex over (X)} N ] 
         [0000]    
       
         
           
             
               
                 X 
                 ^ 
               
               i 
             
             = 
             
               
                 argmax 
                 q 
               
                
               
                 
                   P 
                    
                   
                     ( 
                     
                       
                         X 
                         i 
                       
                       = 
                       
                         ϕ 
                         q 
                       
                     
                     ) 
                   
                 
                 . 
               
             
           
         
       
     
         [0006]    As contemplated in LDPC coding, the product of the check matrix  H  by the received word  x  is performed. Because of noise and channel distortion, the result of this product is generally not the null vector: 
         [0000]    
       
      
         H ·  x =  z ≠ 
       0 
      
     
         [0000]    thus the receiver may determine which codeword has been received by implementing an appropriate decoding technique based on properties of LDPC codes. The a posteriori probability that a codeword  c  has been transmitted when a generic signal  r  has been received is computed taking into account the code constraint. 
         [0007]    More specifically, LDPC are decoded by means of a belief propagation algorithm that is described in the following paragraphs. The symbols are characterized by the PMF (Probability Mass Function). In the preferred embodiment PMF are represented in the log-domain: 
         [0000]      Λ iq =−log( P ( X   i =φ q )) φ q   εGF (2 p )
 
         [0008]    Using the vector representation 
         [0000]      Λ i =└Λ i0 ,Λ i1 , . . . Λ iq-1 ┘
 
         [0009]    The full complexity algorithm to be used as reference is the log-domain symbol based belief propagation and is calculated as 
         [0000]    
       
         
           
             
               
                 Λ 
                 iq 
               
               = 
               
                 
                   
                     - 
                     
                       log 
                        
                       
                         ( 
                         
                           P 
                            
                           
                             ( 
                             
                               
                                 X 
                                 i 
                               
                               = 
                               
                                 ϕ 
                                 q 
                               
                             
                             ) 
                           
                         
                         ) 
                       
                     
                   
                    
                   
                       
                   
                    
                   
                     ∀ 
                     i 
                   
                 
                 = 
                 0 
               
             
             , 
             
               
                 … 
                  
                 
                     
                 
                  
                 nv 
                  
                 
                     
                 
                  
                 
                   ∀ 
                   q 
                 
               
               = 
               0 
             
             , 
             
               
                 … 
                  
                 
                     
                 
                  
                 
                   2 
                   p 
                 
               
               - 
               1 
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 for 
                  
                 
                     
                 
                  
                 k 
               
               = 
               
                 1 
                 : 
                 
                   N 
                   ite 
                 
               
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 for 
                  
                 
                     
                 
                  
                 j 
               
               = 
               
                 1 
                 : 
                 nc 
               
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 for 
                  
                 
                     
                 
                  
                 i 
               
               ∈ 
               
                 VC 
                  
                 
                   ( 
                   j 
                   ) 
                 
               
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 
                   Q 
                   ij 
                 
                 = 
                 
                   
                     
                       Λ 
                       i 
                     
                     - 
                     
                       
                         R 
                         ji 
                       
                        
                       
                         ∀ 
                         q 
                       
                     
                   
                   = 
                   0 
                 
               
               , 
               
                 
                   … 
                    
                   
                       
                   
                    
                   
                     2 
                     p 
                   
                 
                 - 
                 1 
               
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 
                   R 
                   ji 
                 
                 = 
                 
                   
                     
                       SPC 
                        
                       
                         ( 
                         
                           
                             H 
                             j 
                           
                           , 
                           
                             Q 
                             ij 
                           
                         
                         ) 
                       
                     
                      
                     
                       ∀ 
                       q 
                     
                   
                   = 
                   0 
                 
               
               , 
               
                 
                   … 
                    
                   
                       
                   
                    
                   
                     2 
                     p 
                   
                 
                 - 
                 1 
               
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 Λ 
                 i 
               
               = 
               
                 
                   Q 
                   ij 
                 
                 + 
                 
                   R 
                   ji 
                 
               
             
           
         
       
       
         
           
             
               
                 X 
                 ^ 
               
               i 
             
             = 
             
               
                 argmax 
                 q 
               
                
               
                 ( 
                 
                   Λ 
                   iq 
                 
                 ) 
               
             
           
         
       
     
         [0000]    where Q ij , R ji  represent the variable to check and the check to variable messages (vectors each including a single PMF relative to the i-th symbol). In a preferred embodiment the belief propagation is implemented with the layered schedule (Dale E. Hocevar, “A reduced complexity decoder architecture via layered decoding of LDPC Codes”, IEEE Workshop on Signal Processing Systems (SIPS), October 2004, pp. 107-112). 
         [0010]    The check node processing (CNP) is performed by the SPC function. This is the most computational intensive part of the decoding algorithm. It is worth reviewing the approaches proposed so far for the decoding of Non Binary LDPC. 
         [0011]    M. C. Davey and D. MacKay, “Low-density parity-check codes over GF(q)”, IEEE Commun. Lett., vol. 2, no. 6, pp. 165, that first introduced the use of Non binary LDPC, proposed a very general implementation of the belief propagation (called also Sum Product Algorithm). It works in the probability domain. It has been noted very soon that this it has stability problems when probability values are represented in finite digit. Moreover, its complexity increases as the square of the size of the Galois field 2 p . 
         [0012]    Henk Wymeersch, Heidi Steendam and Marc Moeneclaey “Log-domain decoding of LDPC codes over GF (q)” Proc. IEEE International Conference on Communications, proposed the Sum Product Algorithm in logarithm domain. Its complexity increases as the square of the size of the Galois field 2 p . The log domain is the preferred embodiment also for the present invention. 
         [0013]    H. Song and J. R. Cruz, Reduced-complexity decoding of q-ary LDPC codes for magnetic recording,” IEEE Trans. Magn., vol. 39, no. 2, pp. 1081, introduced the SPC processing with the forward-backward approach describe below. Moreover they proposed Q-ary LDPC decoding using Fast Fourier Transform (FFT), both in probability and in logarithm domains. Unfortunately, probability domain gives instability problem when finite representation is used and the FFT in the logarithm domain involves doubling the used quantities. The advantage of using FFT approach is therefore is lost. 
         [0014]    A. Voicila, D. Declereq, F. Verdier, M. Fossorier, P. Urard, “Low-complexity, Low-memory EMS algorithm for non-binary LDPC codes” IEEE International Conference on Communications, 2007, ICC &#39;07, proposed the so-called Extended Min Sum algorithm: this very generic approach introduces the concept of reduction of candidates at the input of the SPC but does not provide a computationally simple and effective way to perform the CNP. 
         [0015]    Therefore, there is the need for a simpler and faster algorithm usable for decoding non-binary LDPC codes, especially in the most computationally intensive part that is the SPC. 
         [0016]    The exact formulation of the SPC is the following: 
         [0000]    
       
         
           
             
               R 
               jip 
             
             = 
             
               
                 SPC 
                  
                 
                   ( 
                   
                     
                       H 
                       j 
                     
                     , 
                     
                       Q 
                       ij 
                     
                   
                   ) 
                 
               
               = 
               
                 
                   
                     - 
                     
                       log 
                        
                       
                         ( 
                         
                           P 
                            
                           
                             ( 
                             
                               
                                 X 
                                 i 
                               
                               = 
                               
                                 ϕ 
                                 p 
                               
                             
                             ) 
                           
                         
                         ) 
                       
                     
                   
                    
                   
                       
                   
                    
                   
                     s 
                     . 
                     t 
                     . 
                     
                         
                     
                      
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           
                             VC 
                              
                             
                               ( 
                               j 
                               ) 
                             
                           
                         
                       
                        
                       
                         
                           H 
                           ji 
                         
                          
                         
                           X 
                           i 
                         
                       
                     
                   
                 
                 = 
                 0 
               
             
           
         
       
     
         [0017]    The straight-forward approach to solve the SPC is based on the forward-backward recursion over a fully connected trellis with q=2 p  states (see for example H. Song and J. R. Cruz, Reduced-complexity decoding of q-ary LDPC codes for magnetic recording,” IEEE Trans. Magn., vol. 39, no. 2, pp. 1081 where the same approach is introduce in the probability domain). 
         [0018]    States correspond to the symbols Xi. The branches are given by Q ijp  and the state connections are determined by the parity check coefficients. 
         [0019]    The forward recursion for a generic parity check equation with coefficients H t  where the inputs PMF are Q tp =−log(P in (X t =φ p ) is given by: 
         [0000]    
       
         
           
             
               
                 a 
                 i 
               
                
               
                 ( 
                 z 
                 ) 
               
             
             = 
             
               
                 
                   - 
                   log 
                 
                  
                 
                     
                 
                  
                 
                   ( 
                   
                     P 
                      
                     
                       ( 
                       
                         
                           state 
                           t 
                         
                         = 
                         
                           ϕ 
                           z 
                         
                       
                       ) 
                     
                   
                   ) 
                 
               
               = 
               
                 
                   max 
                   
                     
                       n 
                       = 
                       0 
                     
                     , 
                     
                         
                     
                      
                     
                       
                         … 
                          
                         
                             
                         
                          
                         q 
                       
                       - 
                       1 
                     
                   
                 
                  
                 
                   * 
                   
                     ( 
                     
                       
                         
                           a 
                           
                             t 
                             - 
                             1 
                           
                         
                          
                         
                           ( 
                           n 
                           ) 
                         
                       
                       - 
                       
                         log 
                          
                         
                           ( 
                           
                             
                               P 
                               
                                 i 
                                  
                                 
                                     
                                 
                                  
                                 n 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   X 
                                   t 
                                 
                                 = 
                                 
                                   
                                     H 
                                     t 
                                     
                                       - 
                                       1 
                                     
                                   
                                   · 
                                   
                                     ( 
                                     
                                       
                                         ϕ 
                                         z 
                                       
                                       - 
                                       
                                         ϕ 
                                         n 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               ) 
                             
                           
                           ) 
                         
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0020]    Backward recursion is defined analogously. The combining step is given by 
         [0000]    
       
         
           
             
               R 
               tz 
             
             = 
             
               
                 - 
                 
                   log 
                    
                   
                     ( 
                     
                       P 
                        
                       
                         ( 
                         
                           
                             X 
                             t 
                           
                           = 
                           
                             ϕ 
                             z 
                           
                         
                         ) 
                       
                     
                     ) 
                   
                 
               
               = 
               
                 
                   
                     max 
                     
                       
                         
                           n 
                           = 
                           0 
                         
                         , 
                         
                             
                         
                          
                         
                           
                             … 
                              
                             
                                 
                             
                              
                             q 
                           
                           - 
                           1 
                         
                       
                       
                         
                           m 
                           = 
                           0 
                         
                         , 
                         
                             
                         
                          
                         
                           
                             … 
                              
                             
                                 
                             
                              
                             q 
                           
                           - 
                           1 
                         
                       
                     
                   
                    
                   
                     * 
                     
                       ( 
                       
                         
                           
                             a 
                             
                               t 
                               - 
                               1 
                             
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                         + 
                         
                           
                             β 
                             
                               t 
                               + 
                               1 
                             
                           
                            
                           
                             ( 
                             m 
                             ) 
                           
                         
                       
                       ) 
                     
                      
                     
                         
                     
                      
                     
                       s 
                       . 
                       t 
                       . 
                       
                           
                       
                        
                       
                         
                           H 
                           t 
                           
                             - 
                             1 
                           
                         
                          
                         
                           ( 
                           
                             
                               ϕ 
                               n 
                             
                             + 
                             
                               ϕ 
                               m 
                             
                           
                           ) 
                         
                       
                     
                   
                 
                 = 
                 
                   ϕ 
                   z 
                 
               
             
           
         
       
     
         [0021]    The straightforward approximation available at the Check Node Processing is the substitution of the max* operator with the max. In order to compensate the well-known overestimation of the max operator a proper scaling factor is applied at the SPC output so that the recursion is given by: 
         [0000]    
       
         
           
             
               
                 a 
                 t 
               
                
               
                 ( 
                 z 
                 ) 
               
             
             = 
             
               
                 max 
                 
                   
                     n 
                     = 
                     0 
                   
                   , 
                   
                       
                   
                    
                   
                     
                       … 
                        
                       
                           
                       
                        
                       q 
                     
                     - 
                     1 
                   
                 
               
                
               
                 ( 
                 
                   
                     
                       a 
                       
                         t 
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       n 
                       ) 
                     
                   
                   - 
                   
                     log 
                      
                     
                       ( 
                       
                         
                           P 
                           
                             i 
                              
                             
                                 
                             
                              
                             n 
                           
                         
                          
                         
                           ( 
                           
                             
                               X 
                               t 
                             
                             = 
                             
                               
                                 H 
                                 t 
                                 
                                   - 
                                   1 
                                 
                               
                               · 
                               
                                 ( 
                                 
                                   
                                     ϕ 
                                     z 
                                   
                                   - 
                                   
                                     ϕ 
                                     n 
                                   
                                 
                                 ) 
                               
                             
                           
                           ) 
                         
                       
                       ) 
                     
                   
                 
                 ) 
               
             
           
         
       
     
         [0000]    and the combining is 
         [0000]    
       
         
           
             
               R 
               tz 
             
             = 
             
               
                 γ 
                 · 
                 
                   
                     max 
                     
                       
                         
                           n 
                           = 
                           0 
                         
                         , 
                         
                             
                         
                          
                         
                           
                             … 
                              
                             
                                 
                             
                              
                             q 
                           
                           - 
                           1 
                         
                       
                       
                         
                           m 
                           = 
                           0 
                         
                         , 
                         
                             
                         
                          
                         
                           
                             … 
                              
                             
                                 
                             
                              
                             q 
                           
                           - 
                           1 
                         
                       
                     
                   
                    
                   
                     
                       ( 
                       
                         
                           
                             a 
                             
                               t 
                               - 
                               1 
                             
                           
                            
                           
                             ( 
                             n 
                             ) 
                           
                         
                         + 
                         
                           
                             β 
                             
                               t 
                               + 
                               1 
                             
                           
                            
                           
                             ( 
                             m 
                             ) 
                           
                         
                       
                       ) 
                     
                      
                     
                         
                     
                      
                     
                       s 
                       . 
                       t 
                       . 
                       
                           
                       
                        
                       
                         
                           H 
                           t 
                           
                             - 
                             1 
                           
                         
                          
                         
                           ( 
                           
                             
                               ϕ 
                               n 
                             
                             + 
                             
                               ϕ 
                               m 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
               = 
               
                 ϕ 
                 z 
               
             
           
         
       
     
         [0000]    where the scaling factor γ is—in the context of magnetic recording—about 0.75. 
         [0022]    This algorithm is the natural extension of the normalized min-sum belief propagation in the binary field (Zarkeshvari, F.; Banihashemi, A. H.; “On implementation of min-sum algorithm for decoding low-density parity-check (LDPC) codes”, Global Telecommunications Conference, 2002. GLOBECOM &#39;02. IEEE Volume 2, 17-21 November 2002 Page(s): 1349-1353.). 
         [0023]    In order to further simplify the decoding algorithm, both input and SPC processing can be restricted to a subset of symbol candidates (A. Voicila, D. Declereq, F. Verdier, M. Fossorier, P. Urard, “Low-complexity, Low-memory EMS algorithm for non-binary LDPC codes” IEEE International Conference on Communications, 2007, ICC &#39;07). 
       SUMMARY OF THE INVENTION 
       [0024]    An algorithm useful for decoding Non Binary LDPC in digital communications, a relative decoder and software code adapted to implement it have been devised. 
         [0025]    This algorithm may be repeated for each check node related to a parity check equation of a LDPC code, for generating signals representing a first output table  S   output  of corrected values of symbols of a word received through a communication channel and transmitted according to the LDPC code, wherein each row of the table from the first to the last stores, in order, the most probable value down to the least probable value and each column of the table stores the possible values of each symbol. The algorithm may also generate signals representing a second output table  M   output  of the logarithm of the ratio between the respective probability of correctness of the values of same coordinates in the first output table  S   output  and their corresponding maximum probability of correctness. 
         [0026]    According to the method, the values of the output tables are obtained by processing the components of a first input table  S   input  of values of a Galois Field of symbols that may have been transmitted and of a second input table  M   input  of corresponding probability of correctness of each value. The processing may include filling in the first row of the second output table  M   output  by copying the first row of the input table into the first row of the corresponding output table, and filling in the first row of the first output table  S   output  by computing the most likely symbol that satisfy the parity check equation. The processing may also include determining the probability values of the second row of the second output table  M   output  for each symbol in the hypothesis that one symbol different from the considered one of the received word is assuming its second best value, and determining the corresponding corrected value in the first output table  S   output  applying accordingly the check equation. The processing may further include determining the probability values of the third row of the second output table  M   output  a for each symbol in the hypothesis that one symbol different from the considered one of the received word is assuming a value different from its most probable value and the value considered at the previous step, and determining the corresponding corrected value in the first output table  S   output  applying accordingly the check equation. The processing may yet further include determining the probability values of the fourth and successive rows of the second output table  M   output  for each symbol. The determining may include for each symbol, calculating a first probability value in the case that one symbol different from the considered one of the received word is assuming a value different from its most probable value and the values considered at the previous steps, and calculating a second probability value in the case that two symbols different from the considered one of the received word are not assuming their most probable values. The determining may also include checking which is the greatest of the two probability values first and second, and determining the corresponding corrected value in the first output table  S   output  applying accordingly the check equation, and outputting the signals representing the so generated output tables first  S   output  and second  M   output . 
         [0027]    The above algorithm may be implemented via software, stored in a computer readable medium, or in a hardware LIST decoder, and executed by a computer or processor. LIST decoders internally generate the input tables  S   input ,  M   input  and, according to an aspect of this invention, they may be further equipped with circuit means adapted to process the input tables according to the algorithm for generating signals representing the output tables. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0028]      FIG. 1  is a basic high-level block diagram of an embodiment of the algorithm according to the present invention. 
           [0029]      FIGS. 2 to 6  are more detailed block diagrams of the preferred embodiment of the algorithm according to the present invention. 
           [0030]      FIG. 7  is a functional block scheme of the architecture of a decoder adapted to implement the algorithm of the present invention. 
       
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
       [0031]    The present invention relies upon the following approach that results in minimal performance losses. The approach includes first sorting the symbol candidates according to the corresponding value in the PMF so that the first candidate results to be the most likely choices, and then preserving in input the PMF of the first n symbol candidates with the exact probabilities and set the 2 p-n  candidate probabilities equal the value of the n-th candidate. The approach then includes computing as output of the SPC the first n symbol candidates with the exact probabilities and set the 2 p-n  equal the value of the n-th candidate. 
         [0032]    In order to explain how the SPC works in the present invention, it is beneficial to introduce a new description of Q ij . Let consider the generic check i and form a matrix QW i  with the PMF associated to the symbols belonging to the check I QW i =└Q i1 Q i2  . . . Q ij  . . . Q id     c   ┘ 
         [0033]    Then sort every column of QW i  and produce two matrices  M   input  and  S   input  of dimension (2 p ×dc). M input (i, j) is the value of the PMF of the j-th symbol. For a given symbol j, the values M input (i, j) are in ascending order so that the value of most likely candidate is in the first row M input (1, j). For further simplifying the algorithm, the values M input (i, j) are normalized by subtracting the values in the first row so that M input (1, j)=0 and M input (i, j)=M input (i, j)−M input (1, j) for i=2, . . . 2 p . The generic entry of S input (i, j) of the matrix  S   input  is the candidate associated to the PMF value  M   input (i, j). As already described in the previous paragraph, M input (i, j)=  M   input (n, j) for n&lt;i≦2 p . 
         [0034]    The objective of the SPC LIST decoder incorporated in the LDPC decoder is to generate for each set of symbol  x  belonging to the same parity check j two output tables (matrices)  M   output  and  S   output , analogous to the tables  M   input  and  S   input , that describe the SPC output R ji . The present invention is mainly related to the introduction of a low complexity SPC LIST decoder. 
         [0035]    This invention is more specifically related to the way the check-node processing (CNP) step is performed. In the context of the CNP that solves the problem of delivering new symbols estimate given the constraint of a single parity check it has been found that, considered the set of symbols belonging to a specific SPC of the non binary LDPC, starting from a list of the possible symbols values over a Galois Field  S   input  that can be assumed by each of the aforementioned symbols and the associate probability  M   input , it is possible to generate, with relatively not onerous calculations, a first output table  S   output  containing a list of potentially correct values according to the SPC constraints and a second output table  M   output  containing the logarithm of the associated probability of being correct by executing the following operations. The operations include filling the first row of the output table  M   output  by copying the first row of the corresponding input tables; the first row of  S   output  is filled computing the most likely symbol that satisfy the parity check. The operations also include determining the probability values of the second row of the second output table  M   output  a for each symbol in the hypothesis that one symbol different from the considered one of the received word is assuming its second best value, and determining the corresponding corrected value in the first output table  S   output  applying accordingly said check equation. 
         [0036]    The operations further include determining the probability values of the third row of the second output table  M   output  for each symbol in the hypothesis that one symbol different from the considered one of the received word is assuming a value different from its most probable value and the value considered at the previous step, and determining the corresponding corrected value in the first output table  S   output  applying accordingly the check equation. 
         [0037]    The probability values of the fourth and successive rows of the second output table  M   output  may be determined for each symbol. The probability values may be determined by for each symbol, calculating the probability that one symbol different from the considered one of the received word is assuming a value different from its most probable value and the values considered at the previous steps, and calculating the probability that two symbols different from the considered one of the received word are not assuming their most probable values. The probability values are also determined by checking which is the greatest of said two probabilities, and determining the corresponding corrected value in the first output table  S   output  applying accordingly said check equation. 
         [0038]    In order to better understand how the method works, reference is made to a practical exemplary case of a code in GF(2 3 ) with a single check equation (thus with a single check-node), though the method may be applied mutatis mutandis to codes belonging to a Galois field of any order and for any number of check equations. 
         [0039]    Moreover, the method will be illustrated referring to a particular case in which all symbols of words to be received are involved in the single check node. This is not a limitation and the method remains applicable also if some of the symbols of a received word are involved in a check equation. In this case, what will be stated shall refer to the symbols involved in the considered check equation, the other symbols being ignored as if they were not present. 
         [0040]    Let us suppose to use a LDPC defined by a generic check matrix  H , and that the receiver, after having received the incoming word  x  composed of seven symbols (dc=7), generates the following two matrices  M   input  and  S   input  that are provided to the decoder: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                     
                       0 
                     
                   
                   
                     
                       10 
                     
                     
                       2 
                     
                     
                       17 
                     
                     
                       11 
                     
                     
                       4 
                     
                     
                       15 
                     
                     
                       12 
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       7 
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       6 
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     
                       0 
                     
                     
                       2 
                     
                     
                       4 
                     
                     
                       1 
                     
                     
                       7 
                     
                     
                       2 
                     
                     
                       5 
                     
                   
                   
                     
                       5 
                     
                     
                       3 
                     
                     
                       2 
                     
                     
                       0 
                     
                     
                       4 
                     
                     
                       6 
                     
                     
                       1 
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                     
                       
                           
                       
                     
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0041]    The matrix  S   input  contains in the first row the values of maximum probability of correctness of each symbol; in the second row the values of second best probability of correctness; in the third row the values of third best probability of correctness and so on. 
         [0042]    The generic value M input (i, j) of the matrix  M   input  is the opposite of the natural logarithm of the ratio between the probability that the j-th symbol of the received word be equal to the value S input (i, j) of the Galois filed GF(2 3 ) and the probability that the j-th symbol of the received word be equal to the value S input (1, j). 
         [0043]    According to LDPC decoding, the value S input (1, j) is considered and in each (generic k-th) check node the following check value is calculated in the Galois field: 
         [0000]    
       
         
           
             
               
                 ∑ 
                 j 
               
                
               
                 
                   H 
                    
                   
                     ( 
                     
                       k 
                       , 
                       j 
                     
                     ) 
                   
                 
                 · 
                 
                   
                     S 
                     input 
                   
                    
                   
                     ( 
                     
                       1 
                       , 
                       j 
                     
                     ) 
                   
                 
               
             
             = 
             
               
                 z 
                  
                 
                   ( 
                   k 
                   ) 
                 
               
               ≠ 
               0 
             
           
         
       
     
         [0044]    According to the method, for each check node k, a corrected value S output (1, j) of maximum probability of correctness for each symbol is calculated according to the following equation: 
         [0000]    
       
         
           
             
               
                 S 
                 output 
               
                
               
                 ( 
                 
                   1 
                   , 
                   j 
                 
                 ) 
               
             
             = 
             
               
                 
                   z 
                    
                   
                     ( 
                     k 
                     ) 
                   
                 
                 - 
                 
                   
                     H 
                      
                     
                       ( 
                       
                         k 
                         , 
                         j 
                       
                       ) 
                     
                   
                   · 
                   
                     
                       S 
                       input 
                     
                      
                     
                       ( 
                       
                         1 
                         , 
                         j 
                       
                       ) 
                     
                   
                 
               
               
                 H 
                  
                 
                   ( 
                   
                     k 
                     , 
                     j 
                   
                   ) 
                 
               
             
           
         
       
       
         
           
             
               
                 M 
                 output 
               
                
               
                 ( 
                 
                   1 
                   , 
                   j 
                 
                 ) 
               
             
             = 
             0 
           
         
       
     
         [0045]    All operations are executed in the Galois field GF (2 3 ) (in the general case, in the Galois field 2 N ). The above equation for calculating S output (1, j) is to be applied to the symbols that are involved in check calculations performed at the k-th check node (in this case the values H(k, j) at the denominator differ from 0). 
         [0046]    The values of maximum probability of correctness in the first row of  S   output  and the corresponding logarithm of normalized probability in the first row of  M   output  are obtained: 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
           
         
       
     
       M output (1, j) 
       [0047]    In order to fill in the second row of the matrix  S   output , according to the method it is necessary to identify the symbols a 1 -th and b 1 -th for which: 
         [0000]        M   input (2 ,a   1 )≦ M   input (2 ,j )∀ jε{ 1 , . . . , dc} 
 
         [0000]        M   input (2 ,b   1 )≦ M   input (2 ,j )∀ jε{ 1 , . . . , dc}−{a   1 }
 
         [0048]    In practice, excluding a priori the values of maximum probability of correctness, the above operations correspond to identifying the first most probable value S input (2, a 1 ) and its corresponding symbol a 1 , and identifying the second immediately most probable value S input (2, b 1 ) not belonging to the symbol a 1 . 
         [0049]    In the considered numerical example, the a 1 -th symbol is the second symbol and the b 1 -th symbol is the fifth symbol. Two cases are possible: a) the j-th symbol to be corrected is the a 1 -th symbol (in the exemplary case: j=2); and b) the j-th symbol to be corrected is not the a 1 -th symbol (in the exemplary case: j≠2). 
         [0050]    In case a), the value S output (2, a 1 ) and its corresponding logarithm of normalized probability M output (2, a 1 ) are determined according to the following general formulae: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             S 
                             output 
                           
                            
                           
                             ( 
                             
                               2 
                               , 
                               
                                 a 
                                 1 
                               
                             
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               
                                 
                                   
                                     
                                       z 
                                        
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                     - 
                                     
                                       
                                         H 
                                          
                                         
                                           ( 
                                           
                                             k 
                                             , 
                                             
                                               a 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                       · 
                                       
                                         
                                           S 
                                           input 
                                         
                                          
                                         
                                           ( 
                                           
                                             1 
                                             , 
                                             
                                               a 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                     - 
                                     
                                       
                                         H 
                                          
                                         
                                           ( 
                                           
                                             k 
                                             , 
                                             
                                               b 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                       · 
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     
                                       
                                         S 
                                         input 
                                       
                                        
                                       
                                         ( 
                                         
                                           1 
                                           , 
                                           
                                             b 
                                             1 
                                           
                                         
                                         ) 
                                       
                                     
                                     + 
                                     
                                       
                                         H 
                                          
                                         
                                           ( 
                                           
                                             k 
                                             , 
                                             
                                               b 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                       · 
                                       
                                         
                                           S 
                                           input 
                                         
                                          
                                         
                                           ( 
                                           
                                             2 
                                             , 
                                             
                                               b 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             
                               H 
                                
                               
                                 ( 
                                 
                                   k 
                                   , 
                                   
                                     a 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                           
                           = 
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               S 
                               output 
                             
                              
                             
                               ( 
                               
                                 1 
                                 , 
                                 
                                   a 
                                   1 
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               
                                 H 
                                  
                                 
                                   ( 
                                   
                                     k 
                                     , 
                                     
                                       b 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                               
                                 H 
                                  
                                 
                                   ( 
                                   
                                     k 
                                     , 
                                     
                                       a 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                             · 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ( 
                             
                               
                                 
                                   S 
                                   input 
                                 
                                  
                                 
                                   ( 
                                   
                                     2 
                                     , 
                                     
                                       b 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   S 
                                   input 
                                 
                                  
                                 
                                   ( 
                                   
                                     1 
                                     , 
                                     
                                       b 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                             ) 
                           
                           ; 
                         
                       
                     
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     
                       M 
                       output 
                     
                      
                     
                       ( 
                       
                         2 
                         , 
                         
                           a 
                           1 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         M 
                         input 
                       
                        
                       
                         ( 
                         
                           2 
                           , 
                           
                             b 
                             1 
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0051]    It is worth nothing here that the difference (S input (2, b 1 )−S input (1, b 1 )) is part of the value that will be used to store in a compressed way the whole  S   output  table. 
         [0052]    In case b), the value S output (2, j) and its corresponding probability M output (2, j)∀j≠a 1  are determined according to the following general formulae: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             S 
                             output 
                           
                            
                           
                             ( 
                             
                               2 
                               , 
                               j 
                             
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               
                                 
                                   
                                     z 
                                      
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                   - 
                                   
                                     
                                       H 
                                        
                                       
                                         ( 
                                         
                                           k 
                                           , 
                                           j 
                                         
                                         ) 
                                       
                                     
                                     · 
                                     
                                       
                                         S 
                                         input 
                                       
                                        
                                       
                                         ( 
                                         
                                           1 
                                           , 
                                           j 
                                         
                                         ) 
                                       
                                     
                                   
                                   - 
                                   
                                     
                                       
                                         H 
                                          
                                         
                                           ( 
                                           
                                             k 
                                             , 
                                             
                                               a 
                                               1 
                                             
                                           
                                           ) 
                                         
                                       
                                       · 
                                       
                                         S 
                                         input 
                                       
                                     
                                      
                                     
                                       ( 
                                       
                                         1 
                                         , 
                                         
                                           a 
                                           1 
                                         
                                       
                                       ) 
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   
                                     H 
                                      
                                     
                                       ( 
                                       
                                         k 
                                         , 
                                         
                                           a 
                                           1 
                                         
                                       
                                       ) 
                                     
                                   
                                   · 
                                   
                                     
                                       S 
                                       input 
                                     
                                      
                                     
                                       ( 
                                       
                                         2 
                                         , 
                                         
                                           a 
                                           1 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                           
                             H 
                              
                             
                               ( 
                               
                                 k 
                                 , 
                                 j 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                            
                           
                             
                               
                                 S 
                                 output 
                               
                                
                               
                                 ( 
                                 
                                   1 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             + 
                             
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         a 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                               
                               · 
                               
                                 ( 
                                 
                                   
                                     
                                       S 
                                       input 
                                     
                                      
                                     
                                       ( 
                                       
                                         2 
                                         , 
                                         
                                           a 
                                           1 
                                         
                                       
                                       ) 
                                     
                                   
                                   - 
                                   
                                     
                                       S 
                                       input 
                                     
                                      
                                     
                                       ( 
                                       
                                         1 
                                         , 
                                         
                                           a 
                                           1 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ; 
                       
                     
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     
                       M 
                       output 
                     
                      
                     
                       ( 
                       
                         2 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         M 
                         input 
                       
                        
                       
                         ( 
                         
                           2 
                           , 
                           
                             a 
                             1 
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0053]    It is worth nothing here that the difference (S input (2, a 1 )−S input (1, a 1 )) is part of the value that will be used to store in a compressed way the whole  S   output  table. 
         [0054]    Considering the numerical example, the first two rows of the output probability matrix are 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
           
         
       
     
       M output (1, j), M output (2, j) 
       [0055]    Independently from the degree of the check matrix, the second row of the output probability matrix  M   output  has been filled with two values different from zero. This is particularly advantageous because it greatly simplifies the recording of the matrix in a memory. 
         [0056]    The a 1 -th column of the output probability matrix  M   output  is the sole column different from the other columns. 
         [0057]    It is easy to verify that the output matrix  S   output  that is being filled so far cannot contain twice a same value in a same column. 
         [0058]    The values of the row S output (3, j) are calculated in order starting from the value S output (3, a 1 ); then the value S output (3, b 1 ) and the other values are calculated according to a procedure similar to that used for calculating the second row. Differently from the previous step, now attention should be paid to avoid filling in a same column of the matrix  S   output  repeating twice a same value. 
         [0059]    The value S output (3, a 1 ) is calculated by: 
         [0000]    a) looking at the matrix of input probabilities  M   input  to identify the a 2 -th symbol for which 
         [0000]        M   input ( i   a2   ,a   2 )≦ M   input ( i,j )∀ i≧ 2 ,a   2   ≠a   1  and ( i   a2   ,a   2 )≠(2 ,b   1 );
 
         [0000]    b) calculating the value S output (3, a 1 ) and the corresponding logarithm of normalized probability M output (3, a 1 ) using the following formulae: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       output 
                     
                      
                     
                       ( 
                       
                         3 
                         , 
                         
                           a 
                           1 
                         
                       
                       ) 
                     
                   
                   = 
                     
                    
                   
                     
                       
                         
                           
                             
                               
                                 z 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         a 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         a 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         a 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         a 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               + 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         a 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           a 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                       , 
                                       
                                         a 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                       
                         H 
                          
                         
                           ( 
                           
                             k 
                             , 
                             
                               a 
                               1 
                             
                           
                           ) 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         S 
                         ouput 
                       
                        
                       
                         ( 
                         
                           1 
                           , 
                           
                             a 
                             1 
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 a 
                                 2 
                               
                             
                             ) 
                           
                         
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 a 
                                 1 
                               
                             
                             ) 
                           
                         
                       
                       · 
                       
                         ( 
                         
                           
                             
                               
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           a 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                       , 
                                       
                                         a 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                 - 
                               
                             
                           
                           
                             
                               
                                 
                                   S 
                                   input 
                                 
                                  
                                 
                                   ( 
                                   
                                     1 
                                     , 
                                     
                                       a 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   M 
                   output 
                 
                  
                 
                   ( 
                   
                     3 
                     , 
                     
                       a 
                       1 
                     
                   
                   ) 
                 
               
               = 
               
                 
                   M 
                   input 
                 
                  
                 
                   ( 
                   
                     
                       i 
                       
                         a 
                          
                         
                             
                         
                          
                         2 
                       
                     
                     , 
                     
                       a 
                       2 
                     
                   
                   ) 
                 
               
             
             ; 
           
         
       
     
         [0060]    It is worth nothing here that the difference (S input (i a2 , a 2 )−S input (1, a 2 )) is part of the value that will be used to store in a compressed way the whole  S   output  table; 
         [0000]    c) checking whether or not S output (3, a 1 )=S output (2, a 1 ) and, in the affirmative case, restarting the procedure from point a) choosing a different pair (i a2 , a 2 ). 
         [0061]    In the exemplary numerical case the pair (i a2 , a 2 ) is (3, 5). 
         [0062]    The output probability matrix is being filled as follows 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                     
                 
               
               
                 6 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0063]    The value S output (3, b 1 ) and the other values S output (3, j)∀j≠a 1 , b 1  are calculated with a procedure similar to that for calculating S output (2, a 1 ) and the other values S output (2, j)∀j≠a 1 . 
         [0064]    According to the method, the symbol b 2 -th and c 2 -th for which: 
         [0000]        M   input ( i   b2   ,b   2 )≦ M   input ( i,j )∀ jε{ 1 , . . . , dc}−{b   1   },b   2   ≠b   1  and ( i   b2   ,b   2 )≠(2 ,a   1 );
 
         [0000]        M   input ( i   c2   ,c   2 )≦ M   input ( i,j )∀ jε{ 1 , . . . , dc } and ( i   c2   ,c   2 )≠(2 ,a   1 ),
 
         [0000]    are identified.
 
In practice, excluding a priori the values of maximum probability of correctness and the value S input (2, a 1 ) already considered in the previous step, the above operation corresponds to identifying the first most probable value S input (i c2 , c 2 ) and its corresponding symbol c 2 , and identifying the second most probable value S input (i b2 , b 2 ) and its corresponding symbol b 2  different from the symbol b 1 .
 
         [0065]    It may occur that the value S input (i c2 , c 2 ) is the value S input (2, b 1 ). In the considered numerical example, the c 2 -th symbol is again the fifth symbol and the b 2 -th symbol is again the second symbol. 
         [0066]    Two cases are possible: a) the j-th symbol to be corrected is the b 1 -th symbol (in the exemplary case: j=5); and b) the j-th symbol to be corrected is neither the b 1 -th or a 1 -th or c 2 -th symbol (in the exemplary case: j≠5, 2). As stated before, the c 2 -th symbol is the b 2 -th symbol. 
         [0067]    In case a), the value S output (3, b 1 ) and its corresponding logarithm of normalized probability M output (3, b 1 ) are determined according to the following general formulae: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       output 
                     
                      
                     
                       ( 
                       
                         3 
                         , 
                         
                           b 
                           1 
                         
                       
                       ) 
                     
                   
                   = 
                     
                    
                   
                     
                       
                         
                           
                             
                               
                                 z 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         b 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         b 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         b 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         b 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               + 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         b 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           b 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                       , 
                                       
                                         b 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                       
                         H 
                          
                         
                           ( 
                           
                             k 
                             , 
                             
                               b 
                               1 
                             
                           
                           ) 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         S 
                         ouput 
                       
                        
                       
                         ( 
                         
                           1 
                           , 
                           
                             b 
                             1 
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 b 
                                 2 
                               
                             
                             ) 
                           
                         
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 b 
                                 1 
                               
                             
                             ) 
                           
                         
                       
                       · 
                       
                         ( 
                         
                           
                             
                               
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           b 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                       , 
                                       
                                         b 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                 - 
                               
                             
                           
                           
                             
                               
                                 
                                   S 
                                   input 
                                 
                                  
                                 
                                   ( 
                                   
                                     1 
                                     , 
                                     
                                       b 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 M 
                 output 
               
                
               
                 ( 
                 
                   3 
                   , 
                   
                     b 
                     1 
                   
                 
                 ) 
               
             
             = 
             
               
                 M 
                 input 
               
                
               
                 ( 
                 
                   
                     i 
                     
                       b 
                        
                       
                           
                       
                        
                       2 
                     
                   
                   , 
                   
                     b 
                     2 
                   
                 
                 ) 
               
             
           
         
       
     
         [0068]    It is worth nothing here that the difference (S input (i b2 , b 2 )−S input (1, b 2 )) is part of the value that will be used to store in a compressed way the whole  S   output  table. 
         [0069]    Also in this case, it is to be checked whether or not S output (3, b 1 )≠S output (2, b 1 ) and eventually to identify the immediately less probable value than S input (i b2 , b 2 ) to be used in place thereof. 
         [0070]    By looking at the input probability matrix of the numerical example, S input (i b2 , b 2 )=S input (3, 2) because M input (3, 2)=7. Therefore, the output probability matrix is 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                     
                 
               
               
                 6 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 7 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0071]    In case b), the value S output (3, j) and its corresponding probability M output (3, j)∀j≠a 1 , b 1  are determined according to the following general formulae: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         S 
                         output 
                       
                        
                       
                         ( 
                         
                           3 
                           , 
                           j 
                         
                         ) 
                       
                     
                     = 
                       
                      
                     
                       
                         
                           
                             
                               
                                 
                                   z 
                                    
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                                 - 
                                 
                                   
                                     H 
                                      
                                     
                                       ( 
                                       
                                         k 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   · 
                                   
                                     
                                       S 
                                       input 
                                     
                                      
                                     
                                       ( 
                                       
                                         1 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                 
                                 - 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     H 
                                      
                                     
                                       ( 
                                       
                                         k 
                                         , 
                                         
                                           c 
                                           2 
                                         
                                       
                                       ) 
                                     
                                   
                                   · 
                                   
                                     
                                       S 
                                       input 
                                     
                                      
                                     
                                       ( 
                                       
                                         1 
                                         , 
                                         
                                           c 
                                           2 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                                 + 
                                 
                                   
                                     H 
                                      
                                     
                                       ( 
                                       
                                         k 
                                         , 
                                         
                                           c 
                                           2 
                                         
                                       
                                       ) 
                                     
                                   
                                   · 
                                   
                                     
                                       S 
                                       input 
                                     
                                      
                                     
                                       ( 
                                       
                                         
                                           i 
                                           
                                             c 
                                              
                                             
                                                 
                                             
                                              
                                             2 
                                           
                                         
                                         , 
                                         
                                           c 
                                           2 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                         
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               j 
                             
                             ) 
                           
                         
                       
                       = 
                     
                   
                   ; 
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         S 
                         ouput 
                       
                        
                       
                         ( 
                         
                           1 
                           , 
                           j 
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 c 
                                 2 
                               
                             
                             ) 
                           
                         
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               j 
                             
                             ) 
                           
                         
                       
                       · 
                       
                         ( 
                         
                           
                             
                               
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           c 
                                            
                                           
                                               
                                           
                                            
                                           2 
                                         
                                       
                                       , 
                                       
                                         c 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                                 - 
                               
                             
                           
                           
                             
                               
                                 
                                   S 
                                   input 
                                 
                                  
                                 
                                   ( 
                                   
                                     1 
                                     , 
                                     
                                       c 
                                       2 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 M 
                 output 
               
                
               
                 ( 
                 
                   3 
                   , 
                   j 
                 
                 ) 
               
             
             = 
             
               
                 
                   M 
                   input 
                 
                  
                 
                   ( 
                   
                     
                       i 
                       
                         c 
                          
                         
                             
                         
                          
                         2 
                       
                     
                     , 
                     
                       c 
                       2 
                     
                   
                   ) 
                 
               
               . 
             
           
         
       
     
         [0072]    It is worth nothing here that the difference (S input (i c2 , c 2 )−S input (1, c 2 )) is part of the value that will be used to store in a compressed way the whole  S   output  table. 
         [0073]    Also in this case, it is to be checked whether or not S output (3, j)≠S output (2, j) and eventually to identify the immediately less probable value than S input (i c2 , c 2 ) to be used in place thereof. 
         [0074]    In the exemplary numerical case, the output probability matrix is filled as follows 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                   
                       
                   
                    
                   4 
                 
               
               
                 6 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 7 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
             
           
         
       
     
       M output (1, j) M output (2, j) M output (3, j) 
       [0075]    At the end of this step there are at most two columns (the a 1 -th and the b 1 -th) in the output probability matrix different from the other columns. 
         [0076]    For sake of example, let us suppose that the condition 
         [0000]        H ( k,c   2 )·( S   input ( i   c2   ,c   2 )− S   input (1 ,c   2 ))≠ H ( k,a   1 )·( S   input (2 ,a   1 )− S   input (1 ,a   1 ))
 
         [0000]    is not satisfied. A different value S input (i c2 , c 2 ) is identified, which in the numerical example is used in place of S input (3, 5), thus obtaining the following alternative output probability matrix 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                   
                       
                   
                    
                   6 
                 
               
               
                 6 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 7 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
             
           
         
       
     
       M output (1, j) M output (2, j) M output (3, j) 
       [0077]    The values of the fourth row of the output matrix of values  S   output  are calculated starting from the a 1 -th symbol, then calculating in order the values of the symbols S output (4, b 1 ), S output (4, b 2 ) (if not yet calculated) and of the other symbols with a procedure similar to that used for filling in the third row and using practically the same formulae. At each calculation, it is to be checked whether or not there are two identical symbols for a same column of the output matrix  S   output , and in this case a different value should be chosen as done in the calculations for the third most probable values. 
         [0078]    A difference in respect to the algorithm used for filling the third row exists in that, in the algorithm for filling from the fourth row onwards, it may not be possible to exclude a priori that the logarithm of normalized probability of a value identified in this step be larger than the sum of two nonnull values stored in the input probability matrix. This case will be considered later and corresponds to the event in which a received symbol is assuming its value of fourth best probability of correctness and two other symbols are not assuming their values of maximum probability of correctness. 
         [0079]    Let us now suppose that this is not the case, as in the considered numerical example. The value S output (4, a 1 ) is calculated by looking at the matrix of input probabilities  M   input  to identify the a 3 -th symbol for which M input (i a3 , a 3 )≦M input (i, j)∀jε{1, . . . , dc}−{a 1 }, i≧2, a 3 ≠a 1  and (i a3 , a 3 )≠(i a2 , a 2 ), (2, b 1 ). This step corresponds to identifying the most probable value not belonging to the symbol a 1  and not corresponding to the values (i a2 , a 2 ), (2, b 1 ) already considered for the symbol a 1 . The value S output (4, a 1 ) is further calculated by calculating the value S output (4, a 1 ) and the corresponding logarithm of normalized probability M output (4, a 1 ) using the following formulae: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       output 
                     
                      
                     
                       ( 
                       
                         4 
                         , 
                         
                           a 
                           1 
                         
                       
                       ) 
                     
                   
                   = 
                     
                    
                   
                     
                       
                         
                           
                             
                               
                                 z 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         a 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         a 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         a 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         a 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               + 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         a 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           a 
                                            
                                           
                                               
                                           
                                            
                                           3 
                                         
                                       
                                       , 
                                       
                                         a 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                       
                         H 
                          
                         
                           ( 
                           
                             k 
                             , 
                             
                               a 
                               1 
                             
                           
                           ) 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         S 
                         ouput 
                       
                        
                       
                         ( 
                         
                           1 
                           , 
                           
                             a 
                             1 
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 a 
                                 3 
                               
                             
                             ) 
                           
                         
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 a 
                                 1 
                               
                             
                             ) 
                           
                         
                       
                       · 
                       
                         ( 
                         
                           
                             
                               
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           a 
                                            
                                           
                                               
                                           
                                            
                                           3 
                                         
                                       
                                       , 
                                       
                                         a 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                                 - 
                               
                             
                           
                           
                             
                               
                                 
                                   S 
                                   input 
                                 
                                  
                                 
                                   ( 
                                   
                                     1 
                                     , 
                                     
                                       a 
                                       3 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   M 
                   output 
                 
                  
                 
                   ( 
                   
                     4 
                     , 
                     
                       a 
                       1 
                     
                   
                   ) 
                 
               
               = 
               
                 
                   M 
                   input 
                 
                  
                 
                   ( 
                   
                     
                       i 
                       
                         a 
                          
                         
                             
                         
                          
                         3 
                       
                     
                     , 
                     
                       a 
                       3 
                     
                   
                   ) 
                 
               
             
             ; 
           
         
       
     
         [0080]    It is worth nothing here that the difference (S input (i a3 , a 3 )−S input (1, a 3 )) is part of the value that will be used to store in a compressed way the whole  S   output  table. 
         [0081]    The value S output (4, a 1 ) is further calculated by checking whether or not S output (4, a 1 )=S output (2, a 1 ) or S output (4, a 1 )=S output (3, a 1 ) and, in the affirmative case, restarting the procedure from point a) choosing a different pair (i a3 , a 3 ). 
         [0082]    In the exemplary numerical case, the pair (i a3 , a 3 ) is (2, 1). Therefore, the output probability matrix is being filled as follows: 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                   
                       
                   
                    
                   4 
                 
               
               
                 6 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 7 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
             
             
               
                 
                     
                 
               
               
                 10 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0083]    The value S output (4, b 1 ) is calculated by: 
         [0084]    a) looking at the matrix of input probabilities  M   input  to identify the b 3 -th symbol for which M input (i b3 , b 3 )≦M input (i, j)∀jε{1, . . . , dc}−{b 1 }, i≧2, b 3 ≠b 1  and (i b3 , b 3 )≠(i b2 , b 2 ), (2, a 1 ). This step corresponds to identifying the most probable value not belonging to the symbol b 1  and not corresponding to the values (i b2 , b 2 ), (2, a 1 ) already considered for the symbol b 1 ; 
         [0085]    b) calculating the value S output (4, b 1 ) and the corresponding logarithm of normalized probability M output (4, b 1 ) using the following formulae: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       S 
                       output 
                     
                      
                     
                       ( 
                       
                         4 
                         , 
                         
                           b 
                           1 
                         
                       
                       ) 
                     
                   
                   = 
                     
                    
                   
                     
                       
                         
                           
                             
                               
                                 z 
                                  
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         b 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         b 
                                         1 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         b 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       1 
                                       , 
                                       
                                         b 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               + 
                               
                                 
                                   H 
                                    
                                   
                                     ( 
                                     
                                       k 
                                       , 
                                       
                                         b 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                                 · 
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           b 
                                            
                                           
                                               
                                           
                                            
                                           3 
                                         
                                       
                                       , 
                                       
                                         b 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                       
                         H 
                          
                         
                           ( 
                           
                             k 
                             , 
                             
                               b 
                               1 
                             
                           
                           ) 
                         
                       
                     
                     = 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         S 
                         ouput 
                       
                        
                       
                         ( 
                         
                           1 
                           , 
                           
                             b 
                             1 
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 b 
                                 3 
                               
                             
                             ) 
                           
                         
                         
                           H 
                            
                           
                             ( 
                             
                               k 
                               , 
                               
                                 b 
                                 1 
                               
                             
                             ) 
                           
                         
                       
                       · 
                       
                         ( 
                         
                           
                             
                               
                                 
                                   
                                     S 
                                     input 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         i 
                                         
                                           b 
                                            
                                           
                                               
                                           
                                            
                                           3 
                                         
                                       
                                       , 
                                       
                                         b 
                                         3 
                                       
                                     
                                     ) 
                                   
                                 
                                 - 
                               
                             
                           
                           
                             
                               
                                 
                                   S 
                                   input 
                                 
                                  
                                 
                                   ( 
                                   
                                     1 
                                     , 
                                     
                                       b 
                                       3 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 M 
                 output 
               
                
               
                 ( 
                 
                   4 
                   , 
                   
                     b 
                     1 
                   
                 
                 ) 
               
             
             = 
             
               
                 
                   M 
                   input 
                 
                  
                 
                   ( 
                   
                     
                       i 
                       
                         b 
                          
                         
                             
                         
                          
                         3 
                       
                     
                     , 
                     
                       b 
                       3 
                     
                   
                   ) 
                 
               
               . 
             
           
         
       
     
         [0086]    It is worth nothing here that the difference (S input (i b3 , b 3 )−S input (1, b 3 )) is part of the value that will be used to store in a compressed way the whole  S   output  table. 
         [0087]    c) checking whether or not S output (4, b 1 )=S output (2, b 1 ) or S output (4, b 1 )=S output (3, b 1 ) and, in the affirmative case, restarting the procedure from point a) choosing a different pair (i b3 , b 3 ). 
         [0088]    In the exemplary numerical case, the pair (i b3 , b 3 ) is (2, 1). The output probability matrix is being filled as follows: 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                   
                       
                   
                    
                   4 
                 
               
               
                 6 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 7 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
             
             
               
                 
                     
                 
               
               
                 10 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
               
                 
                   10 
                    
                   
                       
                   
                 
               
               
                 
                     
                 
               
               
                 
                     
                 
               
             
           
         
       
     
         [0089]    Then the remaining values S output (4, j) for the other symbols are calculated neglecting the values of maximum probability of correctness and the already considered values S input (2, a 1 ) and S input (I c2 , c 2 ) through the following steps: 
         [0090]    a) identifying usable the first most probable value S input (i d3 , d 3 ) and its corresponding symbol d 1 , and 
         [0091]    b) identifying the usable second immediately most probable value S input (i c3 , c 3 ). 
         [0092]    The output probability matrix becomes 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                   
                       
                   
                    
                   4 
                 
               
               
                 6 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 7 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
             
             
               
                 
                   
                       
                   
                    
                   6 
                 
               
               
                 10 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   10 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
             
           
         
       
     
       M output (1, j) M output (2, j) M output (3, j), M output (4, j) 
       [0093]    At the end of this step there will be at most three columns (a 1 -th, b 1 -th and c 3 -th) different from the other columns in the output probability matrix  M   output . 
         [0094]    As stated before, it should be checked whether the logarithm of normalized probability of a value identified in this step for any symbol is larger than the sum of two nonnull values stored in the input probability matrix usable for that symbol, i.e.: 
         [0000]        M   input ( i,j )&gt; M   input ( i   1   ,j   1 )+ M   input ( i   2   ,j   2 ). 
         [0095]    This check has been schematically indicated in  FIG. 1  with the label  DOUBLE PATH CKR . Let us suppose that this check is positive for the symbol a 1 : 
         [0000]        M   input ( i   a3   ,a   3 )&gt; M   input ( i   a3-1   ,a   3-1 )+ M   input ( i   a3-2   ,a   3-2 ); 
         [0096]    In this case, the matrices  M   output  and  S   output  are filled in as follows: 
         [0000]    
       
         
           
             
                 
             
              
             
               
                 
                   
                     M 
                     output 
                   
                    
                   
                     ( 
                     
                       4 
                       , 
                       
                         a 
                         1 
                       
                     
                     ) 
                   
                 
                 = 
                 
                   
                     
                       M 
                       input 
                     
                      
                     
                       ( 
                       
                         
                           i 
                           
                             
                               a 
                                
                               
                                   
                               
                                
                               3 
                             
                             - 
                             1 
                           
                         
                         , 
                         
                           a 
                           
                             3 
                             - 
                             1 
                           
                         
                       
                       ) 
                     
                   
                   + 
                   
                     
                       M 
                       input 
                     
                      
                     
                       ( 
                       
                         
                           i 
                           
                             
                               a 
                                
                               
                                   
                               
                                
                               3 
                             
                             - 
                             2 
                           
                         
                         , 
                         
                           a 
                           
                             3 
                             - 
                             2 
                           
                         
                       
                       ) 
                     
                   
                 
               
               ; 
             
           
         
       
       
         
           
             
               
                 S 
                 output 
               
                
               
                 ( 
                 
                   4 
                   , 
                   
                     a 
                     1 
                   
                 
                 ) 
               
             
             = 
             
               
                 
                   S 
                   output 
                 
                  
                 
                   ( 
                   
                     1 
                     , 
                     
                       a 
                       1 
                     
                   
                   ) 
                 
               
               + 
               
                 
                   
                     
                       H 
                        
                       
                         ( 
                         
                           k 
                           , 
                           
                             a 
                             
                               3 
                               - 
                               1 
                             
                           
                         
                         ) 
                       
                     
                     
                       H 
                        
                       
                         ( 
                         
                           k 
                           , 
                           
                             a 
                             1 
                           
                         
                         ) 
                       
                     
                   
                   · 
                   
                     
                       ( 
                       
                         
                           
                             S 
                             input 
                           
                            
                           
                             ( 
                             
                               
                                 i 
                                 
                                   
                                     a 
                                      
                                     
                                         
                                     
                                      
                                     3 
                                   
                                   - 
                                   1 
                                 
                               
                               , 
                               
                                 a 
                                 
                                   3 
                                   - 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                         - 
                         
                           
                             S 
                             input 
                           
                            
                           
                             ( 
                             
                               1 
                               , 
                               
                                 a 
                                 
                                   3 
                                   - 
                                   1 
                                 
                               
                             
                             ) 
                           
                         
                       
                       ) 
                     
                     ++ 
                   
                 
                  
                 
                   
                     
                       H 
                        
                       
                         ( 
                         
                           k 
                           , 
                           
                             a 
                             
                               3 
                               - 
                               2 
                             
                           
                         
                         ) 
                       
                     
                     
                       H 
                        
                       
                         ( 
                         
                           k 
                           , 
                           
                             a 
                             1 
                           
                         
                         ) 
                       
                     
                   
                   · 
                   
                     
                       ( 
                       
                         
                           
                             S 
                             input 
                           
                            
                           
                             ( 
                             
                               
                                 i 
                                 
                                   
                                     a 
                                      
                                     
                                         
                                     
                                      
                                     3 
                                   
                                   - 
                                   2 
                                 
                               
                               , 
                               
                                 a 
                                 
                                   3 
                                   - 
                                   2 
                                 
                               
                             
                             ) 
                           
                         
                         - 
                         
                           
                             S 
                             input 
                           
                            
                           
                             ( 
                             
                               1 
                               , 
                               
                                 a 
                                 
                                   3 
                                   - 
                                   2 
                                 
                               
                             
                             ) 
                           
                         
                       
                       ) 
                     
                     . 
                   
                 
               
             
           
         
       
     
         [0097]    The symbols a 3-1  and a 3-2  may be different, otherwise they stay on the same column of the input matrix and therefore they cannot be taken. It may happen that, for a same symbol s, the second and third value of the output probability values are equal to values of a same symbol l of the input probability matrix, 
         [0000]        M   output (2 ,s )= M   input ( . . . ,  l ); 
         [0000]        M   output (3 ,s )= M   input ( . . . ,  l ) 
         [0098]    This one may not be accepted as double error but such possibility cannot be excluded. 
         [0099]    In fact two symbols may be looked for:
       S1′=S input (i d , d)−S input (1, d) such that H(k, d)·(S input (i d , d)−S input (1, d))=H(k, n)·(S input (2, n)−S input (1, n))   S2′=S input (i 1 , t)−S input (1, t) such that H(k, t)·(S input (i 1 , t)−S input (1, t))=H(k, z)·(S input (2, Z)−S input (1, z))       
 
         [0102]    These two symbols give the same contribution of the original one (in term of symbol of the Galois Field) but are not on the same column. 
         [0103]    The magnitude of the two pairs is computed and compared: the smallest between the triplet {M input (i 1 , 1), (M input (i d , d)+M input (2, Z)), (M input (i 1 , t)+M input (2, n))} is the selected magnitude. Concerning the S output , they give exactly the same contribution. 
         [0104]    The above check should be carried out for every symbol. The algorithm could be stopped at this step, because in general four alternative values for each symbol are sufficient. 
         [0105]    As an alternative, in the unlikely event that four alternative values for each symbols be insufficient, a fifth step may be executed. 
         [0106]    The fifth most probable values are calculated starting from the different columns (a 1 -th, b 1 -th and c 3 -th) following the same reasoning used for calculating the symbol S output (4, a 1 ); then the symbol S output (5, c 3 ) is calculated (if it has not yet been calculated) as done for the symbol S output (3, b 1 ); finally the remaining symbols are calculated as done for the other symbols S output (3, j). 
         [0107]    At each calculation, it is to be checked whether or not there two identical symbols for a same column of the output matrix  S   output  have been calculated, and in that case a different value should be chosen as done in the calculations for the third most probable values. As for the previous step, the check DOUBLE PATH CKR should be carried out. Obviously here we have three possibilities of double path. 
         [0108]    At the end of this fifth step, the output probability matrix is as follows: 
         [0000]    
       
         
           
             
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
               
                 0 
               
             
             
               
                 2 
               
               
                 4 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
               
                 2 
               
             
             
               
                 
                   
                       
                   
                    
                   4 
                 
               
               
                 6 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 7 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
               
                 
                   4 
                    
                   
                       
                   
                 
               
             
             
               
                 
                   
                       
                   
                    
                   6 
                 
               
               
                 10 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   10 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
               
                 
                   6 
                    
                   
                       
                   
                 
               
             
             
               
                 7 
               
               
                 11 
               
               
                 7 
               
               
                 7 
               
               
                 11 
               
               
                 7 
               
               
                 7 
               
             
           
         
       
     
       M output (1, j), M output (2, j), M output (3, j) M output (4, j), M output (5, j) 
       [0109]    It would be possible to continue calculating the other less probable values by repeating the above procedure, though five values for each symbol are commonly considered enough for every practical application. 
         [0110]    The fifth candidate has the same exception of the fourth one. There are three possibilities that we indicate for simplicity using the matrix  M   output : 
         [0111]    M output (2, i)+M output (3, i) 
         [0112]    M output (2, i)+M output (4, i) 
         [0113]    M output (3, i)+M output (4, i) 
         [0114]    Again, if the symbols that generate one or all this pairs are on the same column in the input matrix, a search to identify S1′, S2′, S3′ is performed and all the possibilities are analyzed. Note that in case a double error is present in fourth candidate, it is not necessary to look for it in the fifth. 
         [0115]    The above algorithm is summarized in Figures from  1  to  6 , that will appear self-explaining in view of the above discussion and for this reason will not be illustrated further. 
         [0116]    The above disclosed method may be implemented in a hardware LIST decoder or with a software computer program executed by a computer. 
         [0117]    The method is relatively simple because it does not require calculation of Fourier transforms or logarithms, but additions and multiplications in a Galois field, thus it may be implemented in real time applications. 
         [0118]    Another key advantage of the present invention is related to the amount of memory used to store the temporary values R ji  that are basically the table  M   output  and  S   output  for each parity check. Instead of storing the whole tables a great storage reduction comes from the following rules that are part of the present invention and that can be easily generalized by those expert in the field. 
         [0119]    In practice, the output tables  M   output  and  S   output  may be calculated through very simple operations from relatively few values. Therefore, instead of storing the whole output tables  M   output  and  S   output , that may be very large and use a great amount of memory space, it is possible equivalently to store the few values that are necessary to calculate them. This will result in a great reduction of memory space dedicated for storing the output tables. 
         [0120]    The present embodiment is focused on the approach of computing the first five candidates, but the invention is not limited to this case. Given a parity check output  M   output  it can be demonstrated that there are 14 different values in the table. To calculate the fifth candidates for every symbols just 14=2+3+4+5 parameters are necessary. 
         [0121]    To recover the information to reproduce the whole tables  M   output  and  S   output  the following values may be stored:
       the four values indicating the indexes of the special columns: a 1 , b 1 , c 2 , d 3 ;   the values of S input (1, i)∀i   for column a 1 , that is the first column that differentiates from the others, symbols S input (2, b 1 )−S input (1, b 1 )) that give S input (2, a 1 ) and analogous differences for S input (s, a 1 ) with s=3, 4;       
 
         [0125]    analogously, for column b 1 , that is the second column that differentiates from the others, the three differences already highlighted in the previous section;
       analogously for column c 2 , that is the third column that differentiates from the others, the two differences already highlighted in the previous section;   for the last optional step, for column d 3  that is the fourth column that differentiates from the others, the differences already highlighted in the previous section.       
 
         [0128]    When five different candidates are considered, the storage of S output (5, i) is not required. 
         [0129]    Overall memory used to represent  M   output  and  S   output , supposing check degree equal to dc, includes the 14 different entries of  M   output , the (dc+9) GF values and four indexes to identify the special columns. This represents a great improvement in respect to the prior art that would involve storing dc*n GF values and dc*n+1 probabilities. 
       Decoder Architecture 
       [0130]    A macro-architecture suggested for the implementation of the algorithm is depicted in  FIG. 7 . The meaning and the function executed by each block is summarized in the following table. 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 WM 
                 Memory device storing probability 
               
               
                   
                   
                 values of the input probability 
               
               
                   
                   
                 matrix  M   input   
               
               
                   
                 FIFO 
                 FIFO buffer: it hold Q ij  to make them 
               
               
                   
                   
                 available for being added to R ij  and 
               
               
                   
                   
                 fed Hard decision Block and WM. 
               
               
                   
                 SORT PMF 
                 Logic circuit block adapted to sort 
               
               
                   
                   
                 the probability values stored in the 
               
               
                   
                   
                 input probability matrix  M   input   
               
               
                   
                 SPC 
                 Circuit block for carrying out the 
               
               
                   
                   
                 parity check SPC 
               
               
                   
                 CORRECTION 
                 Memory device that stores R ij , the 
               
               
                   
                 MEM 
                 output of SPC. It is used to generate 
               
               
                   
                   
                 on the fly input to SORT PMF block 
               
               
                   
                 HD&amp;SYND 
                 Hard Decision and Syndrome 
               
               
                   
                   
                 computation 
               
               
                   
                   
               
             
          
         
       
     
         [0131]    The memory WM contains the PMFs of the symbols At the beginning, they are initialized with the demodulator (or detector) outputs and then they are updated accordingly to the decoding algorithm schedule. 
         [0132]    The variable-to-check PMF are first sorted to identify the first n candidates magnitudes (five magnitudes in the preferred implementation over GF(2 3 )). The remaining magnitudes are assumed to be equal to the fifth. 
         [0133]    The sorted PMF are passed to the SPC block that performs the CNP (computation of R ji ). The CORRECTION MEM contains the check-to-variable messages R ji . The memory size can be greatly reduced following the rules given in the last part of the present disclosure.