Abstract:
A wireless communication method includes a mobile terminal for supporting precoding matrix feedback for multi-user and single-user multiple-input and multiple-output (MIMO) systems. The wireless communication method also includes obtaining, at the mobile terminal, channel state information comprising at least gain information and relative-phase information. Further, the method includes generating precoding matrices comprising b g , p1, p2, and p3 bit groups, wherein each of the precoding matrices are generated by quantization using at least the gain information and the relative-phase information between antenna elements. The method also includes selecting the best precoding matrix among the generated precoding matrices, and transmitting the bit sequence representing the selected precoding matrix to a base station.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
       [0001]    The present application claims priority from U.S. Provisional Application No. 61/552,273, filed Oct. 27, 2011. The content of the priority application is hereby incorporated by reference in its entirety. 
     
    
     BACKGROUND OF INVENTION 
       [0002]    1. Technical Field 
         [0003]    One or more embodiments of the present invention relate to wireless communications technology. Specifically, one or more embodiments of the present invention are used to improve the performance of multi-user multiple-input, multiple-output (MU-MIMO) and single-user MIMO (SU-MIMO) systems that use a bit sequence representing the pre-coding matrix in order to represent the channel state information (CSI) of a user. 
         [0004]    2. Background Art 
         [0005]    Multi-user MIMO, and certain forms of Single-User MIMO, require that the transmitting entity know something about the channel state information (CSI) that exists between the transmitting antennas (e.g. at a base station) and the receiving antennas at one or more receivers (e.g. one or more mobile terminals). Multi-user MIMO (MU-MIMO), in particular, is sensitive to the accuracy in the knowledge of such CSI. Specifically, if the CSI that is assumed at the transmitter, and is used in selecting the users to be served, assigning rates to such users, and forming the beamforming vectors which carry data streams to such users, is different from the CSI that is experienced at the time and frequencies used for transmission, then high-levels of interference may be experienced between the streams of different users. This “intra” transmission interference may severely limit the rates that can be supported by MU-MIMO. 
         [0006]    Many factors come together in determining the “accuracy” of the CSI known at the transmitter and receiver. Some of these depend on the physics of the channel, e.g. how fast the channel changes in time and/or frequency. Some depend on limits imposed by a system design, e.g. the time-delay between estimating the CSI at the receivers, feeding knowledge of such CS back to the transmitter, and ultimately using at the transmitter for directing data transmissions. Another factor is the number of bits used by a receiving entity to describe the CSI to the transmitter via digital feedback. The present release of 3GPP&#39;s LTE design uses only 4 bits to describe a rank-1 channel. 
         [0007]    Part of the reason for using this potentially interference-limited 4-bit LTE design is that LTE has in the past placed strong emphasis on scenarios where either the CS changed rapidly in time and/or frequency, or scenarios where the channel feedback had to describe a state used over a large bandwidth (e.g. 5 to 20 MHz). In such a case channel dynamics dominated over CS feedback accuracy and MU-MIMO does not operate efficiently for such reasons rather than by feedback limitations. Another is a stronger focus on SU-MIMO which requires less accurate CS. 
         [0008]    Even in cases with slower channel dynamics where MU-MIMO can operate efficiently, a difficulty in considering feedback in excess of 4 bits is designing large codebooks that also support rank n&gt;1 feedback. For example, cases where a user may want to represent n=2 subspaces of the 4×2 CS. Other concerns include using a large number of CSI bits in terms of transmission resources and computational/receiver complexity. 
         [0009]    However, such concerns are becoming less important as deployment scenarios look to lower channel dynamics such as lower mobility users and smaller cells. Furthermore, improvement in MIMO spectral efficiency for cases of multiple users ultimately rests on getting MU-MIMO to work efficiently over SU-MIMO improvements. Thus, emphasis is shifting to improving MU-MIMO, to allow for significant spectral efficiency over SU-MIMO. To do so, there is an inherent need for supporting more feedback bits in CSI. 
         [0010]    LTE also presently supports a number of different codebook designs, including FFT and Householder transform-based designs. For operations with N transmit antennas, the designs define a number of orthonormal N×N “precoding matrices” (PMs), each selectable by a “Precoding Matrix Indicator” (PMI) which includes a bit sequence representing the selected code vector entry (precoding matrix) from the codebook. However, the LTE designs are rather constrained, where antenna elements are all given the same gain, and only small numbers of PMs are used. That is, there is no concept of a gain-vector across antennas. In addition, LTE and academic contributions have described designs using “intra-site” and “inter-site” antenna phase differences. However, such designs have not included a number of features described in this particular design and method. 
       SUMMARY OF INVENTION 
       [0011]    According to one or more embodiments of the present invention, a wireless communication method in a mobile terminal for supporting precoding matrix feedback for multi-user and single-user multiple-input and multiple-output (MIMO) systems, includes obtaining, at the mobile terminal, channel state information comprising at least gain information and relative-phase information. The wireless communication method also includes generating precoding matrices comprising bg, p1, p2, and p3 bit groups, wherein each of the precoding matrices are generated by quantization using at least the gain information and the relative-phase information between antenna elements, The method further includes selecting the best precoding matrix among the generated precoding matrices, and transmitting the bit sequence representing the selected precoding matrix to a base station. 
         [0012]    According to one or more embodiments of the present invention, a non-transitory computer readable medium includes software instructions, that when executed, are configured to perform a wireless communication method in a mobile terminal for supporting precoding matrix feedback for multi-user and single-user multiple-input and multiple-output (MIMO) systems. The non-transitory computer readable medium also includes obtaining, at the mobile terminal, channel state information comprising at least gain information and relative-phase information, and generating precoding matrices comprising bg, p1, p2, and p3 bit groups, wherein at least one of the precoding matrices is generated by quantization using at least the gain information and the relative-phase information. Further, the non-transitory computer readable medium includes selecting the best precoding matrix among the generated precoding matrices, and transmitting the bit sequence representing the selected precoding matrix to a base station. 
         [0013]    According to one or more embodiments of the present invention, a mobile terminal supports precoding matrix feedback for multi-user and single-user multiple-input and multiple-output (MIMO) systems. The mobile terminal includes a structured codebook to select a precoding matrix, wherein the structured codebook includes, at least, a joint gain and permutation codebook, an intra-subvector phase codebook, and an inter-subvector phase codebook. The mobile terminal also includes a receiver, wherein the receiver of the mobile terminal receives channel state information (CSI) comprising at least gain information and relative-phase information. Further, the mobile terminal includes and a generating unit, wherein the generating unit of the mobile terminal generates bit sequence representing bit-allocation of each of the joint gain and permutation codebook, the intra-subvector phase codebook and the inter-subvector phase codebook for the optimal precoding matrix, by using at least the gain information and the relative-phase information between antenna elements. The mobile terminal also includes a transmitter, wherein the transmitter of the mobile terminal transmits at least the bit sequence to a base station. 
         [0014]    Other aspects and advantages of the invention will be apparent from the following description and the appended claims. 
     
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         [0015]      FIG. 1  is a flowchart of a quantization process according to one or more embodiments of the present disclosure. 
           [0016]      FIG. 2  is a flowchart of a quantization process using an adaptive bit-allocation to phase components according to one or more embodiments of the present disclosure. 
           [0017]      FIG. 3  is a table 1 of a 2-bit joint gain and permutation codebook according to one or more embodiments of the present disclosure. 
           [0018]      FIG. 4  is a table 2 of a 3-bit joint gain and permutation codebook according to one or more embodiments of the present disclosure. 
           [0019]      FIG. 5  is a table 3 of a 4-bit joint gain and permutation codebook according to one or more embodiments of the present disclosure. 
           [0020]      FIG. 6  is a table 4 of a 4-bit joint gain, permutation and bit-allocation codebook according to one or more embodiments of the present disclosure. 
           [0021]      FIG. 7  is a table 5 that is a flow-chart of rank-1 PMI low-complexity search based on matching to a single 4×1 target vector using the proposed codebook structure according to one or more embodiments of the present disclosure. 
           [0022]      FIG. 8  is a table 6 that is a flow of operations including a gain difference Gdiff between antennas 1 and 2 and antennas 3 and 4 according to one or more embodiments of the present disclosure. 
           [0023]      FIG. 9  is a table 7 that shows optimal designs coming out of tests on data from an ITU-R Urban Micro Channel model with non Line of Sight Data and ½ wavelength antenna spacing. Performance is measured in by the log2( ) value of the expected quantization error performance (lower value is better) according to one or more embodiments of the present disclosure. 
           [0024]      FIG. 10  is a table 8 that shows a method of indicating rank via a “Rank Indicator” and the associated vectors for rank 1, 2, 3, and 4. 
           [0025]      FIG. 11  is a table 9 that shows a method of indicating rank 1 or rank 2, with a flexible definition of the rank 2 accompanying vector according to one or more embodiments of the present disclosure. 
       
    
    
     DETAILED DESCRIPTION 
       [0026]    In embodiments of the invention, numerous specific details are set forth in order to provide a more thorough understanding of the invention. However, it will be apparent to one with ordinary skill in the art that the invention may be practiced without these specific details. In other instances, well-known features have not been described in detail to avoid obscuring the invention. 
         [0027]    For purposes of readability and illustration, one or more embodiments of the present disclosure relate generally to codebook designs. According to one or more embodiments, a codebook W is a set of indexed code vectors which are used to quantize the channel matrix or its eigenvectors, etc. Further, the more quantization bits, the better one can match the channel estimated at the receiver. Additionally, an important issue in codebook-based precoding transmission is how to design the codebook so that only a relatively small number of bits are feedback to the transmitter side which are used for generating precoding transmit vectors, thereby consuming relatively limited uplink resources. Another important issue is how to choose the metric which serves for selecting the best codebook vector from available set W. For example, in the scenario of 4 transmitting antennas, and with users having up to 2 receiving antennas, the system may send a single stream to each of say four users, sending streams concurrently in time and frequency via MU-MIMO. To allow for this joint MU-MIMO transmission, each such user in this scenario will describe to the transmitter a 4×1 preferred precoding transmit vector (sub-space representation (i.e. “rank 1 approximation”)) of the total 4×2 channel state space they are experiencing between the transmitter and their two receive antennas. Those of ordinary skill in the art would appreciate that embodiments of the invention are scalable to include more transmitting antennas and receiving antennas. Accordingly, the invention is not limited to 4 transmitting antennas and 2 receiving antennas. 
         [0028]    According to one or more embodiments of the present disclosure, there exists a case in which the CS of antennas are relatively independent, and channel/deployment scenarios where the channel is sufficiently stable over time (e.g. 20 msec) and sufficiently coherent over a block in frequency (e.g. over 1 MHz) such that accuracy of CS is not strongly impacted by channel dynamics or delays in feedback. In such a case, when users have signal to noise ratios (SNRs) between 6 and 10 dB, the minimum number of bits that are needed to describe the CSI of each user can range from 8 to 20 “CSI feedback bits.” CSI feedback bits represent the minimum number of bits that are necessary to provide sufficient CSI accuracy so that the MU-MIMO transmission is not strongly intra-interference limited. 
         [0029]    One or more embodiments of the present invention provide a low complexity apparatus and method which has the ability to support a greater number of CSI feedback bits, e.g. 8 to 12 bits, up to 20 bits and greater. The design is structured, breaking the CSI feedback bits into different parameters which may be individually searched in a sequence of operations. The particular structure chosen allows for low-complexity approaches in determining the CSI feedback bits, and in calculating associated parameters such as rank and channel quality. The particular representation for the gain via a joint permutation and gain vector is very efficient. Further, the designs, extend rank-1 elements to rank-(n&gt;1) elements via simple operations. Furthermore, the designs may be naturally extended to a design for 8 transmitting antennas. The use of gain information and relative-phase parameters also has the potential to extend to cases such as Coordinated Multi-Point (CoMP) and various polarized antenna relationships. 
         [0030]    More specifically, according to one or more embodiments of the present disclosure, a structured codebook design is disclosed which combines principles of classic product vector quantizers, permutation vector quantizers, and partial order bit-allocation quantizers. Further, embodiments of the present invention allow for a specific application to that of channel state information (CSI) quantization, and structured searches which match those applicable to different wireless deployment scenarios. 
         [0031]    The codebook design and search method according to one or more embodiments of the present disclosure provides a low complexity way to support large numbers of PMI bits than presently used in LTE. The design is structured, breaking the PMI bits into different parameters which can be individually searched in groups of subvectors using a sequence of operations. In some cases, such groups of operations and sub-vectors naturally match expected properties of antennas and antenna deployment scenarios. 
         [0032]    According to one or more embodiments of the present invention, a structured codebook may include a joint gain and permutation codebook, an intra-subvector phase codebook, and an inter-subvector phase codebook. 
         [0033]    The design and search method according to one or more embodiments of the present disclosure may also provide a way to easily define rank n&gt;1 pre-coding matrix codebooks by simple operations (e.g. permutations and conjugations) on rank 1 elements. This further enables structured calculations to reduce computational load in PMI and channel quality indication (CQI) determinations. The design may advantageously use the existing type of feedback mechanism in LTE consisting of a Precoding Matrix Indicator and a Rank Indicator. 
         [0034]    Furthermore, the designs can be naturally extended to accommodate other numbers of transmitting antennas, e.g. 5, 6, 8, etc. The use of gain information and relative-phase parameters also has the potential to extend to cases such as CoMP and various polarized antenna relationships. 
         [0035]    According to one or more embodiments of the present disclosure, a rank-1 element, v: vεC 4×1 , of a B-bit codebook C B  is represented by a separate encoding of gain information and phase information into different bits. Each vector is represented by information defining two 2-dimensional sub-vectors and a relationship between such sub-vectors. Phase information represents both relative phase within each sub-vector and the relative phase between sub-vectors. The gain information is coded jointly across the 4 dimensional vector using a permutation codebook with an associated bit-allocation. The permutation assigns various antennas to sub-vectors, and thus various antennas to possible gain values. The gain values, defined by gain vectors, can also define bit-allocations to different phase components. 
         [0036]    According to one or more embodiments of the present disclosure, for a target vector q: qεC 4×1 , the codebook is designed to maximize a quantization of the channel direction, as apposed to the precise phases of the vector. Specifically, the optimal element in the codebook is selected by the following equation: 
         [0000]        v   opt =arg max v∈C     B     |v   H   q|   
         [0037]    It should be noted that one effect of this definition of the optimal element is that the optimal selection is not affected by an overall phase scaling of either the target vector or any of the codebook elements. Specifically, this lack of affect is shown in, at least, the following equation: 
         [0000]        v   opt =arg max v∈C     B     |v   H   q|= arg max v∈C     B   max −π≦φ≦π   |v   H   e   jφ   q|   
         [0038]    Furthermore, as in general operation, q is a norm-1 vector. Any additional “gain” to this vector, representing the overall strength, e.g. signal-to-noise ratio, of the channel is represented by other parameters, e.g. a channel quality indicator (CQI) value. 
         [0039]    The result is that the codebook structure has one less complex dimension that it needs to represent than if it were designed to represent mean-square error approximation to v. The one less dimension comes from the combination of the one irrelevant overall phase and the restriction to norm-1 vectors. Thus, the codebook elements “effectively” exist in a 3-dimensional subspace of a 4-dimensional space. This is in fact represented in the codebook by a codebook which assumes one of the elements of each vector vεC B  is in fact a real positive scalar (phase=0), and by ∥v∥=1 for all vεC B . 
         [0040]    Rank 1 PM Vectors and Parameters 
         [0041]    According to one or more embodiments of the present disclosure, each element v is defined by 4 parameters. The first parameter is a joint gain vector and permutation specified using b g  bits. This can also be used to define the bit-allocation between the 3 different phase components. The second and third parameters are two intra-subvector relative phase scalars θ 1  and θ 2  represented by p 1  and p 2  bits respectively. The fourth parameter is an inter-subvector phase scalar θ 3  represented by p 3  bits. 
         [0042]    Further, according to one or more embodiments of the present disclosure, a B bit codebook is defined by b g +p 1 +p 2 +p 3 =B for all possible vector elements defined in the codebook. Thus the 2 B  combinations of bits represented in all combinations of all values of the 4 parameters defines 2 B  unique code vectors. 
         [0043]    Note, the values p 1 , p 2 , and p 3  do not have to be the same for different elements of the codebook. As noted above, the value of p 1 , p 2  and p 3  can adapt to the information defined in the b g  gain/permutation bits. This may be of particular interest for large B 
         [0044]    According to one or more embodiments of the present disclosure, each element v has the following structure: 
         [0000]    
       
         
           
             
               v 
               = 
               
                 [ 
                 
                   
                     
                       
                         w 
                          
                         
                           ( 
                           
                             i 
                              
                             
                               ( 
                               1 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           
                             i 
                              
                             
                               ( 
                               2 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           
                             i 
                              
                             
                               ( 
                               3 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           
                             i 
                              
                             
                               ( 
                               4 
                               ) 
                             
                           
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
             
              
             
                 
             
           
         
       
       
         
           
             
               where 
                
               
                   
               
                
               
                 { 
                 
                   
                     i 
                      
                     
                       ( 
                       1 
                       ) 
                     
                   
                   , 
                   
                     i 
                      
                     
                       ( 
                       2 
                       ) 
                     
                   
                   , 
                   
                     i 
                      
                     
                       ( 
                       3 
                       ) 
                     
                   
                   , 
                   
                     i 
                      
                     
                       ( 
                       4 
                       ) 
                     
                   
                 
                 } 
               
                
               
                   
               
                
               is 
                
               
                   
               
                
               a 
                
               
                   
               
                
               specified 
                
               
                   
               
                
               permutation 
             
              
             
                 
             
           
         
       
       
         
           
             of 
              
             
                 
             
              
             
               { 
               
                 1 
                 , 
                 2 
                 , 
                 3 
                 , 
                 4 
               
               } 
             
           
         
       
       
         
           with 
         
       
       
         
           
             w 
             = 
             
               
                 [ 
                 
                   
                     
                       
                         w 
                          
                         
                           ( 
                           1 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           2 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           3 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           4 
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
               = 
               
                 [ 
                 
                   
                     
                       
                           
                       
                     
                     
                       
                         [ 
                         
                           
                             
                               
                                 g 
                                  
                                 
                                   ( 
                                   1 
                                   ) 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   g 
                                    
                                   
                                     ( 
                                     2 
                                     ) 
                                   
                                 
                                  
                                 
                                    
                                   
                                     jθ 
                                     1 
                                   
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                   
                     
                       
                          
                         
                           j 
                            
                           
                               
                           
                            
                           
                             θ 
                             3 
                           
                         
                       
                     
                     
                       
                         [ 
                         
                           
                             
                               
                                 g 
                                  
                                 
                                   ( 
                                   3 
                                   ) 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   g 
                                    
                                   
                                     ( 
                                     4 
                                     ) 
                                   
                                 
                                  
                                 
                                    
                                   
                                     jθ 
                                     2 
                                   
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                 
                 ] 
               
             
           
         
       
       
         
           
             and 
              
             
                 
             
              
             where 
              
             
                 
             
              
             the 
              
             
                 
             
              
             
               { 
               
                 
                   i 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
              
             
                 
             
              
             and 
              
             
                 
             
              
             
               { 
               
                 
                   g 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
           
         
       
       
         
           
             are 
              
             
                 
             
              
             defined 
              
             
                 
             
              
             in 
              
             
                 
             
              
             a 
              
             
                 
             
              
             joint 
              
             
                 
             
              
             codebook 
           
         
       
     
         [0045]    We now describe in detail the representation of each of these parameters. 
         [0046]    Joint Permutation and Gain Codebook 
         [0047]    The permutation I={i(1),i(2),i(3),i(4)} and gain vector g={g(1),g(2),g(3),g(4)} are defined as one of 2̂ {g b } combinations. These combinations form a g b -bit codebook. Different B values will often use different values of g b , as defined by the relative accuracy needed of such information within the context of a total bit budget B. Each such value of g b , can also have a different structure. 
         [0048]    A codebook design for g b =2 bits is shown in  FIG. 3 , according to one or more embodiments of the present disclosure. There are a number of useful points to note in this embodiment. A first point is that there is a single gain vector which is defined though a value a in dB. It can be assumed that α&gt;0, so that the first element g(1)&gt;g(2)=g(3)=g(4). Another point is that the first element in the k-th permutation is k. Essentially, one of the best permutation for representing a target CS is the k-th if the k-th antenna of the CS is the one with the largest gain. This antenna gets the largest gain value g(1). Further, in the design of such a codebook the value α to be used can be pre-selected using tests on simulations over a variety of conditions in order to maximize the overall performance of the quantizer. An example of this is given later. 
         [0049]      FIG. 4 , Table 2, shows one potential design of a joint permutation-gain codebook for g b =3 bits according to one or more embodiments of the present disclosure. There are a number of useful points to note relating to this embodiment. A first point is that there are two gain vectors, where one is the equal gain vector. The other gain vector is defined through a value β in dB. We assume β&gt;0, so that the first element g(1)=g(2)&gt;g(3)=g(4). 
         [0050]    Another point worth noting is that, according to one or more embodiments of the present disclosure, the permutation for codebook index value 0 is associated with use of the equal gain vector. Thus, in terms of the gain, many permutations can be used, all being equivalent in assigning gains to antennas. However, in the method it may be necessary to specify a permutation in order to map antennas to sub-vectors. Thus the permutation [1,2,3,4] is used without loss in generality. 
         [0051]    Further, it is also worth noting that, for one or more embodiments according to the present disclosure, the permutations for codebook index values 1, 2, . . . , 6 represent a selection of two antennas as the ones to get the larger gain values {g(1),g(2)}. These elements represent use of an unequal gain gain-vector. As worth noting, the unequal-gain gain vector may be parameterized by a value β. This value can be designed, and chosen apriori, via a search using many simulations over a variety of conditions. 
         [0052]    Additionally, it is also worth nothing that, for one or more embodiments of the present disclosure, the gain vector allows the quantizer to handle the case of independent antennas, where antennas will naturally experience different scaling factors. Further, this design can also be very applicable for cross-polarized arrangements even with strongly dependent antennas. Specifically, in cross-polarized arrangements one polarization can have a different average antenna “receive strength” as compared to another polarization. Here at least two of the permutations in values 1, 2, . . . ,6 are useful in representing that gain imbalance between the two pairs of antennas in a cross-polarized arrangement. 
         [0053]      FIG. 5 , Table 3, shows a design of a joint permutation-gain codebook for g b =4 bits according to one or more embodiments of the present disclosure. It is worth noting that there are three gain vectors. One is defined by a value κ in dB. The value κ is greater than 0 dB, so that the first element g(1)&gt;g(2)=g(3)=g(4). The other two are defined by one of two values, δ and T respectively (both in dB). Both values are greater than 0 dB, so that the first element g(1)=g(2)&gt;g(3)=g(4). The increased number of elements and parameters allows finer modeling of gain variations between antennas. Additionally, the permutations for index values 1, 2, . . . , 6 and 7, 8, . . . , 15 represent a selection of two antennas as the ones to get the larger gain values {g(1),g(2)}. As with the 3-bit design, the permutation structure may also be useful in cross polarized arrangements. 
         [0054]    Joint Permutation, Gain, and Phase-bit Allocations 
         [0055]    According to one or more embodiments of the present disclosure, a design of the permutation-gain codebook can be extended to a design which allows the bit-allocation to different phase components to adapt with the gain vector and permutation used. For example, if one takes the case of B=20 and an embodiment of a design which uses the 4-bit gain codebook structure as shown in  FIG. 5 , p1+p2+p3=20−4=16 for such a design. 
         [0056]    In another example, according to one or more embodiments of the present disclosure, if for the permutation-gain elements corresponding to index values 0, 1, 2, 3, one assumes that the design is such that the value κ is a moderate value, e.g. on the order of 3.0 dB, the design uses more bits for p1 than for p2. This is because the first sub-vector has an antenna with higher gain than the second sub-vector. However, given the moderate gain difference, only one more bit is assigned to p1 over p2. 
         [0057]    In another example, according to one or more embodiments of the present disclosure, if for the permutation-gain elements corresponding to index values 4, 5, . . . , 9, one assumes that the design is such that the value δ is a larger value, e.g. on the order of 9.0 dB, then again, in this case the design uses more bits for p1 than for p2. This is because the first sub-vector has an antenna with higher gain than the second sub-vector. However, given the larger gain difference, 3 more bits (3 less bits) are assigned to p1 (p2) than for index values 0, 1, 2, 3. 
         [0058]    In another example, according to one or more embodiments of the present disclosure, if for the permutation-gain elements corresponding to index values 10, 11, . . . , 15, one assumes that the design is such that the value τ is a moderate value, e.g. on the order of 3.0 dB, yet again, in this case as well the design uses more bits for p1 than for p2, but here the difference in bit-allocation is less, with only 1 more bit assigned to p1 over p2. This design principle can also be naturally extended to the 3-bit codebook design in  FIG. 4 . A flow-chart of the quantization process is shown in  FIG. 2 . 
         [0059]    Phase Codebooks 
         [0060]    According to one or more embodiments of the present disclosure, the phase codebooks each represent a sampling of phases from 0 to 2π. Further, in one or more embodiments, a uniform sampling of phases can be used where the sampling granularity is defined by the number of bits (i.e. p 1 , p 2 , or p 3 ) for the given phase value. Such bit assignments, as noted before, are possibly adaptive to the gain-permutation information. 
         [0061]    According to one or more embodiments of the present disclosure, for the intra-subvector phases using uniform sampling, one can think of the phase codebook as a codebook of 2-dimensional vector elements as follows: 
         [0000]    
       
         
           
             
               Intra 
                
               
                 - 
               
                
               subvector 
                
               
                   
               
                
               phase 
                
               
                   
               
                
               codebook 
                
               
                   
               
                
               
                 “ 
                 k 
                 ” 
               
             
             = 
             
               
                 Φ 
                 k 
               
               = 
               
                 
                   { 
                   
                     
                       
                         
                           [ 
                           
                             
                               
                                 1 
                               
                             
                             
                               
                                 
                                    
                                   
                                     j 
                                      
                                     
                                         
                                     
                                      
                                     2 
                                      
                                     π 
                                      
                                     
                                         
                                     
                                      
                                     
                                       0 
                                       / 
                                       
                                         P 
                                         k 
                                       
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                       
                         
                           [ 
                           
                             
                               
                                 1 
                               
                             
                             
                               
                                 
                                    
                                   
                                     j 
                                      
                                     
                                         
                                     
                                      
                                     2 
                                      
                                     π 
                                      
                                     
                                         
                                     
                                      
                                     
                                       1 
                                       / 
                                       
                                         P 
                                         k 
                                       
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                       
                         … 
                       
                       
                         
                           [ 
                           
                             
                               
                                 1 
                               
                             
                             
                               
                                 
                                    
                                   
                                     
                                       j2π 
                                        
                                       
                                         ( 
                                         
                                           
                                             P 
                                             k 
                                           
                                           - 
                                           1 
                                         
                                         ) 
                                       
                                     
                                     / 
                                     
                                       P 
                                       k 
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   } 
                 
                 = 
                 
                   
                     
                       { 
                       
                         
                           
                             
                               φ 
                               
                                 k 
                                 , 
                                 0 
                               
                             
                           
                           
                             
                               φ 
                               
                                 k 
                                 , 
                                 1 
                               
                             
                           
                           
                             … 
                           
                           
                             
                               φ 
                               
                                 k 
                                 , 
                                 
                                   
                                     P 
                                     k 
                                   
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                       
                       } 
                     
                      
                     
                         
                     
                      
                     where 
                      
                     
                         
                     
                      
                     
                       P 
                       k 
                     
                   
                   = 
                   
                     2 
                     
                       p 
                       k 
                     
                   
                 
               
             
           
         
       
     
         [0062]    Similarly, the inter-subvector phase codebook follows a similar structure, except that only a scalar value is needed as show here: 
         [0000]    
       
         
           
             Inter 
              
             
               - 
             
              
             subvector 
              
             
                 
             
              
             phase 
              
             
                 
             
              
             codebook 
           
         
       
       
         
           
             
               
                 
                   Ω 
                   = 
                     
                    
                   
                     { 
                     
                       
                         
                           
                              
                             
                               j 
                                
                               
                                   
                               
                                
                               2 
                                
                               π 
                                
                               
                                   
                               
                                
                               
                                 0 
                                 / 
                                 
                                   P 
                                   3 
                                 
                               
                             
                           
                         
                         
                           
                              
                             
                               j2π 
                                
                               
                                   
                               
                                
                               
                                 1 
                                 / 
                                 
                                   P 
                                   3 
                                 
                               
                             
                           
                         
                         
                           … 
                         
                         
                           
                              
                             
                               
                                 j2π 
                                  
                                 
                                   ( 
                                   
                                     
                                       P 
                                       3 
                                     
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                               / 
                               
                                 P 
                                 3 
                               
                             
                           
                         
                       
                     
                     } 
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       
                         { 
                         
                           
                             
                               
                                 ω 
                                 0 
                               
                             
                             
                               
                                 ω 
                                 1 
                               
                             
                             
                               … 
                             
                             
                               
                                 ω 
                                 
                                   
                                     P 
                                     3 
                                   
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                         } 
                       
                        
                       
                           
                       
                        
                       where 
                        
                       
                           
                       
                        
                       
                         P 
                         3 
                       
                     
                     = 
                     
                       2 
                       
                         p 
                         3 
                       
                     
                   
                 
               
             
           
         
       
     
         [0063]    The use of these vector and scalar codebooks are useful when executing low-complexity codebook searches. 
         [0064]    Low-Complexity Search for Optimal PMI 
         [0065]    According to one or more embodiments of the present disclosure, a codebook structure may allow one to implement low-complexity strategies that can be applied to the existing rank-1 feedback search which assumes maximal-ratio combining (MRC) at the receiver as discussed below. 
         [0066]    The codebook structure and low-complexity strategies can also be applied to a search of a value qεC 4×1 , ∥q∥=1, defined by a principle component analysis. This provides at least one illustrative embodiment of the search method which could be applied to CS feedback where CS is determined by such a principle component analysis. 
         [0067]      FIG. 7 , outlines the steps and associated rougher complexity estimates with such a search according to one or more embodiments of the present disclosure. Further,  FIG. 1  outlines the basic flow-chart of operations according to one or more embodiments of the present disclosure. As shown in  FIG. 1 , permutation and gain information can be determined by a simple ordering of the energy, also known as gain, seen on different antennas. Intra-subvector phase information is searched independently and separately for each sub-vector. The search of the inter-subvector information is a low-complexity search using some pre-computed scalar values which depend on the intra-subvector phase and gain information. 
         [0068]    Specifically, as shown in  FIG. 1 , according to one or more embodiments of the present disclosure, the quantization process which begins with selecting permutation and gain information by defining b g  feedback bits specifying an index into a joint permutation-gain codebook (S 100 ). Next in the quantization process comes dividing the target vector into two sub-vectors based on the permutation (S 101 ). Once divided, next comes selecting intra-subvector phase information for sub-vector 1 by defining p 1 bits describing θ 1  (S 102 ), selecting intra-subvector phase information for sub-vector 2 by defining p2 bits describing θ 2  (S 103 ), and selecting inter-subvector phase by defining p3 bits describing θ 3  (S 104 ). Finally, the quantization process is completed by grouping b g , p1 , p2, and p3 bits of information into the precoding matrix indicator for transmission to the base station (S 105 ). 
         [0069]    As shown in  FIG. 2 , according to one or more embodiments of the present disclosure, quantization in the mobile terminal using adaptive bit-allocation and phase components beings with selecting permutation and gain information by defining b g  feedback bits specifying an index into the joint permutation-gain codebook (S 200 ). Once selected, quantization continues by dividing the target vector into two sub-vectors based on permutation (S 201 ) and deriving the bit-allocation {p1, p2, p3} to phase components from index into joint permutation-gain codebook (S 202 . Once divided and derived next comes, selecting, given p1, intra-subvector phase information for sub-vector 1 by defining p1 bits describing θ 1  (S 203 ), selecting, given p2, intra-subvector phase information for sub-vector 2 by defining p2 bits describing θ 2  (S 204 ), and selecting, given p3, inter-subvector phase by defining p3 bits describing θ 3  (S 205 ). Finally, the quantization process is completed by grouping b g , p1, p2, and p3 bits of information into the precoding matrix indicator for transmission to the base station (S 206 ). 
         [0070]    Performance Example With Joint Permutation and Gain Encoding 
         [0071]    As an example of quantizing gain, and the efficiency of the joint permutation-gain approach and the low-complexity search method of  FIG. 6 , experimental results on the quantization error performance of the proposed method are provided in  FIG. 9 . 
         [0072]    The quantization error of a codebook C B  may be quantified using the following metric: 
         [0000]      Quantization error performance=Expected Value over data “q” of (1−max vεC     B     |v   H   q|   2 )
 
         [0073]    The lower the value of this quantization error, the better the performance of the design. 
         [0074]      FIG. 9 , shows the performances of the optimal designs coming from a test using ITU-R channels according to one or more embodiments of the present disclosure. The data set represents 800,000 samplings of channels “q” using many randomly generated of the time-domain response of the channel. These time domain responses are used to sample 4×1 frequency domain CS values of the channel at various points in frequency. The channel scenario used is that of an Urban Micro (UMi) channel with co-polarized antennas at ½ wavelength spacing in a non Line of Sight (nLOS) condition. A theoretical upperbound on performance of a B bit quantizer operating on channel samples coming from independent antennas with Rayleigh channels is 2 -B/3 . Thus for B=12 bits the log 2 ( ) of this upperbound value is −4.0. Tests show that the Urban Micro scenario described has about the same upperbound performance. 
         [0075]    As  FIG. 9  shows, performance improves monotonically from b g =0 to 4 bits, for increasing size of the permutation-gain codebook design up to 4 bits. Furthermore, at b g =12 the near upperbound is reached as defined by Rayleigh channels, which is also the near upperbound for this UMi scenario. The results show, therefore, that representing information on the gain in the CS is an important performance enhancer. Furthermore, the proposed design and quantization search method yields near upperbound performance. 
         [0076]    Rank-(n&gt;1) Extensions 
         [0077]    According to one or more embodiments of the present disclosure, for every possible target, defined by a combination of permutation-gain and phase indices g*, n*, m* and r*, (i.e. values g, permutation, and values θ 1 , θ 2 , and θ 3 ) there is an easy way to define a Rank-(n&gt;1) (n≦4) companion to the Rank-1 vector. 
         [0078]    Specifically, as an example, one may consider the rank-1 codebook element as follows: 
         [0000]    
       
         
           
             v 
             = 
             
               
                 
                   [ 
                   
                     
                       
                         
                           w 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 1 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 2 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 3 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 4 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
                  
                 
                     
                 
                  
                 where 
                  
                 
                     
                 
                  
                 w 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                           w 
                            
                           
                             ( 
                             1 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                             ( 
                             2 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                             ( 
                             3 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                             ( 
                             4 
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
                 = 
                 
                   [ 
                   
                     
                       
                         
                             
                         
                       
                       
                         
                           [ 
                           
                             
                               
                                 
                                   g 
                                    
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       2 
                                       ) 
                                     
                                   
                                    
                                   
                                      
                                     
                                       jθ 
                                       1 
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                     
                       
                         
                            
                           
                             j 
                              
                             
                                 
                             
                              
                             
                               θ 
                               3 
                             
                           
                         
                       
                       
                         
                           [ 
                           
                             
                               
                                 
                                   g 
                                    
                                   
                                     ( 
                                     3 
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       4 
                                       ) 
                                     
                                   
                                    
                                   
                                      
                                     
                                       jθ 
                                       2 
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   ] 
                 
               
             
           
         
       
       
         
           
             
               with 
                
               
                   
               
                
               
                 { 
                 
                   
                     i 
                      
                     
                       ( 
                       1 
                       ) 
                     
                   
                   , 
                   
                     i 
                      
                     
                       ( 
                       2 
                       ) 
                     
                   
                   , 
                   
                     i 
                      
                     
                       ( 
                       3 
                       ) 
                     
                   
                   , 
                   
                     i 
                      
                     
                       ( 
                       4 
                       ) 
                     
                   
                 
                 } 
               
                
               
                   
               
                
               as 
                
               
                   
               
                
               a 
                
               
                   
               
                
               specified 
                
               
                   
               
                
               permutation 
                
               
                   
               
                
               of 
             
              
             
                 
             
           
         
       
       
         
           
             { 
             
               1 
               , 
               2 
               , 
               3 
               , 
               4 
             
             } 
           
         
       
     
         [0079]    With the above rank-1 codebook under consideration, one potential definition of a corresponding rank-2 codebook element is defined by: 
         [0000]    
       
         
           
             
               
                 v 
                  
                 
                     
                 
                  
                 2 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           2 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 1 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           2 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 2 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           2 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 3 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           2 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 4 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
                  
                 
                     
                 
                  
                 where 
               
             
              
             
                 
             
           
         
       
       
         
           
             
               w 
                
               
                   
               
                
               2 
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         w 
                          
                         
                             
                         
                          
                         2 
                          
                         
                           ( 
                           1 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                             
                         
                          
                         2 
                          
                         
                           ( 
                           2 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                             
                         
                          
                         2 
                          
                         
                           ( 
                           3 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                             
                         
                          
                         2 
                          
                         
                           ( 
                           4 
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
               = 
               
                 [ 
                 
                   
                     
                       
                         
                            
                           
                             - 
                             
                               jθ 
                               3 
                             
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     - 
                                     
                                       g 
                                        
                                       
                                         ( 
                                         2 
                                         ) 
                                       
                                     
                                   
                                    
                                   
                                      
                                     
                                       - 
                                       
                                         jθ 
                                         1 
                                       
                                     
                                   
                                 
                               
                             
                             
                               
                                 
                                   g 
                                    
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   
                     
                       
                         [ 
                         
                           
                             
                               
                                 
                                   - 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       4 
                                       ) 
                                     
                                   
                                 
                                  
                                 
                                    
                                   
                                     - 
                                     
                                       jθ 
                                       2 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 g 
                                  
                                 
                                   ( 
                                   3 
                                   ) 
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                 
                 ] 
               
             
           
         
       
       
         
           
             with 
              
             
                 
             
              
             
               { 
               
                 
                   i 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
              
             
                 
             
              
             and 
              
             
                 
             
              
             
               { 
               
                 
                   g 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
              
             
                 
             
              
             being 
              
             
                 
             
              
             the 
           
         
       
       
         
           
             same 
              
             
                 
             
              
             gain 
              
             
                 
             
              
             and 
              
             
                 
             
              
             permutation 
              
             
                 
             
              
             used 
              
             
                 
             
              
             in 
              
             
                 
             
              
             the 
              
             
                 
             
              
             corresponding 
           
         
       
       
         
           
             rank 
             - 
             
               1 
                
               
                   
               
                
               
                 element 
                 . 
               
             
           
         
       
     
         [0080]    This is just one possible definition, because there are many possible vectors v2 orthogonal to v. One property of this particular definition, is that the sub-vectors maintain the same gain values, i.e. pairs of elements in v2 and use the same pair of gains as in v. Also, because the assignment of antennas to different sub-vectors is preserved, PMI and CQI searches can, for rank-1 and rank-2 determination and searches, be broken down conveniently into sub-vectors. Furthermore, the definition is easily formed by simple flipping of pairs of elements, and negations and conjugations of values. 
         [0081]    According to one or more embodiments of the present disclosure, Rank-3 and Rank-4 elements can also be defined. 
         [0082]    For example, according to one or more embodiments of the present disclosure, the following vector u 3  is orthogonal to v, but not necessarily orthogonal to v 2 . 
         [0000]    
       
         
           
             
               u 
                
               
                   
               
                
               3 
             
             = 
             
               
                 
                   [ 
                   
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 1 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 2 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 3 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 4 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
                  
                 
                     
                 
                  
                 where 
                  
                 
                     
                 
                  
                 w 
                  
                 
                     
                 
                  
                 3 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             1 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             2 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             3 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           3 
                            
                           
                             ( 
                             4 
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
                 = 
                 
                   [ 
                   
                     
                       
                         
                           
                              
                             
                               
                                 - 
                                 j 
                               
                                
                               
                                   
                               
                                
                               
                                 θ 
                                 3 
                               
                             
                           
                            
                           
                             [ 
                             
                               
                                 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       3 
                                       ) 
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     
                                       - 
                                       
                                         g 
                                          
                                         
                                           ( 
                                           4 
                                           ) 
                                         
                                       
                                     
                                      
                                     
                                        
                                       
                                         
                                           - 
                                           j 
                                         
                                          
                                         
                                             
                                         
                                          
                                         
                                           θ 
                                           2 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             ] 
                           
                         
                       
                     
                     
                       
                         
                           [ 
                           
                             
                               
                                 
                                   - 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       1 
                                       ) 
                                     
                                   
                                 
                               
                             
                             
                               
                                 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       2 
                                       ) 
                                     
                                   
                                    
                                   
                                      
                                     
                                       
                                         - 
                                         j 
                                       
                                        
                                       
                                           
                                       
                                        
                                       
                                         θ 
                                         1 
                                       
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   ] 
                 
               
             
           
         
       
       
         
           
             with 
              
             
                 
             
              
             
               { 
               
                 
                   i 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
              
             
                 
             
              
             and 
              
             
                 
             
              
             
               { 
               
                 
                   g 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
              
             
                 
             
              
             being 
              
             
                 
             
              
             the 
           
         
       
       
         
           
             
               same 
                
               
                   
               
                
               gain 
                
               
                   
               
                
               and 
                
               
                   
               
                
               permutation 
                
               
                   
               
                
               used 
                
               
                   
               
                
               in 
                
               
                   
               
                
               the 
                
               
                   
               
                
               corresponding 
             
              
             
                 
             
           
         
       
       
         
           
             rank 
             - 
             
               1 
                
               
                   
               
                
               
                 element 
                 . 
               
             
           
         
       
     
         [0083]    One can, however, define a rank-3 element v3 as follows: 
         [0000]        v 3= x 3/ ∥x 3∥ where  x 3= u 3−( v 2 H   u 3) u 3
 
         [0000]      Note, ∥ x 3∥ 2 =1−| v 2 H   u 3
 
         [0084]    Further, according to one or more embodiments of the present disclosure, the following vector u4 is orthogonal to v, but not necessarily orthogonal to v. 
         [0000]    
       
         
           
             
               u 
                
               
                   
               
                
               4 
             
             = 
             
               
                 
                   [ 
                   
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 1 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 2 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 3 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 4 
                                 ) 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
                  
                 
                     
                 
                  
                 where 
                  
                 
                     
                 
                  
                 w 
                  
                 
                     
                 
                  
                 4 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             1 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             2 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             3 
                             ) 
                           
                         
                       
                     
                     
                       
                         
                           w 
                            
                           
                               
                           
                            
                           4 
                            
                           
                             ( 
                             4 
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
                 = 
                 
                   [ 
                   
                     
                       
                         
                           
                              
                             
                               
                                 - 
                                 j 
                               
                                
                               
                                   
                               
                                
                               
                                 θ 
                                 3 
                               
                             
                           
                            
                           
                             [ 
                             
                               
                                 
                                   
                                     
                                       g 
                                        
                                       
                                         ( 
                                         4 
                                         ) 
                                       
                                     
                                      
                                     
                                        
                                       
                                         jθ 
                                         2 
                                       
                                     
                                   
                                 
                               
                               
                                 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       3 
                                       ) 
                                     
                                   
                                 
                               
                             
                             ] 
                           
                         
                       
                     
                     
                       
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     - 
                                     
                                       g 
                                        
                                       
                                         ( 
                                         2 
                                         ) 
                                       
                                     
                                   
                                    
                                   
                                      
                                     
                                       jθ 
                                       1 
                                     
                                   
                                 
                               
                             
                             
                               
                                 
                                   - 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       1 
                                       ) 
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   ] 
                 
               
             
           
         
       
       
         
           
             with 
              
             
                 
             
              
             
               { 
               
                 
                   i 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   i 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
              
             
                 
             
              
             and 
              
             
                 
             
              
             
               { 
               
                 
                   g 
                    
                   
                     ( 
                     1 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     2 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     3 
                     ) 
                   
                 
                 , 
                 
                   g 
                    
                   
                     ( 
                     4 
                     ) 
                   
                 
               
               } 
             
              
             
                 
             
              
             being 
              
             
                 
             
              
             the 
           
         
       
       
         
           
             same 
              
             
                 
             
              
             gain 
              
             
                 
             
              
             and 
              
             
                 
             
              
             permutation 
              
             
                 
             
              
             used 
              
             
                 
             
              
             in 
              
             
                 
             
              
             the 
              
             
                 
             
              
             corresponding 
           
         
       
       
         
           
             rank 
             - 
             
               1 
                
               
                   
               
                
               
                 element 
                 . 
               
             
           
         
       
     
         [0085]    One can, however, define a rank-4 element v4 as follows: 
         [0000]        v 4= x 4/∥ x 4∥ where  x 4= u 4−( v   H   u 4) u 4
 
         [0000]      Note, ∥ x 4∥ 2 =1−| v 1 H   u 4| 2  
 
         [0086]    According to one or more embodiments of the present disclosure, in the system, rank n&gt;0 feedback (and requested transmission) by a user can follow two procedures. One procedure is that the vectors v, v 2 , v 3 , and v 4 , are ordered. Feedback would include 2 additional bits, a Rank Indicator (RI), specifying the requested rank that the receiver would like used. Here rank=1 would imply only v, rank=2 would imply use of the pair {v, v 2 }, rank=3 would imply use of the triplet {v, v 2 , v 3 }, and rank=4 would imply use of all dimensions {v, v 2 , v 3 , v 4 }. This is described in  FIG. 10 , which follows the procedure now used with the 4-bit codebook in LTE Release 9. 
         [0087]    Another example would be to allow for flexible selection of the 2n d  vector in a rank-2 requested feedback scenario. For example, only two more additional bits is sufficient to feedback the second vector accompanying the rank-1 vector in case of rank-2 transmission. This is described in  FIG. 11 . 
         [0088]    Infrequent Gain-Feedback Extensions for Cases With Large Antenna Gain Imbalances 
         [0089]    According to one or more embodiments of the present disclosure, the gain-vectors included in the permutation-gain codebook allow for the modeling of a range of gain differences (and variations) between antennas. For cases with a larger range of gain differences between antennas one could consider designs with larger numbers of bits “b g ” for gain, though this may also necessitate larger B in order not to compromise on the phase accuracy. 
         [0090]    However, there are examples where gain-differences between antennas are partially due to factors that change more slowly than the rate at which CSI feedback updates are given by the receiver to the transmitter. These include distributed antenna and Coordinated Multi-Point (CoMP) scenarios where transmitting antennas are located at a number of different geographic locations. Thus, relatively static path loss differences between a receiver and different transmit antennas (or groups of antennas) can exist. 
         [0091]    For example, according to one or more embodiments of the present disclosure, antennas 1 and 2 are located much closer to a receiver than antennas 3 and 4. In such a case, the system could be extended to request, or infer from other information, a relatively static gain difference G diff , G diff &gt;0, that exists between antennas 1 and 2 and antennas 3 and 4 on average. 
         [0092]    This, for example, could be supported by separate path-loss measurements by the UE of each of the locations where the different pairs of antennas reside. Path-loss measurements at the UE can be carried out on separate CSI-RS (channel state information reference signals) configurations for antennas 1 and 2 and antennas 3 and4. The path-loss measurements can either be feedback by the receiver to the base station at a large duty cycle (100 msec order) or not feedback at all and be directly estimated by each of the distributed points based on uplink sounding reference signals (SRS) transmitted from the UE. A person of ordinary skill in the art will appreciate that alternative ways exists. 
         [0093]    According to one or more embodiments of the present disclosure, with the above discussed support, and the information “G diff ” being available both to the transmitter and the receiver, the permutation-gain codebook can be used to focus on and to describe, more efficiently, random fluctuations in the gain due to effects such as fast-fading. 
         [0094]    A process to do so is outlined in  FIG. 8 . Specifically, the process of  FIG. 8  includes modifications to the steps in  FIG. 7  to account for G diff . Specifically, Step  1 A is included which selects a gain vector after taking G diff  out of the determination of the gain vector. Also, Step  1 B creates a new gain vector g 2  defined by the selected gain vector and G diff . In Step  1 C, because the overall antenna gain is important in driving bit-allocation, the bit-allocation is driven by an integer value which is derived jointly from this gain difference and the gain-vector. Further, each integer value has a look up table which defines the bit allocation {p1, p2, p3} to be used. The remaining steps  3 ,  4 ,  5 , and  6  use the new vector g 2  defined by the selected gain vector and G diff . 
         [0095]    A codebook search which includes receiver processing into the metric 
         [0096]    In selecting a rank-1 or rank-2 description of the CS the receiver can take into account an estimate of the post-beamforming signal to noise ratio SNR it may experience in different frequency bands, and the rate supported by these SNRs. This, in fact, is the process suggested by LTE for use with the existing 4-bit codebooks. This procedure is well known to those familiar with the state of the art. 
         [0097]    According to one or more embodiments of the present disclosure, the receiver has measured the 4×2 CSI for T bands, indexed by t=1, 2, . . . , T. The CSI for band t is denoted as Q t  where Q t  is a complex 4×2 matrix. The quantized rank-1 CS value sent by the receiver to the transmitter is v as previously described. The receiver can then estimate a “channel quality” supported by using this v as a beamforming vector at the transmitter using the following calculation: 
         [0000]      Channel Quality using  v= 2 SNR(v)    
         [0098]    where 
         [0000]    
       
         
           
             
               SNR 
                
               
                 ( 
                 v 
                 ) 
               
             
             = 
             
               
                 1 
                 T 
               
                
               
                 
                   ∑ 
                   
                     t 
                     = 
                     1 
                   
                   T 
                 
                  
                 
                   
                     log 
                     2 
                   
                    
                   
                     ( 
                     
                       1 
                       + 
                       
                         
                            
                           
                             
                               Q 
                               t 
                               H 
                             
                              
                             v 
                           
                            
                         
                         2 
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0099]    A person of ordinary skill in the art will appreciate that, the structure of the codebook design can be used to search for good v with respect to this Channel Quality metric. To do so one can include the metric into each of the search steps in  FIG. 7  and  FIG. 8 , with some modifications to the specifics of the search mathematics. 
         [0100]    For example, one or more embodiments of the present disclosure is as follows, were gain determination includes changes in  FIG. 7 . Specifically, one would make the assumption that a single vector “v” can perfectly align all the phases in all the matrices Q t  , t=1, . . . ,T. This allows one to do the following calculation, similar to Step  1  in  FIG. 7  and  FIG. 8 . 
         [0000]    
       
         
           
             
               
                 Let 
                  
                 
                     
                 
                  
                 
                   Q 
                   t 
                 
               
               = 
               
                 [ 
                 
                   
                     
                       
                         q 
                         
                           t 
                           , 
                           1 
                           , 
                           1 
                         
                       
                     
                     
                       
                         q 
                         
                           t 
                           , 
                           1 
                           , 
                           2 
                         
                       
                     
                   
                   
                     
                       
                         q 
                         
                           t 
                           , 
                           2 
                           , 
                           1 
                         
                       
                     
                     
                       
                         q 
                         
                           t 
                           , 
                           2 
                           , 
                           2 
                         
                       
                     
                   
                   
                     
                       
                         q 
                         
                           t 
                           , 
                           3 
                           , 
                           1 
                         
                       
                     
                     
                       
                         q 
                         
                           t 
                           , 
                           3 
                           , 
                           2 
                         
                       
                     
                   
                   
                     
                       
                         q 
                         
                           t 
                           , 
                           4 
                           , 
                           1 
                         
                       
                     
                     
                       
                         q 
                         
                           t 
                           , 
                           4 
                           , 
                           2 
                         
                       
                     
                   
                 
                 ] 
               
             
              
             
                 
             
           
         
       
       
         
           
             
               and 
                
               
                   
               
                
               define 
                
               
                   
               
                
               
                 H 
                 t 
               
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               1 
                               , 
                               1 
                             
                           
                            
                         
                         + 
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               1 
                               , 
                               2 
                             
                           
                            
                         
                       
                     
                   
                   
                     
                       
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               2 
                               , 
                               1 
                             
                           
                            
                         
                         + 
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               2 
                               , 
                               2 
                             
                           
                            
                         
                       
                     
                   
                   
                     
                       
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               3 
                               , 
                               1 
                             
                           
                            
                         
                         + 
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               3 
                               , 
                               2 
                             
                           
                            
                         
                       
                     
                   
                   
                     
                       
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               4 
                               , 
                               1 
                             
                           
                            
                         
                         + 
                         
                            
                           
                             q 
                             
                               t 
                               , 
                               4 
                               , 
                               2 
                             
                           
                            
                         
                       
                     
                   
                 
                 ] 
               
               = 
               
                 
                   [ 
                   
                     
                       
                         
                           h 
                           
                             t 
                             , 
                             1 
                           
                         
                       
                     
                     
                       
                         
                           h 
                           
                             t 
                             , 
                             2 
                           
                         
                       
                     
                     
                       
                         
                           h 
                           
                             t 
                             , 
                             3 
                           
                         
                       
                     
                     
                       
                         
                           h 
                           
                             t 
                             , 
                             4 
                           
                         
                       
                     
                   
                   ] 
                 
                 ∈ 
                 
                   C 
                   
                     4 
                     × 
                     1 
                   
                 
               
             
           
         
       
     
         [0101]    For each gain vector g={g(1), g(2), g(3), g(4)} and associated permutation Φ={i(1),i(2), i(3), i(4)} calculate 
         [0000]    
       
         
           
             
               SNR 
                
               
                 ( 
                 
                   g 
                   , 
                   Φ 
                 
                 ) 
               
             
             = 
             
               
                 1 
                 T 
               
                
               
                 
                   ∑ 
                   
                     t 
                     = 
                     1 
                   
                   T 
                 
                  
                 
                   
                     log 
                     2 
                   
                   ( 
                   
                     1 
                     + 
                     
                       
                         ∑ 
                         
                           a 
                           = 
                           1 
                         
                         4 
                       
                        
                       
                         
                            
                           
                             
                               h 
                               
                                 t 
                                 , 
                                 a 
                               
                             
                              
                             
                               g 
                                
                               
                                 ( 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     a 
                                     ) 
                                   
                                 
                                 ) 
                               
                             
                           
                            
                         
                         2 
                       
                     
                   
                   ) 
                 
               
             
           
         
       
     
         [0102]    In contrast to searching over a single value “q”, the search may have to consider all combinations separately rather than using an ordering of antennas by gain. This new search has complexity that scales with 2̂{g b }. However, if the channels Q t  , t=1, . . . , T are very similar, i.e. show a strong degree of coherence, a search using an ordering of antennas by gain could be used. 
         [0103]    Intra-Subvector Phase Determination: Changes in  FIG. 7 . 
         [0104]    The determination of phase for one subvector has little influence on the determination of the phase of the other subvector. The optimal search may consider a joint search over both intra-subvector phases and inter-subvector phases. However, this may lead to negligible gains for sufficiently large p1, p2, and p3. Thus, intra-subvector phases can be searched independently. To search each intra-vector phase one need only take the case of the first sub-vector and the case of the second subvector follows naturally. 
         [0000]    
       
         
           
             
               Let 
                
               
                   
               
                
               
                 r 
                 
                   t 
                   , 
                   1 
                 
               
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 1 
                                 ) 
                               
                             
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                                 , 
                                 1 
                               
                             
                             + 
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                                 , 
                                 2 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 2 
                                 ) 
                               
                             
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     2 
                                     ) 
                                   
                                 
                                 , 
                                 1 
                               
                             
                             + 
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     2 
                                     ) 
                                   
                                 
                                 , 
                                 2 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
               ∈ 
               
                 C 
                 
                   2 
                   × 
                   1 
                 
               
             
           
         
       
     
         [0105]    Where the optimal permutation Φ={i(1), i(2), i(3), i(4)} 
         [0106]    and the optimal gain vector g={g(1), g(2), g(3), g(4)} 
         [0000]    
       
         
           
             
               n 
               * 
             
             = 
             
               arg 
                
               
                   
               
                
               
                 
                   max 
                   
                     
                       n 
                       = 
                       0 
                     
                     , 
                     1 
                     , 
                     … 
                     , 
                     
                       
                         P 
                         1 
                       
                       - 
                       1 
                     
                   
                 
                  
                 
                   
                     ∑ 
                     
                       t 
                       = 
                       1 
                     
                     T 
                   
                    
                   
                     
                       log 
                       2 
                     
                      
                     
                       ( 
                       
                         1 
                         + 
                         
                           
                              
                             
                               
                                 φ 
                                 
                                   1 
                                   , 
                                   n 
                                 
                                 H 
                               
                                
                               
                                 r 
                                 
                                   t 
                                   , 
                                   1 
                                 
                               
                             
                              
                           
                           2 
                         
                       
                       ) 
                     
                   
                 
               
             
           
         
       
     
         [0107]    The optimal index m* for the intra-subvector phase for the second subvector follows. 
         [0108]    Inter-Subvector Phase Determination: Changes in  FIG. 7 . 
         [0109]    The determination of phase for one subvector has little influence on the determination of the phase of the other subvector. The optimal search would consider a joint search over both intra-subvector phases and inter-subvector phases. However, this may lead to negligible gains for sufficiently large p1, p2, and p3. To search each intra-vector phase one need only take the case of the first sub-vector and the case of the second subvector follows naturally. 
         [0000]    
       
         
           
             
               Let 
                
               
                   
               
                
               
                 r 
                 
                   t 
                   , 
                   1 
                 
               
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 1 
                                 ) 
                               
                             
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                                 , 
                                 1 
                               
                             
                             + 
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                 
                                 , 
                                 2 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 2 
                                 ) 
                               
                             
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     2 
                                     ) 
                                   
                                 
                                 , 
                                 1 
                               
                             
                             + 
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     2 
                                     ) 
                                   
                                 
                                 , 
                                 2 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
               ∈ 
               
                 
                   C 
                   
                     2 
                     × 
                     1 
                   
                 
                  
                 
                     
                 
                  
                 and 
               
             
           
         
       
       
         
           
             
               r 
               
                 t 
                 , 
                 2 
               
             
             = 
             
               
                 [ 
                 
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 3 
                                 ) 
                               
                             
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     3 
                                     ) 
                                   
                                 
                                 , 
                                 1 
                               
                             
                             + 
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     3 
                                     ) 
                                   
                                 
                                 , 
                                 2 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             
                               i 
                                
                               
                                 ( 
                                 4 
                                 ) 
                               
                             
                             ) 
                           
                         
                          
                         
                           ( 
                           
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     4 
                                     ) 
                                   
                                 
                                 , 
                                 1 
                               
                             
                             + 
                             
                               q 
                               
                                 t 
                                 , 
                                 
                                   i 
                                    
                                   
                                     ( 
                                     4 
                                     ) 
                                   
                                 
                                 , 
                                 2 
                               
                             
                           
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
               ∈ 
               
                 C 
                 
                   2 
                   × 
                   1 
                 
               
             
           
         
       
     
         [0110]    Where the optimal permutation Φ={i(1), i(2), i(3), (4)} 
         [0111]    and the optimal gain vector g={g(1), g(2), g(3), g(4)} 
         [0112]    Let ρ t,1 =φ 1,n*   H r t,1  and ρ t,2 =φ 2,m*   H r t,2    
         [0113]    Then 
         [0000]    
       
         
           
             
               r 
               * 
             
             = 
             
               arg 
                
               
                   
               
                
               
                 
                   max 
                   
                     
                       r 
                       = 
                       0 
                     
                     , 
                     1 
                     , 
                     … 
                     , 
                     
                       
                         P 
                         3 
                       
                       - 
                       1 
                     
                   
                 
                  
                 
                   
                     ∑ 
                     
                       t 
                       = 
                       1 
                     
                     T 
                   
                    
                   
                     
                       log 
                       2 
                     
                      
                     
                       ( 
                       
                         1 
                         + 
                         
                           
                              
                             
                               
                                 ρ 
                                 1 
                               
                               + 
                               
                                 
                                   ω 
                                   r 
                                 
                                  
                                 
                                   ρ 
                                   2 
                                 
                               
                             
                              
                           
                           2 
                         
                       
                       ) 
                     
                   
                 
               
             
           
         
       
     
         [0114]    Extensions to Even Numbers of Antennas Greater Than 4. 
         [0115]    In the above description of operations, according to one or more embodiments of the present disclosure, the gain was jointly encoded over all dimensions. It is also possible to split the dimensions over which the joint encoding of gain is performed. This, in fact, becomes important for higher order MIMO (e.g., 8Tx) and CoMP transmission. 
         [0116]    Specifically, for the case of 8Tx for example, the gain joint encoding can be conducted over all the 8 dimension g=[g(1), g(2), g(3), g(4), g(5), g(6), g(7), g(8)] or over each 4-dimensional subvectors separately g1=[g(1), g(2), g(3), g(4)] and g2=[g(5), g(6), g(7), g(8)]. 
         [0000]    
       
         
           
             w 
             = 
             
               
                 [ 
                 
                   
                     
                       
                         w 
                          
                         
                           ( 
                           1 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           2 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           3 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           4 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           5 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           6 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           7 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           8 
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
               = 
               
                 [ 
                 
                   
                     
                       
                         [ 
                         
                           
                             
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         g 
                                          
                                         
                                           ( 
                                           1 
                                           ) 
                                         
                                       
                                     
                                   
                                   
                                     
                                       
                                         
                                           g 
                                            
                                           
                                             ( 
                                             2 
                                             ) 
                                           
                                         
                                          
                                         
                                            
                                           
                                             jθ 
                                             1 
                                           
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                           
                           
                             
                               
                                 
                                    
                                   
                                     jθ 
                                     3 
                                   
                                 
                                  
                                 
                                   [ 
                                   
                                     
                                       
                                         
                                           g 
                                            
                                           
                                             ( 
                                             3 
                                             ) 
                                           
                                         
                                       
                                     
                                     
                                       
                                         
                                           
                                             g 
                                              
                                             
                                               ( 
                                               4 
                                               ) 
                                             
                                           
                                            
                                           
                                              
                                             
                                               jθ 
                                               2 
                                             
                                           
                                         
                                       
                                     
                                   
                                   ] 
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                   
                     
                       
                         
                            
                           
                             jθ 
                              
                             
                                 
                             
                              
                             7 
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   [ 
                                   
                                     
                                       
                                         
                                           g 
                                            
                                           
                                             ( 
                                             5 
                                             ) 
                                           
                                         
                                       
                                     
                                     
                                       
                                         
                                           
                                             g 
                                              
                                             
                                               ( 
                                               6 
                                               ) 
                                             
                                           
                                            
                                           
                                              
                                             
                                               jθ 
                                               4 
                                             
                                           
                                         
                                       
                                     
                                   
                                   ] 
                                 
                               
                             
                             
                               
                                 
                                   
                                      
                                     
                                       jθ 
                                        
                                       
                                           
                                       
                                        
                                       6 
                                     
                                   
                                    
                                   
                                     [ 
                                     
                                       
                                         
                                           
                                             g 
                                              
                                             
                                               ( 
                                               7 
                                               ) 
                                             
                                           
                                         
                                       
                                       
                                         
                                           
                                             
                                               g 
                                                
                                               
                                                 ( 
                                                 8 
                                                 ) 
                                               
                                             
                                              
                                             
                                                
                                               
                                                 j 
                                                  
                                                 
                                                     
                                                 
                                                  
                                                 θ5 
                                               
                                             
                                           
                                         
                                       
                                     
                                     ] 
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                 
                 ] 
               
             
           
         
       
     
         [0117]    Extensions to other even numbers of antennas, e.g. 6 or 12 antennas, follows in a similar manner by building such quantizers out of smaller 2 or 4 dimensional quantizers and either quantizing the gain jointly or splitting the gain into sub-vectors (with their own individual permutations). 
         [0118]    Extension to Odd Number of Dimensions 
         [0119]    For the case of an odd number of dimensions, dimension splitting can be done as in the case of even number of dimensions but with one additional dimension remaining. For example, for the case of 5Tx transmission, the precoding vector is structured as below: 
         [0000]    
       
         
           
             w 
             = 
             
               
                 [ 
                 
                   
                     
                       
                         w 
                          
                         
                           ( 
                           1 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           2 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           3 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           4 
                           ) 
                         
                       
                     
                   
                   
                     
                       
                         w 
                          
                         
                           ( 
                           5 
                           ) 
                         
                       
                     
                   
                 
                 ] 
               
               = 
               
                 [ 
                 
                   
                     
                       
                         [ 
                         
                           
                             
                               
                                 g 
                                  
                                 
                                   ( 
                                   1 
                                   ) 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   g 
                                    
                                   
                                     ( 
                                     2 
                                     ) 
                                   
                                 
                                  
                                 
                                    
                                   
                                     jθ 
                                     1 
                                   
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                   
                     
                       
                         
                            
                           
                             jθ 
                             3 
                           
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   g 
                                    
                                   
                                     ( 
                                     3 
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 
                                   
                                     g 
                                      
                                     
                                       ( 
                                       4 
                                       ) 
                                     
                                   
                                    
                                   
                                      
                                     
                                       jθ 
                                       2 
                                     
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   
                     
                       
                         
                           g 
                            
                           
                             ( 
                             5 
                             ) 
                           
                         
                          
                         
                            
                           
                             jθ 
                             4 
                           
                         
                       
                     
                   
                 
                 ] 
               
             
           
         
       
     
         [0120]    One straightforward way to extend the codebook design to the case of odd number of transmit antennas, according to one or more embodiments of the present disclosure, is to feedback the phase information θ 9   4  of the remaining last dimension separately from the phase information of other dimensions, while the gain information can be still feedback by a joint encoding with the gain information of other dimensions (e.g., [g(1), g(2), g(3), g(4), g(5)]). 
         [0121]    The proposed design is scalable to different number of antenna configurations, both even and odd, and different split of dimensions. 
         [0122]    While the invention has been described with respect to a limited number of embodiments, those skilled in the art, having benefit of this disclosure, will appreciate that other embodiments can be devised which do not depart from the scope of the invention as disclosed herein. Accordingly, the scope of the invention should be limited only by the attached claims.