# Patent

## Title
Method and apparatus of candidate list augmentation for channel coding system

## Abstract

The present invention discloses a candidate list augmentation apparatus with dynamic compensation in the coded MIMO systems. The proposed path augmentation technique in the present invention can expand the candidate paths derived from the detector to a distinct and larger list before computing the soft value of each bit. Consequently, the detector is allowed to deliver a smaller list, leading to reduction in computation complexity. Moreover, an additive correction term is introduced to dynamically compensate the approximation inaccuracy in the soft value generation, which improves the efficiency and performance of the coded MIMO systems.

## Background
BACKGROUND OF THE INVENTION
1. Field of the Invention
The invention relates to a candidate list augmentation apparatus and method for channel coding system, and more particularly, a candidate list augmentation apparatus which is able to detect signal with dynamic compensation in the multi-input multi-output (MIMO) channel coding systems.
2. Description of the Related Art
Multiple input multiple output (MIMO) technology draws great attention due to its ability to improve transmission efficiency. Among several MIMO detection schemes, maximum likelihood (ML) detection is one of the most well known in the art which is being commonly used to fully utilize the diversity gain. With an additive white Gaussian channel noise assumption, ML detection can be reduced to a closest-point-search problem in a given lattice. Moreover, although MIMO system performance is boosted by the diversity gain, channel coding is often employed to provide extra coding gain such that systems are allowed to perform better in case of lower signal-to-noise-ratio (SNR). Since exhaustive search is infeasible for large number of antennas or high level signal modulation, sphere decoding has been proposed to perform exhaustive search after confining the search range by a radius. With properly chosen radius, sphere decoding has been proved to approach the performance of ML detection.
Please refer to FIG. 1 for a block diagram schematically showing a conventional MIMO system 100 with channel coding schemes. The conventional MIMO system 100 includes a channel encoder 102, a spatial mapping device 104, a transmit device 106, a receive device 108, a sphere decoder 110, and a channel decoder 112. Assume that the transmit device 106 includes Nt transmit antennas and the receive device 108 includes Nr antennas. The channel encoder 102 is utilized to channel code the original signal u and generate the coded bits x=[x(1), x(2), . . . , x(L)]T. The spatial mapping device 104 then modulates the coded bits x through L time slots. Here, Each vector x(t)=[x1(t), x2(t), . . . , xNt×2Mc(t)] with the time index t is mapped to the transmitted vector {tilde over (s)}(1)=[{tilde over (s)}1(t),{tilde over (s)}2(t) . . . {tilde over (s)}Nt(t)]T by {tilde over (M)}(•), which maps 2Mc bits to a complex signal. For simplicity, the spatial mapping in the spatial mapping device 104 refers to direct spatial multiplexing, and M2-QAM-mapped signals are considered henceforth.
After mapping the signal, the transmit device 106 transmits through the complex signal based on the transmitted vector {tilde over (s)}(t) and the receive device 108 receives the real signal according to the received vector {tilde over (y)}(t). The relation between the transmitted vector {tilde over (s)}(t) and the received vector {tilde over (y)}(t) can be expressed by:

{tilde over (y)}(t)={tilde over (H)}(t){tilde over (s)}(t)+ñ(t)  (1)

where the channel {tilde over (H)}(t) is an Nr×Nt matrix of independent and identically distributed (i.i.d.) complex Gaussian random variables; ñ(t) is an Nr×1 i.i.d. complex Gaussian noise vector. The complex model in the equation (1) can be further rewritten as:





  
    
      
        
          y
          
            (
            t
            )
          
        
        =
        
          
            [
            
              
                
                  
                    R
                    ⁢
                    
                      {
                      
                        
                          y
                          ~
                        
                        
                          (
                          t
                          )
                        
                      
                      }
                    
                  
                
              
              
                
                  
                    L
                    ⁢
                    
                      {
                      
                        
                          y
                          ~
                        
                        
                          (
                          t
                          )
                        
                      
                      }
                    
                  
                
              
            
            ]
          
          =
          
            
              
                
                  [
                  
                    
                      
                        
                          
                            R
                            ⁢
                            
                              {
                              
                                
                                  y
                                  ~
                                
                                
                                  (
                                  t
                                  )
                                
                              
                              }
                            
                          
                          ,
                        
                      
                      
                        
                          
                            -
                            L
                          
                          ⁢
                          
                            {
                            
                              
                                H
                                ~
                              
                              
                                (
                                t
                                )
                              
                            
                            }
                          
                        
                      
                    
                    
                      
                        
                          
                            L
                            ⁢
                            
                              {
                              
                                
                                  H
                                  ~
                                
                                
                                  (
                                  t
                                  )
                                
                              
                              }
                            
                          
                          ,
                        
                      
                      
                        
                          R
                          ⁢
                          
                            {
                            
                              
                                y
                                ~
                              
                              
                                (
                                t
                                )
                              
                            
                            }
                          
                        
                      
                    
                  
                  ]
                
                ⁡
                
                  [
                  
                    
                      
                        
                          R
                          ⁢
                          
                            {
                            
                              
                                s
                                ~
                              
                              
                                (
                                t
                                )
                              
                            
                            }
                          
                        
                      
                    
                    
                      
                        
                          L
                          ⁢
                          
                            {
                            
                              
                                s
                                ~
                              
                              
                                (
                                t
                                )
                              
                            
                            }
                          
                        
                      
                    
                  
                  ]
                
              
              +
              
                [
                
                  
                    
                      
                        R
                        ⁢
                        
                          {
                          
                            
                              n
                              ~
                            
                            
                              (
                              t
                              )
                            
                          
                          }
                        
                      
                    
                  
                  
                    
                      
                        L
                        ⁢
                        
                          {
                          
                            
                              n
                              ~
                            
                            
                              (
                              t
                              )
                            
                          
                          }
                        
                      
                    
                  
                
                ]
              
            
            =
            
              
                
                  H
                  
                    (
                    t
                    )
                  
                
                ⁢
                
                  s
                  
                    (
                    t
                    )
                  
                
              
              +
              
                n
                
                  (
                  t
                  )
                
              
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




where R{•} and L{•} refer to the real and the imaginary parts, respectively, of the complex signal s(t). Thus, the Nt-dimensional complex M2-QAM signals s(t) are transformed into 2Nt-dimensional real M-PAM signals y(t). For simpler notation, the time index t will be omitted hereafter.

Based on the equation (2), ML solution can be derived by searching all over the 2Nt-dimensional constellation space Ω2Nt for the minimizer:




  
    
      
        
          
            s
            ^
          
          ML
        
        =
        
          
            arg
          
          ⁢
          
            
              max
              
                
                  s
                  ′
                
                ∈
                
                  Ω
                  
                    2
                    ⁢
                    
                      N
                      t
                    
                  
                
              
            
            ⁢
            
              
                
                
                  y
                  -
                  
                    Hs
                    ′
                  
                
                
              
              2
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




where the cost function ∥•∥2 refers to Euclidean norm. As shown in the equation (3), the exhaustive search for the minimizer ŝML becomes infeasible since the computation grows exponentially with Nt and L. Therefore, the sphere decoder 110 in the conventional MIMO system utilizes sphere decoding algorithm as a means to solve the closest-lattice-point searching problem.

The sphere decoder 110 first confines the search range by a predefined radius r; and only the path metric of the s′ in the hypersphere ∥y−Hs′∥2≦r2 will be compared. That is, the equation (2) can be computed by:




  
    
      
        
          
            
              s
              ^
            
            ML
          
          ≈
          
            
              s
              ^
            
            SD
          
        
        =
        
          
            arg
          
          ⁢
          
            
              min
              
                
                  
                    s
                    ′
                  
                  ∈
                  
                    Ω
                    
                      2
                      ⁢
                      
                        N
                        t
                      
                    
                  
                
                ,
                
                  
                    
                      
                      
                        y
                        -
                        
                          Hs
                          ′
                        
                      
                      
                    
                    2
                  
                  ≤
                  
                    r
                    2
                  
                
              
            
            ⁢
            
              
                
                
                  y
                  -
                  
                    Hs
                    ′
                  
                
                
              
              2
            
          
        
      
    
    
      
        (
        4
        )
      
    
  




Here, if the radius r is chosen properly such that at least one path s′ satisfies the radius constraint.
Next, the sphere decoder 110 will preprocess on y to transform the equation (4) into a tree-search problem. By QR-decomposition, for instance, the channel matrix is decomposed by H=QR where QTQ=I2Nr, an identity matrix of size 2Nr, and R is a 2Nt×2Nt upper triangular matrix. By multiplying y with QT, the sphere decoder 110 can transformed the equation (4) into:




  
    
      
        
          
            s
            ^
          
          ML
        
        =
        
          
            arg
          
          ⁢
          
            
              min
              
                
                  s
                  ′
                
                ∈
                
                  Ω
                  
                    2
                    ⁢
                    
                      N
                      t
                    
                  
                
              
            
            ⁢
            
              
                
                
                  q
                  -
                  
                    Rs
                    ′
                  
                
                
              
              2
            
          
        
      
    
    
      
        (
        5
        )
      
    
  




where q=[q1, q2, . . . , q2Nt]=QTy. Each s′ in Ω2Nt is defined as a “path” that traverses from the root to the leaf of the search tree. Every path consists of 2Nt nodes representing the 2Nt points of the 2Nt-layered tree. Moreover, the cost function of each path, i.e. ∥q−Rs′∥2, will be referred to “path metric” and can be calculated by:





  
    
      
        
          
            
            
              q
              -
              
                Rs
                ′
              
            
            
          
          2
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              
                2
                ⁢
                Nt
              
            
            ⁢
            
              
                (
                
                  
                    q
                    i
                  
                  -
                  
                    
                      ∑
                      
                        j
                        =
                        i
                      
                      
                        2
                        ⁢
                        Nt
                      
                    
                    ⁢
                    
                      
                        R
                        
                          i
                          ,
                          j
                        
                      
                      ⁢
                      
                        s
                        j
                      
                    
                  
                
                )
              
              2
            
          
          =
          
            
              ∑
              
                i
                =
                1
              
              
                2
                ⁢
                Nt
              
            
            ⁢
            
              e
              ⁡
              
                (
                
                  s
                  
                    (
                    i
                    )
                  
                
                )
              
            
          
        
      
    
    
      
        (
        6
        )
      
    
  




where s(i) represents the i-th to 2Nt-th elements of s′, that is, s(i)=[si, si+1, . . . , s2Nt]T. Moreover, the partial Euclidean distance (PED) of s(i), T(s(i)), is defined by:





  
    
      
        
          T
          ⁡
          
            (
            
              s
              
                (
                i
                )
              
            
            )
          
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              
                2
                ⁢
                Nt
              
            
            ⁢
            
              
                (
                
                  
                    q
                    
                      i
                      ′
                    
                  
                  -
                  
                    
                      ∑
                      
                        j
                        =
                        
                          i
                          ′
                        
                      
                      
                        2
                        ⁢
                        Nt
                      
                    
                    ⁢
                    
                      
                        R
                        
                          
                            i
                            ′
                          
                          ,
                          j
                        
                      
                      ⁢
                      
                        s
                        j
                      
                    
                  
                
                )
              
              2
            
          
          =
          
            
              T
              ⁡
              
                (
                
                  s
                  
                    (
                    
                      i
                      +
                      1
                    
                    )
                  
                
                )
              
            
            +
            
              e
              ⁡
              
                (
                
                  s
                  
                    (
                    i
                    )
                  
                
                )
              
            
          
        
      
    
    
      
        (
        7
        )
      
    
  




Based on this conventional sphere decoding algorithm, the minimizer ŝML can be found as long as each path has been searched. However, the traditional sphere decoding algorithm remains a major challenge in acquiring accurate probabilistic information. Limited by the complex computation of sphere decoding, and inconstant decoding throughput could cause inefficient VLSI implementation.
Different from the sphere decoding algorithm that outputs only the ML path, the conventional MIMO system utilizes the modified list sphere decoding algorithm to deliver a candidate list L that consists of the most reliable paths. Please refer to FIG. 2 for a block diagram schematically showing another conventional MIMO system 200 with list sphere coding schemes. The conventional MIMO system 200 includes a channel encoder 202, a spatial mapping device 204, a transmit device 206, a receive device 208, a list sphere decoder 210, and a channel decoder 216. Since the elements of the same name in the FIG. 1 and FIG. 2 have the same function and operation, detailed description is omitted for the sake of brevity. The main different between the MIMO systems 100 and 200 is that the MIMO systems 200 further includes the list sphere decoder 210. The list sphere decoder 210 includes a candidate list generation device 212 and a soft value generation device 214. The candidate list generation device 212 is utilized to generate a candidate list L. Assume that |L| is the list size. Based on the system model in the equation (2), the most reliable |L| paths are equivalent to the paths corresponding to the least |L| path metrics. After generating the candidate list L, the soft value generation device 214 then computes the soft input signal from the list L for the subsequent channel decoder 216. Different soft input signal can result in different error correcting capability for the following channel decoding. The operation of the candidate list generation device 212 and the soft value generation device 214 are further detailed as follows.
Let M(•) denote the M-PAM mapping function such that sk=M(xk,1, xk,2, . . . , xk,Mc). For any path s′ε L, the soft value of xk,j is defined by its “a posteriori” probabilities:




  
    
      
        
          
            
              
                L
                ⁡
                
                  (
                  
                    x
                    
                      k
                      ,
                      j
                    
                  
                  )
                
              
              =
              
                log
                ⁢
                
                  
                    Pr
                    ⁡
                    
                      (
                      
                        
                          x
                          
                            k
                            ,
                            j
                          
                        
                        =
                        
                          0
                          |
                          y
                        
                      
                      )
                    
                  
                  
                    Pr
                    ⁡
                    
                      (
                      
                        
                          x
                          
                            k
                            ,
                            j
                          
                        
                        =
                        
                          1
                          |
                          y
                        
                      
                      )
                    
                  
                
              
            
          
        
        
          
            
              =
              
                
                  log
                  ⁢
                  
                    
                      Pr
                      ⁡
                      
                        (
                        
                          
                            x
                            
                              k
                              ,
                              j
                            
                          
                          =
                          0
                        
                        )
                      
                    
                    
                      Pr
                      ⁡
                      
                        (
                        
                          
                            x
                            
                              k
                              ,
                              j
                            
                          
                          =
                          1
                        
                        )
                      
                    
                  
                
                +
                
                  log
                  ⁢
                  
                    
                      Pr
                      ⁡
                      
                        (
                        
                          
                            y
                            |
                            
                              x
                              
                                k
                                ,
                                j
                              
                            
                          
                          =
                          0
                        
                        )
                      
                    
                    
                      Pr
                      ⁡
                      
                        (
                        
                          
                            y
                            |
                            
                              x
                              
                                k
                                ,
                                j
                              
                            
                          
                          =
                          1
                        
                        )
                      
                    
                  
                
              
            
          
        
      
    
    
      
        
          
            
              (
              8
              )
            
          
        
        
          
            
              
            
          
        
        
          
            
              (
              9
              )
            
          
        
      
    
  




The first term in the equation (9), which is the “a priori” information, is zero for the ML detection or can be computed by the extrinsic information provided by the channel decoder in an iterative detection decoding process. The second term in the equation (9) can be computed by:





  
    
      
        
          log
          ⁢
          
            
              Pr
              ⁡
              
                (
                
                  
                    y
                    |
                    
                      x
                      
                        k
                        ,
                        j
                      
                    
                  
                  =
                  0
                
                )
              
            
            
              Pr
              ⁡
              
                (
                
                  
                    y
                    |
                    
                      x
                      
                        k
                        ,
                        j
                      
                    
                  
                  =
                  1
                
                )
              
            
          
        
        =
        
          log
          ⁢
          
            
              
                ∑
                
                  
                    s
                    ′
                  
                  ∈
                  
                    Ω
                    
                      j
                      ,
                      0
                    
                  
                
              
              ⁢
              
                Pr
                ⁡
                
                  (
                  
                    y
                    |
                    
                      s
                      ′
                    
                  
                  )
                
              
            
            
              
                ∑
                
                  
                    s
                    ′
                  
                  ∈
                  
                    Ω
                    
                      j
                      ,
                      1
                    
                  
                
              
              ⁢
              
                Pr
                ⁡
                
                  (
                  
                    y
                    |
                    
                      s
                      ′
                    
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        10
        )
      
    
  
  
    
      
        ≈
        
          
            1
            
              2
              ⁢
              
                σ
                2
              
            
          
          ⁢
          
            (
            
              
                
                  min
                  
                    
                      s
                      ′
                    
                    ∈
                    
                      Ω
                      
                        j
                        ,
                        1
                      
                    
                  
                
                ⁢
                
                  
                    
                    
                      y
                      -
                      
                        Hs
                        ′
                      
                    
                    
                  
                  2
                
              
              -
              
                
                  min
                  
                    
                      s
                      ′
                    
                    ∈
                    
                      Ω
                      
                        j
                        ,
                        0
                      
                    
                  
                
                ⁢
                
                  
                    
                    
                      y
                      -
                      
                        Hs
                        ′
                      
                    
                    
                  
                  2
                
              
            
            )
          
        
      
    
    
      
        (
        11
        )
      
    
  
  
    
      
        ≈
        
          
            1
            
              2
              ⁢
              
                σ
                2
              
            
          
          ⁢
          
            (
            
              
                
                  min
                  
                    
                      s
                      ′
                    
                    ∈
                    
                      
                        Ω
                        
                          j
                          ,
                          1
                        
                      
                      ⋂
                      L
                    
                  
                
                ⁢
                
                  
                    
                    
                      y
                      -
                      
                        Hs
                        ′
                      
                    
                    
                  
                  2
                
              
              -
              
                
                  min
                  
                    
                      s
                      ′
                    
                    ∈
                    
                      
                        Ω
                        
                          j
                          ,
                          0
                        
                      
                      ⋂
                      L
                    
                  
                
                ⁢
                
                  
                    
                    
                      y
                      -
                      
                        Hs
                        ′
                      
                    
                    
                  
                  2
                
              
            
            )
          
        
      
    
    
      
        (
        12
        )
      
    
  




Where σ2 is the noise variance, and Ωj,b is the set of all path s′ having xk,j=b for b=0, 1. That is, Ωj,0 represents the set of all s′ having xk,j=0, and Ωj,0 represents the set of all s′ having xk,j=1. Usually, the candidate list generation device 212 will generate a sufficiently large list to ensure a high probability in finding the true minimizer in the equation (11) with (12). With preprocessing, the equation (12) will be replaced by:





  
    
      
        
          1
          
            2
            ⁢
            
              σ
              2
            
          
        
        ⁢
        
          (
          
            
              
                min
                
                  
                    s
                    ′
                  
                  ∈
                  
                    
                      Ω
                      
                        j
                        ,
                        1
                      
                    
                    ⋂
                    L
                  
                
              
              ⁢
              
                
                  
                  
                    q
                    -
                    
                      Rs
                      ′
                    
                  
                  
                
                2
              
            
            -
            
              
                min
                
                  
                    s
                    ′
                  
                  ∈
                  
                    
                      Ω
                      
                        j
                        ,
                        0
                      
                    
                    ⋂
                    L
                  
                
              
              ⁢
              
                
                  
                  
                    q
                    -
                    
                      Rs
                      ′
                    
                  
                  
                
                2
              
            
          
          )
        
      
    
    
      
        (
        13
        )
      
    
  




However, when one of the sets Ωj,0 and Ωj,0 can not find the path s′ in the list L (i.e. Ωj,0∩L=0 or Ωj,1∩L=0), it is impossible to find the minimizer in an empty set, and the minima is often approximated by a predefined large constant. Being the soft input signals to the subsequent channel decoder 216, the additional interference resulted from the approximation inaccuracy can degrade the error performance. Although the degradation can be mitigated by increasing the list size to reduce the probability of Ωj,0∩L (or Ωj,1∩L), being an empty set, the computation complexity in generating the candidate list also increases.
Therefore, to solve the above-mentioned problems, the present invention proposes a novel candidate list augmentation apparatus for channel coding system and method thereof along with dynamic compensation to improve the efficiency and performance of the coded MIMO systems.
SUMMARY OF THE INVENTION
It is therefore one of the many objectives of the claimed invention to provide candidate list augmentation apparatus and method thereof along with dynamic compensation to improve the efficiency and performance of the coded MIMO systems.
According to the claimed invention, a candidate list augmentation device is disclosed. The candidate list augmentation device includes a candidate list generation device for receiving an input signal within a coded MIMO system and generating a candidate list according to said input signal; a path augmentation device, coupled to said candidate list generation device, for augmenting paths in the candidate list according to said candidate list and generate an augmented list; and a soft value generation device, coupled to said candidate list generation device and said path augmentation device, for comparing said input signal and said augmented list and generating a soft value according to said input signal, said candidate list and said augmented list, wherein said soft value is utilized for error correcting in decoding said input signal.
Also according to the claimed invention, a candidate list augmentation method with low-complexity soft value generation for the coded MIMO systems is disclosed. The candidate list augmentation method includes (1) receiving an input signal and generating a candidate list according to said input signal; (2) generating an augmented list according to said candidate list; and (3) comparing said input signal and said augmented list and generating a soft value according to said input signal, said candidate list and said augmented list, wherein said soft value is utilized for error correcting in decoding said input signal.
Below, the embodiments of the present invention are described in detail in cooperation with the attached drawings to make easily understood the objectives, technical contents, characteristics and accomplishments of the present invention.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram schematically showing a conventional MIMO system with channel coding schemes;
FIG. 2 is a block diagram schematically showing another conventional MIMO system with list sphere coding schemes;
FIG. 3 is a block diagram schematically showing a MIMO system with candidate list augmentation scheme according to the present invention;
FIG. 4 is diagram schematically showing an example of the operation of the path augmentation device according to the present invention; and
FIG. 5 is a diagram schematically showing a simulation result according to the present invention.



DETAILED DESCRIPTION OF THE INVENTION
The present invention provides a candidate list augmentation device and method thereof for channel coding systems with dynamic compensation to improve the efficiency and performance of the channel coding system especially coded MIMO systems
Please refer to FIG. 3 for a block diagram schematically showing a MIMO system 300 with candidate list augmentation scheme according to the present invention. The MIMO system 300 includes a channel encoder 302, a spatial mapping device 304, a transmit device 306, a receive device 308, a list sphere decoder 310, and a channel decoder 318. The list sphere decoder 310 includes a candidate list generation device 312, a soft value generation device 314, and a path augmentation device 316. The candidate list generation device 312 is mainly responsible for receiving an input signal within the coded MIMO system and generating a candidate list according to this input signal. As for the path augmentation device 316 which is coupled to the candidate list generation device 312, it is responsible for augmenting paths in the candidate list according to the candidate list and then generate an augmented list. The soft value generation device 314 which is coupled to the candidate list generation device 312 and the path augmentation device 316 provides comparison for the input signal and the augmented list, and then generates a soft value according to the input signal, the candidate list and the augmented list, wherein said soft value is utilized for error correcting in decoding the input signal. Since the elements of the same name in the FIG. 2 and FIG. 3 have the same function and operation, detailed description is omitted for the sake of brevity. In the present invention, the path augmentation device 316 is applied to equivalently provide a larger candidate list, and the probability of failing to find the minimizer in the augmented list is reduced accordingly. That is, the path augmentation device 316 can be treated as an enhancement; no modifications are required for the candidate list generation device 312 and the soft value generation device 314 based on the conventional schemes.
For the soft value L(xk,j) computation, the path augmentation device 316 will expand each path s′ in L to M paths by first duplicating s′ M−1 times. Next, each the k-th element of the M identical paths is replaced by a distinct ωj from Ω={ωj|j=0, 1, . . . ,M−1}, the M symbols of M-PAM constellation. This duplicating-and-replacing procedure continues until all the paths in L are examined. As a result, L is expended to Lk and |Lk|=M×|L|. Although identical paths may be found in Lk, Ωj,0∩Lk or Ωj,1∩Lk will never be empty sets since the augmented list contains all constellation points at the k-th layer. Besides, the paths in L are believed to be more reliable, and the augmented list is supposed to be reliable as well. It can be inferred that:




  
    
      
        
          
            
              min
              
                
                  s
                  ′
                
                ∈
                
                  Ω
                  
                    j
                    ,
                    0
                  
                
              
            
            ⁢
            
              
                
                
                  y
                  -
                  
                    Hs
                    ′
                  
                
                
              
              2
            
          
          ≈
          
            
              min
              
                
                  s
                  ′
                
                ∈
                
                  
                    Ω
                    
                      j
                      ,
                      0
                    
                  
                  ⋂
                  
                    L
                    K
                  
                
              
            
            ⁢
            
              
                
                
                  y
                  -
                  
                    Hs
                    ′
                  
                
                
              
              2
            
          
        
        ⁢
        
          

        
        ⁢
        And
      
    
    
      
        (
        14
        )
      
    
  
  
    
      
        
          
            min
            
              
                s
                ′
              
              ∈
              
                Ω
                
                  j
                  ,
                  1
                
              
            
          
          ⁢
          
            
              
              
                y
                -
                
                  Hs
                  ′
                
              
              
            
            2
          
        
        ≈
        
          
            min
            
              
                s
                ′
              
              ∈
              
                
                  Ω
                  
                    j
                    ,
                    1
                  
                
                ⋂
                
                  L
                  K
                
              
            
          
          ⁢
          
            
              
              
                y
                -
                
                  Hs
                  ′
                
              
              
            
            2
          
        
      
    
    
      
        (
        15
        )
      
    
  




Moreover, the path metric of the j-th expanded path from s′ can be computed by





  
    
      
        
          T
          ⁡
          
            (
            
              s
              ′
            
            )
          
        
        +
        
          
            (
            
              
                Δ
                i
              
              ⁢
              
                R
                
                  i
                  ,
                  i
                
              
            
            )
          
          2
        
        +
        
          2
          ⁢
          
            (
            
              
                y
                i
              
              -
              
                
                  ∑
                  
                    j
                    =
                    i
                  
                  
                    2
                    ⁢
                    
                      
                    
                    ⁢
                    
                      N
                      t
                    
                  
                
                ⁢
                
                  
                    R
                    
                      i
                      ,
                      j
                    
                  
                  ⁢
                  
                    S
                    j
                  
                
              
            
            )
          
          ⁢
          
            R
            
              i
              ,
              i
            
          
          ⁢
          
            Δ
            i
          
        
      
    
    
      
        (
        16
        )
      
    
  




where Δj=sk−ωj for j=0, 1, . . . , M−1.

For example, please refer to FIG. 4 for a diagram schematically showing an example of the operation of the path augmentation device 316 according to the present invention. Assume that the path augmentation device 316 is used for computing L(x5,0) and L(x5,1) in a 16-QAM 4×4 MIMO system. The equivalent 4-PAM 8-layered tree can be represented by an 8-stage trellis diagram. Each path s′ in L corresponds to a path in the trellis. In this example, s′={+1,−1,−1,+1,+3,−1,−3,−1}, M=4, and Ω={−3,−1,+1,+3}. The path augmentation device 316 can expand the path s′ to the four distinct path that contains all constellation points of s5 for computing L(x5,0) and L(x5,1) by the duplicating-and-replacing procedure. As shown in FIG. 4, the solid lines are for Ωj,0 and the dashed lines are for Ωj,1.
The above-mentioned procedure needs to be performed 2Nt times for decoding s, and the equation (16) is the major computation overhead. Note that Δj have limited values and ranges, and they can be realized by a simple look up table or a decoder. Please note that, in this embodiment, the path s′ can be expanded to unlimited M paths. However, considering the overhead from the path augmentation device 316, Lk can also be augmented partially. That is, the soft values can be generated by the |L|×M most reliable paths for 0<M<1. The value M can provide a tradeoff between complexity and error performance.
Moreover, the path augmentation device 316 in the present invention can further perform the dynamic compensation by introducing an additive correction term to improve the approximation accuracy of the channel decoder 318 and to improve the error performance. Here, let n0 and n1 denote the sizes of Ωj,0∩Lk and Ωj,1∩Lk respectively, and n0+n1=|L|. Moreover, let




  
    
      
        
          
            m
            0
          
          =
          
            
              min
              
                
                  s
                  ′
                
                ∈
                
                  Ω
                  
                    j
                    ,
                    0
                  
                
              
            
            ⁢
            
              
                
                
                  q
                  -
                  
                    Rs
                    ′
                  
                
                
              
              2
            
          
        
        ⁢
        
          

        
        ⁢
        And
      
    
    
      
        (
        17
        )
      
    
  
  
    
      
        
          m
          1
        
        =
        
          
            min
            
              
                s
                ′
              
              ∈
              
                Ω
                
                  j
                  ,
                  1
                
              
            
          
          ⁢
          
            
              
              
                q
                -
                
                  Rs
                  ′
                
              
              
            
            2
          
        
      
    
    
      
        (
        18
        )
      
    
  




And the path augmentation device 316 can express the equation (10) in the conventional list sphere decoding algorithm as follows:





  
    
      
        
          log
          ⁢
          
            
              
                ∑
                
                  
                    s
                    ′
                  
                  ∈
                  
                    Ω
                    
                      j
                      ,
                      0
                    
                  
                
              
              ⁢
              
                Pr
                ⁡
                
                  (
                  
                    y
                    |
                    
                      s
                      ′
                    
                  
                  )
                
              
            
            
              
                ∑
                
                  
                    s
                    ′
                  
                  ∈
                  
                    Ω
                    
                      j
                      ,
                      1
                    
                  
                
              
              ⁢
              
                Pr
                ⁡
                
                  (
                  
                    y
                    |
                    
                      s
                      ′
                    
                  
                  )
                
              
            
          
        
        =
        
          
            log
            ⁢
            
              
                
                  ∑
                  
                    
                      s
                      ′
                    
                    ∈
                    
                      Ω
                      
                        j
                        ,
                        0
                      
                    
                  
                
                ⁢
                
                  Pr
                  ⁡
                  
                    (
                    
                      q
                      |
                      
                        s
                        ′
                      
                    
                    )
                  
                
              
              
                
                  ∑
                  
                    
                      s
                      ′
                    
                    ∈
                    
                      Ω
                      
                        j
                        ,
                        1
                      
                    
                  
                
                ⁢
                
                  Pr
                  ⁡
                  
                    (
                    
                      q
                      |
                      
                        s
                        ′
                      
                    
                    )
                  
                
              
            
          
          =
          
            
              
                (
                
                  
                    m
                    1
                  
                  -
                  
                    m
                    0
                  
                
                )
              
              
                2
                ⁢
                
                  σ
                  2
                
              
            
            +
            
              log
              ⁢
              
                
                  1
                  +
                  
                    
                      ∑
                      
                        i
                        =
                        1
                      
                      
                        
                          n
                          0
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      e
                      
                        
                          
                            -
                            1
                          
                          
                            2
                            ⁢
                            
                              σ
                              2
                            
                          
                        
                        ⁢
                        
                          (
                          
                            
                              a
                              i
                            
                            -
                            
                              m
                              0
                            
                          
                          )
                        
                      
                    
                  
                
                
                  1
                  +
                  
                    
                      ∑
                      
                        i
                        =
                        1
                      
                      
                        
                          n
                          1
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      e
                      
                        
                          
                            -
                            1
                          
                          
                            2
                            ⁢
                            
                              σ
                              2
                            
                          
                        
                        ⁢
                        
                          (
                          
                            
                              b
                              i
                            
                            -
                            
                              m
                              1
                            
                          
                          )
                        
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        19
        )
      
    
  




where {m0, a1, a2, . . . , an0−1}={T(s′)}|∀s′εΩj,0∩L}, and {m1, b1, b2, . . . , bn1−1}={T(s′)}|∀s′εΩj,1∩L}. For sufficiently large list size,





  
    
      log
      ⁢
      
        
      
      ⁢
      
        
          n
          0
        
        
          n
          1
        
      
    
    ≈
    
      
        Pr
        ⁡
        
          (
          
            
              x
              j
            
            =
            0
          
          )
        
      
      
        Pr
        ⁡
        
          (
          
            
              x
              j
            
            =
            1
          
          )
        
      
    
  
  ,




which is the intrinsic information required by an maximum “a posteriori” (MAP) detector.

The second term in (19) and the intrinsic information can be combined as





  
    
      
        
          β
          ⁢
          
            
          
          ⁢
          log
          ⁢
          
            
              1
              +
              
                n
                0
              
            
            
              1
              +
              
                n
                1
              
            
          
        
        ≅
        
          
            log
            ⁢
            
              
                (
                
                  1
                  +
                  
                    
                      ∑
                      
                        i
                        =
                        1
                      
                      
                        
                          n
                          0
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      e
                      
                        
                          1
                          
                            2
                            ⁢
                            
                              σ
                              2
                            
                          
                        
                        ⁢
                        
                          (
                          
                            
                              a
                              i
                            
                            -
                            
                              m
                              0
                            
                          
                          )
                        
                      
                    
                  
                
                )
              
              
                (
                
                  1
                  +
                  
                    
                      ∑
                      
                        i
                        =
                        1
                      
                      
                        
                          n
                          1
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      e
                      
                        
                          
                            -
                            1
                          
                          
                            2
                            ⁢
                            
                              σ
                              2
                            
                          
                        
                        ⁢
                        
                          (
                          
                            
                              b
                              i
                            
                            -
                            
                              m
                              1
                            
                          
                          )
                        
                      
                    
                  
                
                )
              
            
          
          +
          
            log
            ⁢
            
              
                Pr
                ⁡
                
                  (
                  
                    
                      x
                      j
                    
                    =
                    0
                  
                  )
                
              
              
                Pr
                ⁡
                
                  (
                  
                    
                      x
                      j
                    
                    =
                    1
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        20
        )
      
    
  




where





  
    n
    0
  
  
    n
    1
  




is modified to





  
    1
    +
    
      n
      0
    
  
  
    1
    +
    
      n
      1
    
  




to avoid logarithm of zero or infinity. Ultimately, the soft value generated by the soft value generation device 314 will be:





  
    
      
        
          L
          ⁡
          
            (
            
              x
              
                k
                ,
                j
              
            
            )
          
        
        ≈
        
          
            
              -
              1
            
            
              2
              ⁢
              
                σ
                2
              
            
          
          ⁢
          
            (
            
              
                m
                1
              
              -
              
                m
                0
              
              +
              
                β
                ⁢
                
                  
                
                ⁢
                log
                ⁢
                
                  
                    1
                    +
                    
                      n
                      0
                    
                  
                  
                    1
                    +
                    
                      n
                      1
                    
                  
                
              
            
            )
          
        
      
    
    
      
        (
        21
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          ≈
          
            (
            
              
                m
                1
              
              -
              
                m
                0
              
              +
              
                βlog
                ⁢
                
                  
                    1
                    +
                    
                      n
                      0
                    
                  
                  
                    1
                    +
                    
                      n
                      1
                    
                  
                
              
            
            )
          
        
      
    
    
      
        (
        22
        )
      
    
  




where β is a normalization factor, and n1=|L|−n0. From the equation (21), the computation overhead resulted from the dynamic compensation





  β
  ⁢
  
    
  
  ⁢
  log
  ⁢
  
    
      1
      +
      
        n
        0
      
    
    
      1
      +
      
        n
        1
      
    
  




are one multiplication, two logarithms, and at most |L|+1 additions for accumulating n0. Moreover, m0 (or m1) will be estimated by the maximum path metric in L if Ωj,0∩Lk (or Ωj,1∩Lk) is empty set. Please note that, in this embodiment, the calculation of the soft value L(xk,j) in the equation (21) and (22) is the estimated value suitable for current model. However, the calculation of the soft value L(xk,j) is not limited to the above definition. That is, in other embodiments, the soft value L(xk,j) can be assigned by different conditions depending on design requirements. For example, for simplicity, the soft value generation device 314 can alternatively generate the soft value L(xk,j) by:

L(xk,j)≈m1−m2   (23)

Please refer to FIG. 5 for a diagram schematically showing a simulation result according to the present invention. The simulation is based on a 4×4 MIMO system wherein (648,324) and (1944, 972) LDPC codes of IEEE802.11n is applied as channel coding schemes. The candidate list generation is realized by the K-best algorithm. To achieve the BER lower than 10−5, FIG. 5 shows that the conventional LSDs should have the list size K larger than 128. However, as shown in FIG. 5, the proposed candidate list augmentation scheme (A-LSD) in the present invention can achieve SNR improvement from 0.3 dB to 1 dB, depending on K value, and the improvement becomes more apparent when K value is smaller. That is, the path augmentation algorism in the present invention results in equivalently more available candidates, and therefore 64-best A-LSD has the lowest error floor.
Based on the present invention, the path augmentation algorithm in the present invention guarantees a low probability of failing to find the minimizers. Actually, the computation overhead from list expansion by the path augmentation device 316 is usually smaller as compared to direct generation of a larger candidate list in the conventional MIMO system. Moreover, the path augmentation algorithm in the present invention can be applied in different decoding algorithm, for instance, sphere decoding, list decoding, M-algorithm, T-algorithm, or K-best algorithm. Besides, an additive correction term is introduced to dynamically compensate the approximation loss in the conventional list sphere decoding scheme. Combining the two proposed schemes, the MIMO system with candidate list augmentation scheme in the present invention significantly reduce the calculation complex and perceive improvement in error performance.
Those described above are only the preferred embodiments to exemplify the present invention but not to limit the scope of the present invention. Any equivalent modification or variation according to the shapes, structures, features and spirit disclosed in the specification is to be also included within the scope of the present invention.

## Claims

1. A candidate list augmentation device for channel coding systems, said device comprising:
a candidate list generation device for receiving an input signal within a channel coding system and generating a candidate list according to said input signal;
a path augmentation device, coupled to said candidate list generation device, for augmenting paths in the candidate list according to said candidate list and generate an augmented list; and
a soft value generation device, coupled to said candidate list generation device and said path augmentation device, for comparing said input signal and said augmented list and generating a soft value according to said input signal, said candidate list and said augmented list, wherein said soft value is utilized for error correcting in decoding said input signal;
wherein said path augmentation device generates said augmented list by expanding each said path in said candidate list to M paths by duplicating each said path M−1 times; and replacing said k-th bit information in said M paths by a distinct ωj from an original set Ω={ωj |j=0, 1, . . . , M−1}.

2. The candidate list augmentation device of claim 1, wherein said candidate list comprises a plurality of paths, and each said path comprises a plurality of bit information for decoding said input signal.

3. The candidate list augmentation device of claim 1, wherein said candidate list generation device can generate said candidate list by the sphere decoding algorithm, the list decoding algorithm, M-algorithm, T-algorithm, or K-best algorithm.

4. The candidate list augmentation device of claim 1, wherein said channel coding system includes coded MIMO system.

5. The candidate list augmentation device of claim 1, wherein said path augmentation device could separate said M paths in said candidate list into a first set Ωj,0 and a second set Ωj,1 wherein said first set Ωj,0 denotes j-th bit information of said paths in said first set is in a first digit (zero), and Ωj,1 denotes j-th bit information of said paths in said second set is in a second digit (one).

6. The candidate list augmentation device of claim 5, wherein said path augmentation device can calculate a first minimizer m0 for said first set Ωj,0 by




  
    
      m
      0
    
    =
    
      
        min
        
          
            s
            ′
          
          ∈
          
            Ω
            
              j
              ,
              0
            
          
        
      
      ⁢
      
        
          
          
            q
            -
            
              Rs
              ′
            
          
          
        
        2
      
    
  
  ,




and a second minimizer m1 for said second set Ωj,0 by




  
    
      m
      1
    
    =
    
      
        min
        
          
            s
            ′
          
          ∈
          
            Ω
            
              j
              ,
              1
            
          
        
      
      ⁢
      
        
          
          
            q
            -
            
              Rs
              ′
            
          
          
        
        2
      
    
  
  ,
  
    wherein
    ⁢
    
      
    
    ⁢
    
      
        
        
          q
          -
          
            Rs
            ′
          
        
        
      
      2
    
  




refers to the path metric of said candidate list.

7. The candidate list augmentation device of claim 6, wherein said soft value generation device generated said soft value L(xk,j) by the following equation:




  
    L
    ⁡
    
      (
      
        x
        
          k
          ,
          j
        
      
      )
    
  
  ≈
  
    
      
        -
        1
      
      
        2
        ⁢
        
          σ
          2
        
      
    
    ⁢
    
      (
      
        
          m
          1
        
        -
        
          m
          0
        
        +
        
          β
          ⁢
          
            
          
          ⁢
          log
          ⁢
          
            
              1
              +
              
                n
                0
              
            
            
              1
              +
              
                n
                1
              
            
          
        
      
      )
    
  




wherein σ2 is the noise variance, β is a normalization factor, n0 and n1 denote the sizes of Ωj,0 and Ωj,1 respectively, and n0+n1 are equal to the size of said candidate list.

8. The candidate list augmentation device of claim 6, wherein said soft value generation device generated said soft value L(xk,j) by the following equation:




  
    L
    ⁡
    
      (
      
        x
        
          k
          ,
          j
        
      
      )
    
  
  ≈
  
    
      m
      1
    
    -
    
      m
      0
    
    +
    
      β
      ⁢
      
        
      
      ⁢
      
        log
        (
        
          
            1
            +
            
              n
              0
            
          
          
            1
            +
            
              n
              1
            
          
        
        )
      
    
  




wherein β is a normalization factor, n0 and n1 denote the sizes of Ωj,0 and Ωj,1 respectively, and n0+n1 are equal to the size of said candidate list.

9. The candidate list augmentation device of claim 6, wherein said soft value generation device generated said soft value L(xk,j) by the following equation:


L(xk,j)≈m1−m0.

10. An candidate list augmentation method for channel coding systems, said method comprising:
(1) receiving an input signal and generating a candidate list according to said input signal;
(2) generating an augmented list according to said candidate list; and
(3) comparing said input signal and said augmented list and generating a soft value according to said input signal, said candidate list and said augmented list, wherein said soft value is utilized for error correcting in decoding said input signal;
wherein said step (2) further comprises:
expanding each said path in said candidate list to M paths by duplicating each said path M−1 times; and
replacing said k-th bit information in said M paths by a distinct ωj from an original set Ω={ωj|j=0, 1, . . . , M−1} in said candidate list.

11. The candidate list augmentation method of claim 10, wherein said candidate list comprises a plurality of paths, and each said path comprises a plurality of bit information for decoding said input signal.

12. The candidate list augmentation method of claim 10, wherein said step (1) further comprises: generating said candidate list by the sphere decoding algorithm, the list decoding algorithm, M-algorithm, T-algorithm, or K-best algorithm.

13. The candidate list augmentation method of claim 10, wherein said step (2) further comprises: separating said M paths in said candidate list into a first set Ωj,0 and a second set Ωj,1 , wherein said first set Ωj,0 denotes j-th bit information of said paths in said first set is in a first digit (zero), and Ωj,1 denotes j-th bit information of said paths in said second set is in a second digit (one).

14. The candidate list augmentation method of claim 13, wherein a first minimizer m0 can be calculated for said first set Ωj,0 by




  
    
      m
      0
    
    =
    
      
        min
        
          
            s
            ′
          
          ∈
          
            Ω
            
              j
              ,
              0
            
          
        
      
      ⁢
      
        
          
          
            q
            -
            
              Rs
              ′
            
          
          
        
        2
      
    
  
  ,




and a second minimizer m1 can be calculated for said second set Ωj,0 by,




  
    
      m
      1
    
    =
    
      
        min
        
          
            s
            ′
          
          ∈
          
            Ω
            
              j
              ,
              1
            
          
        
      
      ⁢
      
        
          
          
            q
            -
            
              Rs
              ′
            
          
          
        
        2
      
    
  
  ,




wherein ∥q−Rs′∥2 refers to the path metric of said candidate list.

15. The candidate list augmentation method of claim 14, wherein said soft value L(xk,j) can be generated by the following equation:




  
    L
    ⁡
    
      (
      
        x
        
          k
          ,
          j
        
      
      )
    
  
  ≈
  
    
      
        -
        1
      
      
        2
        ⁢
        
          σ
          2
        
      
    
    ⁢
    
      (
      
        
          m
          1
        
        -
        
          m
          0
        
        +
        
          β
          ⁢
          
            
          
          ⁢
          log
          ⁢
          
            
              1
              +
              
                n
                0
              
            
            
              1
              +
              
                n
                1
              
            
          
        
      
      )
    
  




wherein σ2 is the noise variance, β is a normalization factor, n0 and n1 denote the sizes of Ωj,0 and Ωj,1 respectively, and n0+n1 are equal to the size of said candidate list.

16. The candidate list augmentation method of claim 14, wherein said said soft value L(xk,j) can be generated by the following equation:




  
    L
    ⁡
    
      (
      
        x
        
          k
          ,
          j
        
      
      )
    
  
  ≈
  
    
      m
      1
    
    -
    
      m
      0
    
    +
    
      β
      ⁢
      
        
      
      ⁢
      
        log
        (
        
          
            1
            +
            
              n
              0
            
          
          
            1
            +
            
              n
              1
            
          
        
        )
      
    
  




wherein β is a normalization factor, n0 and n1 denote the sizes of Ωj,0 and Ωj,1 respectively, and n0+n1 are equal to the size of said candidate list.

17. The candidate list augmentation method of claim 14, wherein said said soft value L(xk,j) can be generated by the following equation:


L(xk,j)≈m1−m0.