Abstract:
A method implemented in a base station is disclosed. The method includes precoding data with a precoder, and transmitting the precoded data to a user equipment, and the precoder can be expressed as multiplication OV where V is a first matrix corresponding to a first indication of the precoder for a group of transmitted symbols, and O is a second matrix corresponding to a second indication of the precoder for a variation in a channel. Other methods and apparatuses also are disclosed.

Description:
[0001]    The present application is a divisional of co-pending U.S. patent application Ser. No. 12/952,195, filed Nov. 22, 2010, which in turn is a divisional of U.S. patent application Ser. No. 11/950,702, filed Dec. 5, 2007, which in turn claims priority to U.S. Provisional Application Ser. No. 60/895,904, filed Mar. 20, 2007, the content of which is incorporated by reference. 
     
    
       [0002]    The present invention relates to the codebooks used in wireless communications. 
       BACKGROUND 
       [0003]    With an ever growing need for higher data communication rate over wireless medium, users are demanding high rate data transmission. One area in which the aforementioned considerations have arisen is in UMTS Terrestrial Radio Access Network (UTRAN) and Evolved-UTRA, which call for higher user data rates and improved quality of service. A number of proposals have discussed and concluded the need for multiple-antenna systems to achieve the target spectral efficiency, throughput, and reliability of EUTRA. These proposals have considered different modes of operation applicable to different scenarios. The basic assumptions that vary among proposals include (i) using single stream versus multiple streams, (ii) scheduling one user at a time versus multiple users, (iii) having multiple streams per user versus a single stream per user, and (iv) coding across multiple streams versus using independent streams. A common factor among various downlink physical layer multiple-input-multiple-output (MIMO) proposals, however, is a feedback strategy to control the transmission rate and possibly vary the transmission strategy. 
         [0004]    MIMO antenna systems can be effective in fading environment by providing significant performance improvements and achievable data rates in comparison to single antenna systems. Closed loop MIMO systems typically transmit channel state information from a receiver to a transmitter. Transmitting the channel state information consumes bandwidth that might otherwise be available for data traffic. The performance gain achieved by multiple antenna system increases when the knowledge of the channel state information (CSI) at each end, either the receiver or transmitter, is increased. Although perfect CSI is desirable, practical systems are usually built only on estimating the CSI at the receiver, and possibly feeding back the CSI to the transmitter through a feedback link with a very limited capacity. Using CSI at the transmitter, the transmission strategy is adapted over space (multiple antennas) and over time (over multiple blocks). 
         [0005]    Conventional DL MIMO transmission strategy includes quantized precoding schemes, antenna selection, antenna cycling (with or without rank control), and different space-time coding and spatial multiplexing transmission scheme. The quantized precoding schemes are used whenever a feedback link from the receiver to the transmitter is present. The performance of quantized precoding scheme depends on the codebook design and the complexity and memory requirement are further functions of the precoding algorithm. Hence, codebook design is one of the main aspects of the quantized precoding schemes. The conventional design criterion is based on SNR maximization which is not necessarily the capacity-optimal design strategy. Moreover, the precoder size is assumed to be fixed which means the number of transmitted data streams, i.e., precoding rank, is fixed and is usually taken to be the minimum of the number of transmit and receive antennas. 
       SUMMARY 
       [0006]    In one aspect, a static codebook design provides a successive codebook structure and the precoding matrices are obtained from a set of precoding vector codebooks. This design addresses the problem of optimized vector codebook design, i.e., the set of vector codebooks which result in the optimal precoding matrix codebook. 
         [0007]    In another aspect, a different code-book design problem. When the channel is correlated in time (or in frequency, e.g., across different tones in OFDM systems), the correlation can be used to considerably reduce the feedback requirement without loss in performance. The idea of differential codebook is to feedback only the variation in the channel, since typically quantizing the channel variations requires a smaller codebook than quantizing the channel itself. 
         [0008]    Advantages of preferred embodiments of the above aspects may include one or more of the following. The design jointly optimizes the vector codebooks such that the resulting precoder matrices are optimized. By employing the differential codebook and optimized vector codebook, the performance of quantized precoding schemes is improved and higher throughput will be achievable. In comparison to the other competitive schemes on codebook based precoding which use the CQI-metric based precoder selection, the codebook requires less memory to store and has lower computational complexity. The optimal codebook is channel specific and is finely tuned to the channel statistics. The vector codebooks can be used with successive or Householder structured codebook. Simulation results show the superiority of the designed codebooks over the conventional codebooks. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0009]      FIG. 1  is a schematic block diagram of a multiple-antenna communications system with quantized feedback of channel state information. 
           [0010]      FIG. 2  schematically illustrates the dependency of variables in the determination of eigenvectors and quantized eigenvectors and the re-creation of quantized eigenvectors in a successive beamforming scheme. 
           [0011]      FIG. 3  shows an exemplary codebook generation process. 
           [0012]      FIG. 4  shows an exemplary precoder codebook design algorithm. 
       
    
    
     DESCRIPTION 
       [0013]    An exemplary multiple-antenna communication system  100  with static and differential precoding codebook is schematically shown in  FIGS. 1-2 . A transmitter  110  transmits from t transmitting antennas  111 . 1 - 111 . t  over a fading channel  130  to r receiving antennas  121 . 1 - 121 . r  coupled to a receiver  120 . A channel estimator  125  provides an estimate of the channel  130  to the receiver  120 . The channel estimate is also quantized and provided to the transmitter  110  via a quantized rate control feedback channel  135 . 
         [0014]    For a multiple-antenna system with r receive and t transmit antennas the baseband channel model can be expressed as follows: Y=HX+W, (1) where Y is the r×1 received column vector, H is the r×t channel matrix, X is the t×1 transmit column vector, and W is the r×1 noise column vector. The input is subject to an average power constraint P, i.e, tr(Q)≦P, where Q=E[XX H ], E[.] denotes the expected value and tr(.) represents the trace of a matrix. 
         [0015]    In an exemplary multi-rank beamforming scheme in accordance with the present invention, channel state information (CSI) is available to the transmitter (CSIT) as well as the receiver (CSIR). Where perfect CSIT and CSIR are assumed, the capacity of the multiple-antenna fading channel  130  can be achieved through power adaptation over time (one average power for each channel state) and water-filling power control over multiple eigenvectors of the channel for each block of transmission. 
         [0016]    In systems that employ beamforming such as the MIMO systems, the beamforming matrix (referred to herein as a codeword) generated in response to perceived channel conditions is computed and quantized at the receiver first, and then is provided to the source transmitter (e.g., via feedback). A conventional approach to reduce the overhead associated with this feedback is to provide matrix codebook(s) at each of the transmitter and the receiver, each of the codebook(s) comprising a plurality, or set, of potential beamforming matrixes that may be used depending on the channel conditions perceived at the receiver. When the receiver has identified the appropriate matrix codebook(s), the receiver will typically feed back only an index (instead of the actual matrix entries) that points to the appropriate codeword in the codebook(s) stored at the transmitter. 
         [0017]    Turning now to  FIG. 3 , an exemplary process to generate the codebook is shown. In this process, a random codebook is generated ( 200 ). Next, the process partitions channel state information into a set of nearest neighbors for each codebook entry based on a distance metric ( 210 ). The process then updates the codebook by finding a centroid for each partition ( 220 ). 
         [0018]    In the MIMO system of  FIG. 1  with t transmit antennas at the base station and a user each with r receive antennas, the complex baseband signal model is given by 
         [0000]        y=Hx+w,   (1)
 
         [0019]    where x is the t×1 transmitted signal vector, H is the r×t channel matrix, w:N c (0,I) is a circularly symmetric complex additive white Gaussian noise vector, and y is the r×1 received signal vector. A block fading channel model is used in which the channel remains constant during the transmission of each packet (or codeword of length T) and it changes independently from one block to another, where the distribution of the channel state is known a priori. The average power constraint is given by E[x H x]≦P. 
         [0020]    In maximizing the throughput in single user (SU-) MIMO systems (or sum-rate throughput for multiple user (MU-) MIMO systems) which is usually the primary goal in downlink transmissions, the following assumptions can be used: (1) the user feeds back the quantized channel state via a limited feedback link; (2) based on the feedback information, the base station performs a linear precoding (and only linear precoding is allowed) of the transmitted streams. 
         [0021]    Let UDV* be the singular value decomposition (SVD) of the channel matrix H. With B bits of feedback, the user quantizes the first n column of V (where n≦min(r, t)) is a fixed number predetermined by the base station) using a quantization codebook Q={Q 1 , Q 2 , . . . , Q 2     B   }Q i εC t×r , as follows 
         [0000]    
       
         
           
             
               
                 
                   
                     V 
                      
                     
                       ( 
                       
                         1 
                         : 
                         n 
                       
                       ) 
                     
                   
                   = 
                   
                     arg 
                      
                     
                         
                     
                      
                     
                       
                         min 
                         
                           Q 
                           ∈ 
                           Q 
                         
                       
                        
                       
                         d 
                          
                         
                           ( 
                           
                             
                               V 
                                
                               
                                 ( 
                                 
                                   1 
                                   : 
                                   n 
                                 
                                 ) 
                               
                             
                             , 
                             Q 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0022]    where d(•,•) is some distance metric. The codebook design problem and the appropriate choice of the distance metric have been considered in prior art. The columns of the quantized precoding matrix V(1:n) correspond to possible different streams for this user. 
         [0023]    The transmitted signal x from the base station then consists of L data streams, u 1 , u 2 , . . . , u L , sent through column vectors g 1 , g 2 , . . . , g L , of a linear precoder G. We have 
         [0000]    
       
         
           
             
               
                 
                   x 
                   = 
                   
                     Gu 
                     = 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         L 
                       
                        
                       
                         
                           u 
                           i 
                         
                          
                         
                           
                             g 
                             i 
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0024]    In SU-MIMO systems, we have L=n while in MU-MIMO systems we have L≧n where one or more than one streams may be intended for each user. 
         [0025]    Next, a codebook design will be discussed which is static and predesigned and does not adopt to the changes in the average channel condition. The first design considers rank specific codebook design where for each transmission rank a separate codebook is designed. The second design is based on transformation which generates the codebooks for all ranks based on a set of vector codebook. 
         [0026]    Design Criterion 
         [0027]    For a given transmission rank n and B bits of PMI feedback, the codebook design problem is formulated as finding the set Q={Q 1 , Q 2 , . . . , Q 2     B   } of (t×n) semi-unitary matrices that is a solution to the optimization problem given by 
         [0000]    
       
         
           
             
               
                 
                   C 
                   = 
                   
                     
                       max 
                       Q 
                     
                      
                     
                       
                         E 
                          
                         
                           [ 
                           
                             
                               max 
                               
                                 Q 
                                 ∈ 
                                 Q 
                               
                             
                              
                             
                               log 
                                
                               
                                   
                               
                                
                               
                                 det 
                                  
                                 
                                   ( 
                                   
                                     I 
                                     + 
                                     
                                       
                                         P 
                                         t 
                                       
                                        
                                       
                                         HQQ 
                                         * 
                                       
                                        
                                       
                                         H 
                                         * 
                                       
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0028]    Let UDV* be the partial SVD of H obtained by retaining only the n right singular vectors that correspond to the n largest singular values of H. For a given H the optimal (t×n) precoder that maximizes the instantaneous mutual information is V, thus, for large enough codebook size: 
         [0000]    
       
         
           
             
               
                 
                   C 
                   ≈ 
                   
                     
                       max 
                       Q 
                     
                      
                     
                       
                         E 
                          
                         
                           [ 
                           
                             
                               max 
                               
                                 Q 
                                 ∈ 
                                 Q 
                               
                             
                              
                             
                               log 
                                
                               
                                   
                               
                                
                               
                                 det 
                                  
                                 
                                   ( 
                                   
                                     I 
                                     + 
                                     
                                       
                                         P 
                                         t 
                                       
                                        
                                       
                                         ( 
                                         
                                           
                                             D 
                                             * 
                                           
                                            
                                           D 
                                         
                                         ) 
                                       
                                        
                                       
                                         V 
                                         * 
                                       
                                        
                                       
                                         QQ 
                                         * 
                                       
                                        
                                       V 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0029]    The approximation in (5) is based on the observation that a well designed large enough codebook can closely sample the set of all possible V. 
         [0030]    Next, an approximate upper bound on C is determined by considering channel realizations whose norms are bounded, i.e., H such that ∥H∥ F   2 =tr[H*H]=tr[D*D]≦β. For such channels: 
         [0000]    
       
         
           
             
               
                 
                   C 
                   &lt; 
                   ≈ 
                   
                     
                       max 
                       Q 
                     
                      
                     
                       
                         E 
                          
                         
                           [ 
                           
                             
                               max 
                               
                                 
                                   Q 
                                   ∈ 
                                   Q 
                                 
                                  
                                 
                                     
                                 
                               
                             
                              
                             
                               log 
                                
                               
                                   
                               
                                
                               
                                 det 
                                  
                                 
                                   ( 
                                   
                                     I 
                                     + 
                                     
                                       
                                         P 
                                         t 
                                       
                                        
                                       β 
                                        
                                       
                                           
                                       
                                        
                                       
                                         V 
                                         * 
                                       
                                        
                                       
                                         QQ 
                                         * 
                                       
                                        
                                       V 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           ] 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0031]    Considering the low SNR approximation of the bound in (6), i.e., letting P→0, 
         [0000]    
       
         
           
             
               
                 
                   C 
                   &lt; 
                   ≈ 
                   
                     
                       max 
                       
                         Q 
                          
                         
                             
                         
                       
                     
                      
                     
                       
                         E 
                          
                         
                           [ 
                           
                             
                               max 
                               
                                 Q 
                                 ∈ 
                                 Q 
                               
                             
                              
                             
                               
                                 
                                   P 
                                    
                                   
                                       
                                   
                                    
                                   β 
                                 
                                 t 
                               
                                
                               
                                 
                                    
                                   
                                     
                                       V 
                                       * 
                                     
                                      
                                     Q 
                                   
                                    
                                 
                                 F 
                                 2 
                               
                             
                           
                           ] 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0032]    The inner maximization in the bound in (7) is equivalent to minimizing the chordal distance between the dominant right eigenvectors of the channel and the corresponding quantized vectors, where the chordal distance is defined as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       d 
                       chordal 
                     
                      
                     
                       ( 
                       
                         Q 
                         , 
                         V 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         1 
                         
                           2 
                         
                       
                        
                       
                         
                            
                           
                             
                               VV 
                               * 
                             
                             - 
                             
                               QQ 
                               * 
                             
                           
                            
                         
                         F 
                       
                     
                     = 
                     
                       
                         
                           t 
                           - 
                           
                             
                                
                               
                                 
                                   V 
                                   * 
                                 
                                  
                                 Q 
                               
                                
                             
                             F 
                             2 
                           
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0033]    On the other hand, considering the high SNR approximation of (6), i.e., P→∞: 
         [0000]    
       
         
           
             
               
                 
                   C 
                   &lt; 
                   ≈ 
                   
                     
                       max 
                       Q 
                     
                      
                     
                       
                         E 
                          
                         
                           [ 
                           
                             
                               max 
                               
                                 Q 
                                 ∈ 
                                 Q 
                               
                             
                              
                             
                               log 
                                
                               
                                 ( 
                                 
                                   
                                     
                                       ( 
                                       
                                         
                                           P 
                                            
                                           
                                               
                                           
                                            
                                           β 
                                         
                                         t 
                                       
                                       ) 
                                     
                                     n 
                                   
                                    
                                   
                                     
                                       det 
                                        
                                       
                                         ( 
                                         
                                           
                                             V 
                                             * 
                                           
                                            
                                           Q 
                                         
                                         ) 
                                       
                                     
                                     2 
                                   
                                 
                                 ) 
                               
                             
                           
                           ] 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0034]    The inner maximization in the bound in (9) is equivalent to minimizing the Fubini-Study (FS) distance between the dominant right eigenvectors of the channel and the corresponding quantized vectors, where the FS distance is defined as 
         [0000]        d   FS ( Q,V )=arccos( det ( V*Q )).  (10)
 
         [0035]    This is so because log(.) is a monotonically increasing function and arccos(.) is a monotonically decreasing function. 
         [0036]    For finite SNRs, since the transmitted signals are the linear combination of the columns of the precoder Q, the precoding codebook design used here relies on a metric that measures the distance between the subspaces spanned by different precoders. While there is no known distance metric directly associated with the capacity expression (5), the inner maximization in the bound in (6) is equivalent to minimizing the following p-metric with 
         [0000]    
       
         
           
             
               
                 
                   
                     p 
                     = 
                     
                       
                         β 
                          
                         
                             
                         
                          
                         P 
                       
                       t 
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       
                         d 
                         p 
                       
                        
                       
                         ( 
                         
                           Q 
                           , 
                           V 
                         
                         ) 
                       
                     
                     = 
                     
                       arccos 
                        
                       
                         [ 
                         
                           
                             det 
                              
                             
                               ( 
                               
                                 I 
                                 + 
                                 
                                   
                                     pV 
                                     * 
                                   
                                    
                                   
                                     QQ 
                                     * 
                                   
                                    
                                   V 
                                 
                               
                               ) 
                             
                           
                           
                             
                               
                                 ( 
                                 
                                   1 
                                   + 
                                   p 
                                 
                                 ) 
                               
                               r 
                             
                              
                             
                                 
                             
                           
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0037]    between the subspaces defined by V and Q on the Grassmanian manifold G(N T , r) which in turn is the space of all r dimensional subspaces of an N T  dimensional vector space. The design based on the p-metric depends on the SNR level. The choice of β is discussed next. p-metric is in fact a valid distance metric in the Grassmanian manifold. Moreover, it can be readily verified that if p→0, the p-metric is equivalent to the chordal distance; and if p→∞, the p-metric is equivalent to the Fubini-Study distance. Therefore, the codebook design based on the p-metric bridges the gap between the design for low SNR and that for high SNR. 
         [0038]    Rank Specific Codebook Design 
         [0039]    In this section, the design of an independent codebook for each rank r is discussed. The design algorithm is based on the generalized Lloyd-Max algorithm that is a widely used for solving a variety of vector quantization problems. Given the quantization codebook Q={Q 1 , Q 2 , . . . , Q 2     B   }, the optimal partitioning satisfies 
         [0000]        V   k   ={VεC   t×n   :d   p ( V,Q   k )≦ d   p ( V,Q   j ),∀ j≠k}   (12)
 
         [0040]    To satisfy the centroid condition, the following problem is solved for the k th  partition 
         [0000]    
       
         
           
             
               
                 
                   
                     Q 
                     k 
                   
                   = 
                   
                     
                       argmin 
                        
                       
                           
                       
                        
                       
                         J 
                          
                         
                           ( 
                           Q 
                           ) 
                         
                       
                     
                     = 
                     
                       arg 
                        
                       
                           
                       
                        
                       
                         
                           min 
                           
                             
                               Q 
                               ∈ 
                               
                                 C 
                                 txn 
                               
                             
                             , 
                             
                               
                                 
                                   Q 
                                   * 
                                 
                                  
                                 Q 
                               
                               = 
                               I 
                             
                           
                         
                          
                         
                           E 
                            
                           
                             
                               ⌊ 
                               
                                 
                                   
                                     d 
                                     p 
                                   
                                    
                                   
                                     ( 
                                     
                                       Q 
                                       , 
                                       V 
                                     
                                     ) 
                                   
                                 
                                 | 
                                 
                                   V 
                                   ∈ 
                                   
                                     V 
                                     k 
                                   
                                 
                               
                               ⌋ 
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0041]    Since an analytical solution for the above optimal centroid problem does not exist, this is solved numerically. To employ the gradient-descent search algorithm, the real representation of the matrix Q denoted by  Q  is defined as 
         [0000]    
       
         
           
             
               
                 
                   
                     Q 
                     _ 
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             
                               Re 
                                
                               
                                 ( 
                                 Q 
                                 ) 
                               
                             
                           
                           
                             
                               - 
                               
                                 Im 
                                  
                                 
                                   ( 
                                   Q 
                                   ) 
                                 
                               
                             
                           
                         
                         
                           
                             
                               Im 
                                
                               
                                 ( 
                                 Q 
                                 ) 
                               
                             
                           
                           
                             
                               Re 
                                
                               
                                 ( 
                                 Q 
                                 ) 
                               
                             
                           
                         
                       
                       ] 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0042]    The real representation  H ,  V  of the matrices H, V, respectively, are similarly defined. Also, the system can parameterize the semi-unitary matrix QεC t×n  by using N Φ =2(t−n+1)n independent real parameters φ i , i=1, . . . , N Φ . Therefore, an unconstrained problem can be obtained in terms of the vector Φ=[φ 1 , φ 2 , . . . , φ N     Φ   ]: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       
                         
                           Q 
                           ∈ 
                           
                             C 
                             txn 
                           
                         
                         , 
                         
                           
                             
                               Q 
                               * 
                             
                              
                             Q 
                           
                           = 
                           I 
                         
                       
                     
                      
                     
                       J 
                        
                       
                         ( 
                         Q 
                         ) 
                       
                     
                   
                   = 
                   
                     
                       
                         min 
                         Φ 
                       
                        
                       
                         J 
                          
                         
                           ( 
                           
                             Q 
                              
                             
                               ( 
                               Φ 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                     = 
                     
                       
                         min 
                         Φ 
                       
                        
                       
                         
                           E 
                            
                           
                             [ 
                             
                               
                                 
                                   d 
                                   p 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       
                                         Q 
                                         _ 
                                       
                                        
                                       
                                         ( 
                                         Φ 
                                         ) 
                                       
                                     
                                     , 
                                     
                                       V 
                                       _ 
                                     
                                   
                                   ) 
                                 
                               
                               | 
                               
                                 V 
                                 ∈ 
                                 
                                   V 
                                   k 
                                 
                               
                             
                             ] 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
         [0043]    The derivative of the objective function (15) with respect to φ k  is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           ∂ 
                           
                             ∂ 
                             
                               φ 
                               k 
                             
                           
                         
                          
                         
                           J 
                            
                           
                             ( 
                             
                               
                                 Q 
                                 _ 
                               
                                
                               
                                 ( 
                                 Φ 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                       = 
                       
                         tr 
                          
                         
                           { 
                           
                             
                               
                                 [ 
                                 
                                   
                                     ∂ 
                                     
                                       
                                         Q 
                                         _ 
                                       
                                        
                                       
                                         ( 
                                         Φ 
                                         ) 
                                       
                                     
                                   
                                   
                                     ∂ 
                                     
                                       φ 
                                       k 
                                     
                                   
                                 
                                 ] 
                               
                               T 
                             
                              
                             
                               
                                 ∇ 
                                 
                                   Q 
                                   _ 
                                 
                               
                                
                               
                                 J 
                                  
                                 
                                   ( 
                                   
                                     Q 
                                     _ 
                                   
                                   ) 
                                 
                               
                             
                           
                           } 
                         
                       
                     
                     , 
                     
                       1 
                       ≤ 
                       k 
                       ≤ 
                       
                         N 
                         Φ 
                       
                     
                   
                    
                   
                     
 
                   
                    
                   where 
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           
                             ∇ 
                             
                               Q 
                               _ 
                             
                           
                            
                           
                             J 
                              
                             
                               ( 
                               
                                 Q 
                                 _ 
                               
                               ) 
                             
                           
                         
                         = 
                           
                          
                         
                           E 
                            
                           
                             [ 
                             
                               
                                 
                                   - 
                                   
                                     
                                       
                                         ( 
                                         
                                           1 
                                           - 
                                           
                                             F 
                                             2 
                                           
                                         
                                         ) 
                                       
                                       
                                         
                                           - 
                                           1 
                                         
                                         / 
                                         2 
                                       
                                     
                                     
                                       
                                         ( 
                                         
                                           1 
                                           + 
                                           p 
                                         
                                         ) 
                                       
                                       r 
                                     
                                   
                                 
                                  
                                 
                                   
                                     ∇ 
                                     
                                       Q 
                                       _ 
                                     
                                   
                                    
                                   
                                     det 
                                      
                                     
                                       ( 
                                       
                                         I 
                                         + 
                                         
                                           p 
                                            
                                           
                                             
                                               V 
                                               _ 
                                             
                                             T 
                                           
                                            
                                           
                                             Q 
                                             _ 
                                           
                                            
                                           
                                               
                                           
                                            
                                           
                                             
                                               Q 
                                               _ 
                                             
                                             T 
                                           
                                            
                                           
                                             V 
                                             _ 
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                               | 
                               
                                 V 
                                 ∈ 
                                 
                                   V 
                                   k 
                                 
                               
                             
                             ] 
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                            
                           
                             E 
                              
                             
                               [ 
                               
                                 
                                   
                                     
                                       
                                         - 
                                         2 
                                       
                                        
                                       p 
                                        
                                       
                                           
                                       
                                        
                                       
                                         
                                           F 
                                            
                                           
                                             ( 
                                             
                                               1 
                                               - 
                                               
                                                 F 
                                                 2 
                                               
                                             
                                             ) 
                                           
                                         
                                         
                                           
                                             - 
                                             1 
                                           
                                           / 
                                           2 
                                         
                                       
                                        
                                       
                                         V 
                                         _ 
                                       
                                        
                                       
                                           
                                       
                                        
                                       
                                         
                                           V 
                                           _ 
                                         
                                         T 
                                       
                                        
                                       
                                         Q 
                                         _ 
                                       
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         
                                           ( 
                                           
                                             I 
                                             + 
                                             
                                               p 
                                                
                                               
                                                 
                                                   V 
                                                   _ 
                                                 
                                                 T 
                                               
                                                
                                               
                                                 Q 
                                                 _ 
                                               
                                                
                                               
                                                   
                                               
                                                
                                               
                                                 
                                                   Q 
                                                   _ 
                                                 
                                                 T 
                                               
                                                
                                               
                                                 V 
                                                 _ 
                                               
                                             
                                           
                                           ) 
                                         
                                         
                                           - 
                                           1 
                                         
                                       
                                       | 
                                       
                                         V 
                                         ∈ 
                                         
                                           V 
                                           k 
                                         
                                       
                                     
                                   
                                 
                               
                               ] 
                             
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   
                     
                       
                         
                           ( 
                           17 
                           ) 
                         
                          
                         
                           ( 
                           18 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                           
                       
                     
                   
                 
               
             
           
         
       
     
         [0044]    with 
         [0000]    
       
         
           
             F 
             = 
             
               
                 
                   det 
                    
                   
                     ( 
                     
                       I 
                       + 
                       
                         p 
                          
                         
                           
                             V 
                             _ 
                           
                           T 
                         
                          
                         
                           Q 
                           _ 
                         
                          
                         
                             
                         
                          
                         
                           
                             Q 
                             _ 
                           
                           T 
                         
                          
                         V 
                       
                     
                     ) 
                   
                 
                 
                   
                     
                       ( 
                       
                         1 
                         + 
                         p 
                       
                       ) 
                     
                     r 
                   
                    
                   
                       
                   
                 
               
               . 
             
           
         
       
     
         [0000]    The expression 
         [0000]    
       
         
           
             
               ∂ 
               
                 
                   Q 
                   _ 
                 
                  
                 
                   ( 
                   Φ 
                   ) 
                 
               
             
             
               ∂ 
               
                 φ 
                 
                   k 
                    
                   
                       
                   
                 
               
             
           
         
       
     
         [0000]    can be found using standard techniques. The gradient-descent search algorithm can be used with the following update formula 
         [0000]      Φ (l+1) =Φ (l) −μ l ∇ Φ   J (   Q   (Φ))| Φ     (l)     (19)
 
         [0045]    where μ l  is the sequence of the step sizes. Upon convergence, Φ is used to find the corresponding unitary matrix Q(Φ). 
         [0046]    In sum, as shown in  FIG. 4 , the precoder codebook design algorithm is as follows: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 Input: SNR ave , μ i , codebook size 2 B , Iteration max , rank r 
               
               
                 Output: The codebook Q = {Q 1 , Q 2 , . . . , Q 2     B   } 
               
               
                 Generate an evaluation set {H (l) } l=1   Size  based on the channel distribution. 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             Let 
                              
                             
                                 
                             
                              
                             p 
                           
                           = 
                           
                             
                               
                                 SNR 
                                 ave 
                               
                               r 
                             
                              
                             
                               
                                 max 
                                 k 
                               
                                
                               
                                 { 
                                 
                                   
                                      
                                     
                                       H 
                                       
                                         ( 
                                         l 
                                         ) 
                                       
                                     
                                      
                                   
                                   F 
                                   2 
                                 
                                 } 
                               
                             
                           
                         
                         ; 
                       
                     
                   
                 
               
               
                   
               
               
                 Initialize the codebook Q(0) = {Q 1 (0), Q 2 (0), . . . , Q 2     B   (0)}randomly; 
               
               
                 for i = 1 to Iteration max  do 
               
               
                  Given Q(i − 1), find {V k (i), k = 1, 2, . . . , 2B} using (12); 
               
               
                  Calculate the centroid {Q k (i), k = 1, 2, . . . , 2B} using (16 )-(19); 
               
               
                 end 
               
               
                 return Q(Iteration max ) 
               
               
                   
               
             
          
         
       
     
         [0047]    Nested Vector Codebook Design 
         [0000]    In this embodiment, the system imposes a structure on the codebook which facilitates implementation of the precoding scheme in a practical system by reducing the computational complexity as well as the memory requirement. Denote 
         [0000]    
       
         
           
             
               e 
               k 
             
             = 
             
               
                 
                   [ 
                   
                     1 
                     ; 
                     0 
                     ; 
                     … 
                      
                     
                         
                     
                     ; 
                     0 
                   
                   ] 
                 
                 
                    
                   
                     k 
                     - 
                     1 
                   
                 
               
               . 
             
           
         
       
     
         [0000]    Note that by applying a series of successive rotations, any semi-unitary matrix QεC t×n  can be expressed as 
         [0000]    
       
         
           
             
               
                 
                   Q 
                   = 
                   
                     [ 
                     
                       
                         q 
                         
                           ( 
                           1 
                           ) 
                         
                       
                       , 
                       
                         
                           
                             ( 
                             
                               
                                 ϒ 
                                 1 
                               
                                
                               
                                 ( 
                                 
                                   q 
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                             ) 
                           
                           * 
                         
                          
                         
                           [ 
                           
                             
                               
                                 0 
                               
                             
                             
                               
                                 
                                   
                                     q 
                                     
                                       ( 
                                       2 
                                       ) 
                                     
                                   
                                   , 
                                   
                                     
                                       
                                         ( 
                                         
                                           
                                             ϒ 
                                             2 
                                           
                                            
                                           
                                             ( 
                                             
                                               q 
                                               
                                                 ( 
                                                 2 
                                                 ) 
                                               
                                             
                                             ) 
                                           
                                         
                                         ) 
                                       
                                       * 
                                     
                                      
                                     
                                       [ 
                                       
                                         
                                           
                                             0 
                                           
                                         
                                         
                                           
                                             
                                               
                                                 q 
                                                 
                                                   ( 
                                                   3 
                                                   ) 
                                                 
                                               
                                               , 
                                               … 
                                             
                                           
                                         
                                       
                                       ] 
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
         [0048]    where            k : C t-k+1 →C (t-k+1)×(t-k+1)  is a mapping that for any unit-norm vector q (k) εC t-k+1  returns a rotation matrix            k (q (k) ) such that            k (q (k) )q (k) =e t-k+1 . Therefore, instead of designing the codebook of precoding matrices Q, the vector codebooks contains all the vectors q (k) . 
         [0049]    Consider N T −1 sets of unit-norm vectors in Q (1) ={q i   (1) } i=1   K     1   ⊂C t , Q (2) ={q i   (2) } i=1   K     2   ⊂C t-1 , . . . , Q (t-1) ={q i   (t-1) } i=1   K     t-1   ⊂C 2 . If Q (t) =1, for rotations, the Householder transformation defined by 
         [0000]    
       
         
           
             
               Ψ 
                
               
                 ( 
                 x 
                 ) 
               
             
             = 
             
               I 
               - 
               
                 
                   2 
                    
                   
                     xx 
                     * 
                   
                 
                 
                   
                      
                     x 
                      
                   
                   
                     2 
                      
                     
                         
                     
                   
                 
               
             
           
         
       
     
         [0000]    can be used and let 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ϒ 
                       k 
                     
                      
                     
                       ( 
                       
                         q 
                         
                           ( 
                           k 
                           ) 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       Ψ 
                        
                       
                         ( 
                         
                           
                             q 
                             
                               ( 
                               k 
                               ) 
                             
                           
                           - 
                           
                             e 
                             
                               t 
                               - 
                               k 
                               + 
                               1 
                             
                           
                         
                         ) 
                       
                     
                     = 
                     
                       I 
                       - 
                       
                         
                           
                             2 
                              
                             
                               ( 
                               
                                 
                                   q 
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                                 - 
                                 
                                   e 
                                   
                                     t 
                                     - 
                                     k 
                                     + 
                                     1 
                                   
                                 
                               
                               ) 
                             
                              
                             
                               
                                 ( 
                                 
                                   
                                     q 
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                   - 
                                   
                                     e 
                                     
                                       t 
                                       - 
                                       k 
                                       + 
                                       1 
                                     
                                   
                                 
                                 ) 
                               
                               * 
                             
                           
                           
                             
                                
                               
                                 
                                   q 
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                                 - 
                                 
                                   e 
                                   
                                     
                                       t 
                                       - 
                                       k 
                                       + 
                                       1 
                                     
                                      
                                     
                                         
                                     
                                   
                                 
                               
                                
                             
                             2 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
         [0050]    To have a valid Householder transformation in the complex domain, the first element of the vector x has to be real valued. The codebook of rank r consists of the set of Π i=1   r K i  precoding matrices of size t×n generated using the vector codebooks defined above. The size of the vector sets, i.e., K 1 , K 2 , . . . , K t-1 , are the design parameters and are usually chosen such that K 1 ≧K 2 ≧ . . . ≧K t-1 . For example, to design a set of 12 precoders of rank 2, K 1 =4 and K 2 =3. By choosing the indices i 1 , i 2 , . . . , i r , i j ε{1, 2, . . . , K j } of the vectors from Q (1) , Q (2) , . . . , Q (r) , any precoder of rank r r=1, 2, . . . , t−1, is generated as 
         [0000]    
       
         
           
             
               
                 
                   
                     Q 
                      
                     
                       ( 
                       
                         
                           q 
                           
                             i 
                             1 
                           
                           
                             ( 
                             1 
                             ) 
                           
                         
                         , 
                         
                           q 
                           
                             i 
                             2 
                           
                           
                             ( 
                             2 
                             ) 
                           
                         
                         , 
                         … 
                          
                         
                             
                         
                         , 
                         
                           q 
                           
                             i 
                             r 
                           
                           
                             ( 
                             r 
                             ) 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 q 
                                 
                                   i 
                                   1 
                                 
                                 
                                   ( 
                                   1 
                                   ) 
                                 
                               
                               , 
                               
                                 
                                   Ψ 
                                    
                                   
                                     ( 
                                     
                                       
                                         q 
                                         
                                           i 
                                           1 
                                         
                                         
                                           ( 
                                           1 
                                           ) 
                                         
                                       
                                       - 
                                       
                                         e 
                                         t 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   [ 
                                   
                                     
                                       
                                         0 
                                       
                                     
                                     
                                       
                                         
                                           q 
                                           
                                             i 
                                             2 
                                           
                                           
                                             ( 
                                             2 
                                             ) 
                                           
                                         
                                       
                                     
                                   
                                   ] 
                                 
                               
                               , 
                               … 
                                
                               
                                   
                               
                               , 
                             
                           
                         
                         
                           
                             
                               
                                 Ψ 
                                  
                                 
                                   ( 
                                   
                                     
                                       q 
                                       
                                         i 
                                         1 
                                       
                                       
                                         ( 
                                         1 
                                         ) 
                                       
                                     
                                     - 
                                     
                                       e 
                                       t 
                                     
                                   
                                   ) 
                                 
                               
                                
                               
                                 [ 
                                 
                                   
                                     
                                       0 
                                     
                                   
                                   
                                     
                                       
                                         
                                           Ψ 
                                            
                                           
                                             ( 
                                             
                                               
                                                 q 
                                                 
                                                   i 
                                                   2 
                                                 
                                                 
                                                   ( 
                                                   2 
                                                   ) 
                                                 
                                               
                                               - 
                                               
                                                 e 
                                                 
                                                   t 
                                                   - 
                                                   1 
                                                 
                                               
                                             
                                             ) 
                                           
                                         
                                          
                                         
                                             
                                         
                                          
                                         
                                           … 
                                            
                                           
                                               
                                           
                                           [ 
                                           
                                             
                                               
                                                 0 
                                               
                                             
                                             
                                               
                                                 
                                                   q 
                                                   
                                                     t 
                                                     r 
                                                   
                                                   
                                                     ( 
                                                     r 
                                                     ) 
                                                   
                                                 
                                               
                                             
                                           
                                           ] 
                                         
                                          
                                         
                                             
                                         
                                          
                                         … 
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                           
                         
                       
                       ] 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
         [0051]    The optimization is performed over the vector codebooks Q (1) , Q (2) , . . . , Q (t-1) . The partitioning and centroid steps for the first vector codebook are given by
       Partitioning: Given the quantization codebook Q (1) ={q 1   (1) , q 2   (1) , . . . , q K     1     (1) }, the optimal partitioning satisfies       
 
         [0000]        V   k   (1)   ={vεC   t×1   :d   p ( v,q   k   (1) )≦ d   p ( v,q   j   (1) ),∀ k≠k}   (23)
       Centroid: The centroid for the k th  partition is given by       
 
         [0000]    
       
         
           
             
               
                 
                   
                     q 
                     k 
                     
                       ( 
                       1 
                       ) 
                     
                   
                   = 
                   
                     arg 
                      
                     
                         
                     
                      
                     
                       
                         min 
                         
                           
                             q 
                             ∈ 
                             
                               C 
                               
                                 tx 
                                  
                                 
                                     
                                 
                                  
                                 1 
                               
                             
                           
                           , 
                           
                             
                               
                                 q 
                                 * 
                               
                                
                               q 
                             
                             = 
                             1 
                           
                         
                       
                        
                       
                         
                           E 
                            
                           
                             [ 
                             
                               
                                 
                                   d 
                                   p 
                                 
                                  
                                 
                                   ( 
                                   
                                     q 
                                     , 
                                     v 
                                   
                                   ) 
                                 
                               
                               | 
                               
                                 v 
                                 ∈ 
                                 
                                   V 
                                   k 
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                               
                             
                             ] 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
           
         
       
     
         [0054]    where the expectation is taken over the dominant singular vector v. 
         [0055]    For the second codebook, a set of doubly indexed partitions can be used, where each partition is identified by two vectors in the first and the second vector codebooks Q (1)  and Q (2) . The partitioning and centroid steps are then as follows.
       Partitioning: Given the quantization codebooks Q (1) ={q 1   (1) , q 2   (1) , . . . , q K     1     (1) } and Q (2) ={q 1   (2) , q 2   (2) , . . . , q K     2     (2) }, the optimal partitioning satisfies       
 
         [0000]    
       
         
           
             
               
                 
                   
                     V 
                     
                       
                         i 
                         1 
                       
                       , 
                       
                         i 
                         2 
                       
                     
                     
                       ( 
                       2 
                       ) 
                     
                   
                   = 
                   
                     
                       { 
                       
                         
                           
                             
                               
                                 V 
                                 
                                   ( 
                                   2 
                                   ) 
                                 
                               
                               = 
                               
                                 
                                   [ 
                                   
                                     
                                       v 
                                       
                                         ( 
                                         1 
                                         ) 
                                       
                                     
                                      
                                     
                                       v 
                                       
                                         ( 
                                         2 
                                         ) 
                                       
                                     
                                   
                                   ] 
                                 
                                 ∈ 
                                 
                                   
                                     ℂ 
                                     
                                       t 
                                       × 
                                       2 
                                     
                                   
                                   : 
                                   
                                     
                                       
                                         d 
                                         p 
                                       
                                        
                                       
                                         ( 
                                         
                                           
                                             V 
                                             
                                               ( 
                                               2 
                                               ) 
                                             
                                           
                                           , 
                                           
                                             [ 
                                             
                                               
                                                 q 
                                                 
                                                   i 
                                                   1 
                                                 
                                                 
                                                   ( 
                                                   1 
                                                   ) 
                                                 
                                               
                                               , 
                                               
                                                 
                                                   Ψ 
                                                    
                                                   
                                                     ( 
                                                     
                                                       
                                                         q 
                                                         
                                                           i 
                                                           
                                                             1 
                                                              
                                                             
                                                               
                                                             
                                                           
                                                         
                                                         
                                                           ( 
                                                           1 
                                                           ) 
                                                         
                                                       
                                                       - 
                                                       
                                                         e 
                                                         t 
                                                       
                                                     
                                                     ) 
                                                   
                                                 
                                                  
                                                 
                                                   [ 
                                                   
                                                     
                                                       
                                                         0 
                                                       
                                                     
                                                     
                                                       
                                                         
                                                           q 
                                                           
                                                             i 
                                                             
                                                             2 
                                                              
                                                             
                                                               
                                                             
                                                             
                                                           
                                                           
                                                             ( 
                                                             2 
                                                             ) 
                                                           
                                                         
                                                       
                                                     
                                                   
                                                   ] 
                                                 
                                               
                                             
                                             ] 
                                           
                                         
                                         ) 
                                       
                                     
                                     ≤ 
                                   
                                 
                               
                             
                           
                         
                         
                           
                             
                               
                                 
                                   d 
                                   p 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       V 
                                       
                                         ( 
                                         2 
                                         ) 
                                       
                                     
                                     , 
                                     
                                       [ 
                                       
                                         
                                           q 
                                           
                                             j 
                                             1 
                                           
                                           
                                             ( 
                                             1 
                                             ) 
                                           
                                         
                                         , 
                                         
                                           
                                             Ψ 
                                              
                                             
                                               ( 
                                               
                                                 
                                                   q 
                                                   
                                                     j 
                                                     1 
                                                   
                                                   
                                                     ( 
                                                     1 
                                                     ) 
                                                   
                                                 
                                                 - 
                                                 
                                                   e 
                                                   t 
                                                 
                                               
                                               ) 
                                             
                                           
                                            
                                           
                                             [ 
                                             
                                               
                                                 
                                                   0 
                                                 
                                               
                                               
                                                 
                                                   
                                                     q 
                                                     
                                                       j 
                                                       2 
                                                     
                                                     
                                                       ( 
                                                       2 
                                                       ) 
                                                     
                                                   
                                                 
                                               
                                             
                                             ] 
                                           
                                         
                                       
                                       ] 
                                     
                                   
                                   ) 
                                 
                               
                               , 
                               
                                 ∀ 
                                 
                                   
                                     ( 
                                     
                                       
                                         j 
                                         1 
                                       
                                       , 
                                       
                                         j 
                                         2 
                                       
                                     
                                     ) 
                                   
                                   ≠ 
                                   
                                     ( 
                                     
                                       
                                         i 
                                         1 
                                       
                                       , 
                                       
                                         i 
                                         2 
                                       
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                       } 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
           
         
       
       
         
           
             Centroid: The centroid corresponding to index i 2  is given by 
           
         
       
     
         [0000]    
       
         
           
             
               
                 
                   
                     q 
                     
                       i 
                       2 
                     
                     
                       ( 
                       2 
                       ) 
                     
                   
                   = 
                   
                     arg 
                      
                     
                         
                     
                      
                     
                       
                         min 
                         
                           
                             q 
                             ∈ 
                             
                               ℂ 
                               
                                 
                                   ( 
                                   
                                     t 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 × 
                                 1 
                               
                             
                           
                           , 
                           
                             
                               
                                 q 
                                 * 
                               
                                
                               q 
                             
                             = 
                             1 
                           
                         
                       
                        
                       
                         
                           ∑ 
                           
                             
                               i 
                               1 
                             
                             = 
                             1 
                           
                           
                             K 
                             1 
                           
                         
                          
                         
                           
                              
                              
                             
                               [ 
                               
                                 
                                   
                                     
                                       
                                         d 
                                         p 
                                       
                                        
                                       
                                         ( 
                                         
                                           
                                             [ 
                                             
                                               
                                                 q 
                                                 
                                                   i 
                                                   1 
                                                 
                                                 
                                                   ( 
                                                   1 
                                                   ) 
                                                 
                                               
                                               , 
                                               
                                                 
                                                   Ψ 
                                                    
                                                   
                                                     ( 
                                                     
                                                       
                                                         q 
                                                         
                                                           i 
                                                           1 
                                                         
                                                         
                                                           ( 
                                                           1 
                                                           ) 
                                                         
                                                       
                                                       - 
                                                       
                                                         e 
                                                         t 
                                                       
                                                     
                                                     ) 
                                                   
                                                 
                                                  
                                                 
                                                   [ 
                                                   
                                                     
                                                       
                                                         0 
                                                       
                                                     
                                                     
                                                       
                                                         q 
                                                       
                                                     
                                                   
                                                   ] 
                                                 
                                               
                                             
                                             ] 
                                           
                                           , 
                                           
                                             V 
                                             
                                               ( 
                                               2 
                                               ) 
                                             
                                           
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                 
                                   
                                     
                                       I 
                                        
                                       
                                         ( 
                                         
                                           
                                             V 
                                             
                                               ( 
                                               2 
                                               ) 
                                             
                                           
                                           ∈ 
                                           
                                             V 
                                             
                                               
                                                 i 
                                                 1 
                                               
                                               , 
                                               
                                                 i 
                                                 2 
                                               
                                             
                                             
                                               ( 
                                               2 
                                               ) 
                                             
                                           
                                         
                                         ) 
                                       
                                     
                                   
                                 
                               
                               ] 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
         [0058]    where the expectation is over the first two dominant eigenvectors, i.e., V (2)  and I(.) denotes the indicator function. 
         [0059]    In general, in finding the partitioning for the r th  vector codebook Q (r) , a set of r-tuple indexed partitions is defined and the partitioning and centroid conditions follows the same structure as above. A design procedure similar to Algorithm of  FIG. 3  can be used to find the vector codebooks. 
         [0060]    Differential Codebook Design 
         [0061]    When the channel is correlated in time (or in frequency, e.g., across different tones in OFDM systems), the correlation can be used to considerably reduce the feedback requirement without loss in performance. The idea of differential codebook is to feedback only the variation in the channel, since typically quantizing the channel variations requires a smaller codebook than quantizing the channel itself. 
         [0062]    Let V(s) denote the quantized version of the first N right eigenvectors of the channel matrix H(s)=U(s)D(s)V*(s) at time s using the static quantized codebook design previously discussed. For time s+1, we then find V(s+1)=OV(s+1) by using a t×t unitary transformation matrix O. With B bits of feedback, the differential codebook design is formulated as finding the set of O={O 1 , O 2 , . . . , O 2     B   } unitary matrices such that the average quantization error defined by 
         [0000]      ε= E[∥O ( V ( s ), V ( s+ 1)) V ( s )− V ( s+ 1)∥ F   2 ]  (27)
 
         [0063]    is minimized where O(V (s), V(s+1)) denotes the transformation as a function of the right eigenvectors of the channel for two consecutive time slots. 
         [0064]    In order to employ the Lloyed-Max algorithm, the system finds the optimal partitioning and the centroid for each partition. The optimal partitioning for the quantizer O(V(s),V(s+1)) satisfies 
         [0000]        V   k ={( {circumflex over (V)},V )ε C   t×r   ×C   t×r :∥O k   {circumflex over (V)}−V∥   F   2   ≦∥O   j   {circumflex over (V)}−V∥   F   2   ,∀j≠k},   (28)
 
         [0065]    where {circumflex over (V)} and V denote the quantized and the actual right eigenvectors of the channel for two consecutive time slots, respectively. To satisfy the centroid condition, the following problem for the k th  partition is solved: 
         [0000]    
       
         
           
             
               
                 
                   arg 
                    
                   
                       
                   
                    
                   
                     
                       min 
                       
                         
                           O 
                           ∈ 
                           
                             C 
                             
                               M 
                               × 
                               M 
                             
                           
                         
                         , 
                         
                           
                             
                               O 
                               * 
                             
                              
                             O 
                           
                           = 
                           I 
                         
                       
                     
                      
                     
                       E 
                       [ 
                       
                         
                           
                              
                             
                               
                                 O 
                                  
                                 
                                   V 
                                   ^ 
                                 
                               
                               - 
                               V 
                             
                              
                           
                           F 
                           2 
                         
                          
                         
                           
                              
                             
                               
                                 ( 
                                 
                                   V 
                                   , 
                                   V 
                                 
                                 ) 
                               
                               ∈ 
                               
                                 V 
                                 k 
                               
                             
                             ] 
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   29 
                   ) 
                 
               
             
           
         
       
     
         [0066]    Since ∥O{circumflex over (V)}−V∥ F   2 =∥V∥ F   2 −2          etr{V{circumflex over (V)}*O*}+∥{circumflex over (V)}∥ F   2 , the following is maximized 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           E 
                            
                           
                             [ 
                             
                               
                                 Re 
                                  
                                 
                                     
                                 
                                  
                                 tr 
                                  
                                 
                                   { 
                                   
                                     V 
                                      
                                     
                                         
                                     
                                      
                                     
                                       
                                         V 
                                         ^ 
                                       
                                       * 
                                     
                                      
                                     O 
                                   
                                   } 
                                 
                                  
                                 
                                   | 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       V 
                                       ^ 
                                     
                                     , 
                                     V 
                                   
                                   ) 
                                 
                               
                               ∈ 
                               
                                 V 
                                 k 
                               
                             
                             ] 
                           
                         
                         == 
                           
                          
                         
                           Re 
                            
                           
                               
                           
                            
                           tr 
                            
                           
                             { 
                             
                               
                                 E 
                                  
                                 
                                   [ 
                                   
                                     
                                       V 
                                        
                                       
                                           
                                       
                                        
                                       
                                         
                                           V 
                                           ^ 
                                         
                                         * 
                                       
                                        
                                       
                                         | 
                                       
                                        
                                       
                                         ( 
                                         
                                           
                                             V 
                                             ^ 
                                           
                                           , 
                                           V 
                                         
                                         ) 
                                       
                                     
                                     ∈ 
                                     
                                       V 
                                       k 
                                     
                                   
                                   ] 
                                 
                               
                                
                               
                                 O 
                                 * 
                               
                             
                             } 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           Re 
                            
                           
                               
                           
                            
                           tr 
                            
                           
                             { 
                             
                               Θ 
                                
                               
                                   
                               
                                
                               Σ 
                                
                               
                                   
                               
                                
                               
                                 Φ 
                                 * 
                               
                                
                               
                                 O 
                                 * 
                               
                             
                             } 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           Re 
                            
                           
                               
                           
                            
                           tr 
                            
                           
                             { 
                             
                               Σ 
                                
                               
                                   
                               
                                
                               
                                 Φ 
                                 * 
                               
                                
                               
                                 O 
                                 * 
                               
                                
                               Θ 
                             
                             } 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           Re 
                            
                           
                               
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               M 
                             
                              
                             
                               
                                 σ 
                                 i 
                               
                                
                               
                                 s 
                                 ii 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   30 
                   ) 
                 
               
             
           
         
       
     
         [0067]    where ΘΣΦ*=SVD(E└V{circumflex over (V)}*|({circumflex over (V)},V)εV k ┘) and T=[s ij ]=Φ*O*Θ is a unitary matrix. Thus, (30) is maximized when all s ii =1, i.e., when O=ΘΦ*. It should be noted that since the final solution depends only on ΘΦ*, it can be obtained directly through the polar decomposition of E└VV*|({circumflex over (V)},V)εV k ┘ instead of the SVD. 
         [0068]    The idea behind differential quantization is to use B 1  bits for the main quantizer and B 2 &lt;B 1  bits for the differential quantizer. For example, in OFDM systems, when the precoder is used for a chunk of adjacent OFDM tones, the precoding is usually much more effective if the chunk size is smaller. Hence, if B bits are available for precoding across a large chunk of adjacent OFDM tones, the chunk is usually broken into several smaller, e.g., 3 sub-chunks of the same sizes where the precoder for each sub-chunk is specified with B/3 bits. However, considering the correlation between the adjacent sub-chunks, we can use a main quantizer with B 1 &gt;B/3 bits for quantizing the center sub-chunk and use a differential codebook with B 2 &lt;B/3 bits for quantizing of each of the other two sub-chunks, where B=B 1 +2B 2 , and B 2 &lt;B 1 . Depending on the correlation structure we can usually pick B 2 &lt;B 1  such that the precoding performance of all three sub-chunks is almost similar. 
         [0069]    The invention may be implemented in hardware, firmware or software, or a combination of the three. Preferably the invention is implemented in a computer program executed on a programmable computer having a processor, a data storage system, volatile and non-volatile memory and/or storage elements, at least one input device and at least one output device. 
         [0070]    Each computer program is tangibly stored in a machine-readable storage media or device (e.g., program memory or magnetic disk) readable by a general or special purpose programmable computer, for configuring and controlling operation of a computer when the storage media or device is read by the computer to perform the procedures described herein. The inventive system may also be considered to be embodied in a computer-readable storage medium, configured with a computer program, where the storage medium so configured causes a computer to operate in a specific and predefined manner to perform the functions described herein. 
         [0071]    The invention has been described herein in considerable detail in order to comply with the patent Statutes and to provide those skilled in the art with the information needed to apply the novel principles and to construct and use such specialized components as are required. However, it is to be understood that the invention can be carried out by specifically different equipment and devices, and that various modifications, both as to the equipment details and operating procedures, can be accomplished without departing from the scope of the invention itself.