# Patent

## Title
Proportional-fair radio resource management

## Abstract

In one embodiment, the unit share data rates for a plurality of mobile stations are determined with regard to two resource groups. A differentiation factor for each mobile station is formed from a ratio of its unit share data rates. The resulting differentiation factors are sorted and classified into two groups according to a proportional fair border determining function. A first one of the resource groups is allocated to the mobile stations corresponding to a first one of the differentiation factor groups. Similarly, a second one of the resource groups is allocated to the mobile stations corresponding to a remaining second one of the differentiation factor groups.

## Background
RELATED APPLICATION
This application claims the benefit of U.S. Provisional Application No. 61/449,466, filed Mar. 4, 2011.


TECHNICAL FIELD
The present invention relates to wireless network resource management, and more particularly to a proportional-fair radio resource management technique.
BACKGROUND
Many challenging wireless network management issues arise with regard to the allocation of two available resource groups. For example, the component carrier (CC) assignment problem in a carrier aggregated network, the resource partition (RP) assignment problem in an interference coordinated network, and the handoff (or cell association) decision problem all typically involve the partitioning or allocation of two resource groups. The definition of a resource group depends upon the network circumstances—for example, a resource group may be a single component carrier (or a set of CCs) in the component carrier assignment problem, or a single resource partition (or a set of RPs) in the resource partition assignment problem, or the radio resource of a single cell in the handoff decision problem.
Regardless of the particular type of resource group being allocated, the allocation depends upon the goals of the network designer. For example, one can design a network so that system capacity is maximized. In that regard, suppose a high quality resource group is being allocated along with a low quality resource group. If there is single wireless terminal in a cell, a trivial solution to allocation is to let the wireless terminal use both resource groups. If there is more than one user, the problem is no longer trivial due to the conflict between system capacity and fairness. For example, the radio quality for a terminal in the cell core is likely better than that for a terminal in the cell edge. Assigning both the high and low quality resource group to the cell core terminal, therefore, maximizes the system capacity. But such a solution makes maximizes unfairness because the edge terminal is not provided with any resource. Conversely, the network designer may stress fairness over system capacity. In such a scenario, one could evenly distribute the high quality and low quality resource groups to all terminals in the cell. If the resource groups are component carriers, however, the power consumption caused by turning on multiple CCs should be avoided (especially for the battery-powered terminals) as much as possible. Moreover, channel feedback and scheduling overhead accompanied by multiple CCs (or RPs) grows as the number of wireless terminals increases. Thus, system capacity would be significantly degraded in a totally fair design.
One can thus readily appreciate that it is a non-trivial problem to balance the competing needs of system capacity and fairness simultaneously. Thus there is a need in the art for improved resource group allocation techniques.
SUMMARY
In one embodiment, radio resource management is differentiated by the radio quality difference of two resource groups. First, the unit share rate achievable with a unit share of each of resource groups is determined for each wireless terminal. Alternative rate definitions may also be used. Each terminal would thus have a first unit share rate corresponding to a first resource group and a second unit share rate corresponding to a second resource group. Here, each terminal is required to have an above-zero rate at least at one of the two resource groups (if the rates of a terminal are zero in both of the groups, it is simply excluded from the resource allocation). If there is only one terminal satisfying the requirement, a trivial solution is to allocate all the resource groups with above-zero rate to the single terminal. If there are at least two terminals satisfying the above requirement, then a differentiation factor is determined for each terminal by computing the ratio of the two rates, for example, by computing the ratio of the first unit share rate divided by the second unit share rate. Alternative expressions can be used as discussed further below but the resulting differentiation factors should be calculated in a fashion that addresses the relative sizes of each resource group. Defining the bit rates per unit share of the resource group as discussed further herein conveniently accounts for the relative sizes of the resource groups. If the differentiation factors of the terminals are all zero or all infinity, then all terminals have zero rate in one resource group and (finite) non-zero rates in the other resource group. A trivial solution for such case is to allocate the resource of the resource group with non-zero rate evenly to the terminals. On the other hand if there is at least one terminal with a finite, non-zero differentiation factor, then for each of such terminals, the resource shares of the terminal at the first resource group and the second resource group are determined based on the differentiation factors of the terminal and the other terminals. A terminal is considered as associated with a resource group if the resource share of the terminal at the resource group is above zero.
The resource shares of terminals may be determined by sorting the differentiation factors for the terminals in either a non-decreasing or non-increasing order. It there are N such terminals being sorted, the terminals may be indexed with regard to this ordering according to an index k that ranges from 1 to N. Alternatively, the terminals may be indexed from an integer a to form a sorted group a, a+1, . . . , a+N−1. This alternative indexing is advantageous with regard to implementing the sorting algorithm in software in that it saves memory space for the resulting arrays. The following discussion will first address the case in which the index ranges from 1 to N followed by a discussion of the index ranging from a to a+N−1. There will thus be a total of four proportional fair alternatives in that each index alternative may be solved using either an increasing or decreasing sorting of the differentiation factors as set forth below in Table 1. The first two alternatives concern the indexing from 1 to N and are denoted herein as “algorithm 1” and “algorithm 2.” Algorithm 1 addresses a descending sorting whereas algorithm 2 is directed to an ascending sorting of the differentiation factors. Algorithms 3 and 4 use an indexing from an integer a to an integer a+N−1. Algorithm 3 addresses a descending sorting whereas algorithm 4 is directed to an ascending order of the differentiation factors. It may be seen that algorithm 1 is just a special case of algorithm 3. Similarly, algorithm 2 is a special case of algorithm 4.









TABLE 1









Sorting of d(k)










Descending
Ascending














Indexing
k = 1, 2, . . . , N
Algorithm 1
Algorithm 2



k = a, a + 1, . . . , a + N − 1
Algorithm 3
Algorithm 4









In each algorithm, a border determining function may be applied to the sorted differentiation factors to determine a border terminal index (defined with regard to an integer K). Equivalently, an inverse border determining function may be applied to the sorting index as compared to differentiation factors to determine the border terminal index. With regard to the ith sorting index, the ith differentiation factor may be denoted as d(i) such that the border determining function of the ith differentiation factor may be denoted as G(d(i)). The terminals may then be allocated to one resource group or the other depending upon their relationship to the border terminal index. Advantageously, only the border terminal can be allocated to both resource groups, which simplifies implementation. Accordingly, up to one terminal (that is, the border terminal) may associate with both resource groups while the other terminals associate with only one of the two resource groups. The radio resource of a resource group is allocated only to the terminals associated with the resource group. The distribution of the terminal throughputs according to the above resource allocation can be proved to be proportional-fair, which is known to provide a good trade-off between the system capacity and fairness.
Because most of the terminals (i.e. all terminals except for up to one terminal) are associated with only one resource group, overhead involved in the association and allocation of the resource groups is significantly reduced as compared to conventional schemes where terminals are associated with and allocated from both resource groups. If the quality of one resource group is better than that of the remaining resource group for all wireless terminals, then the differentiation factors are either all above one or below one depending on how the ratio for the differentiation factors is computed. The present invention provides a proportional fair resource allocation for such a scenario. Thus, while a strategy that simply selects a high-quality resource group for all wireless terminals wastes the other resource group in that no wireless terminal is allocated to the low-quality resource group, the present invention provides more efficient resource allocation.
When association is of primary interest, it can be determined alternatively without determining the resource group shares. To do so, first the differentiation factors of all the terminals may be sorted in a monotonically decreasing order. The sorted differentiation factors are then tested to find which of the following conditions is satisfied.
1. If there is Kε{1, . . . , N−1} such that G(d(K+1))≦K≦G(d(K))
2. If there is Kε{1, . . . , N−2} such that K<G(d(K+1))<K+1
3. If for K=0, K<G(d(K+1))<K+1
4. If for K=N−1, K<G(d(K+1))<K+1
If the sorted differentiation factor distribution satisfies the condition 1, then the terminals having indices belonging to the set k=1, . . . , K are associated with the first resource group while the remaining terminals whose indices are k=K+1, . . . , N are associated with the second resource group. There is thus no wireless terminal allocated to both resource groups in the case of satisfied condition 1. If the sorted differentiation factor distribution satisfies condition 2, on the other hand, then the terminals whose indices belong to the set k=1, . . . , K, k=K+1, and k=K+2, . . . , N are respectively associated with the first resource group, with the first and the second resource groups, and the second resource group. If the sorted differentiation factor distribution satisfies condition 3, then the terminal whose index is k=1 is associated with the first and the second resource groups while the terminal whose index is k=2, . . . , N is associated with the second resource group. If the sorted differentiation factor distribution satisfies condition 4, then the terminals whose indices belong to the set k=1, . . . , N−1 is associated with the first resource group while the terminal whose index is k=N is associated with the first and the second resource groups.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 shows an example network having two resource groups for allocation.
FIG. 2 illustrates a time-based division of resource groups.
FIG. 3 illustrates a frequency-based division of resource groups.
FIG. 4 illustrates data rates for the network of FIG. 1 using the resource groups of FIG. 2.
FIG. 5 is a flowchart for a proportional fair resource group association and allocation algorithm.
FIG. 6 is a flowchart for the differentiation factor determination step of FIG. 5.
FIG. 7 is a flowchart for the proportional fair resource group share determination step of FIG. 5 if either/both resource groups provide a zero rate for all terminals or if there is only one terminal.
FIG. 8 is a flowchart for an embodiment of the proportional fair resource group share determination step of FIG. 5 if either/both of the resource groups provide a non-zero rate for plural terminals.
FIG. 9 is a flowchart for an alternative embodiment of the proportional fair resource group share determination step of FIG. 5 if either/both of the resource groups provide a non-zero rate for plural terminals.
FIG. 10 is a flowchart detailing the association of terminals with resource groups in an alternative embodiment when cases 1 or 3 are true.
FIG. 11 is a flowchart detailing the association of terminals with resource groups in an alternative embodiment when case 2 is true.
FIG. 12 illustrates the signal flow between a base station and a mobile station to enable the measurement of downlink data rates in conjunction with a proportional fair resource allocation.
FIG. 13 is a block diagram of the base station and mobile station of FIG. 12.



DETAILED DESCRIPTION
The present invention is applicable to a network in which two resource groups are allocated to one or more wireless terminals in a proportional fair manner. Turning now to the drawings, FIG. 1 illustrates an exemplary network, comprising a wireless terminal and three cells, two of which (C1 and C3) are high-power macrocells and the other one (C2) is a low power picocell.
The wireless service of each cell in FIG. 1 depends upon the particular wireless protocol. For example, in the 3GPP Long Term Evolution (LTE) protocol, the wireless service is provided by nodes such as eNB (evolved Node B), RRH (Remote Radio Head), MME (Mobility Management Entity), and S-GW (Serving GateWay). In the IEEE 802.16 WiMAX protocol, wireless service is provided by nodes such as a BS (Base Station), Relay, and ASN-GW (Access Service Network GateWay). The resource allocation disclosed herein is independent of the particular wireless protocol being implemented to service the cells.
Each cell is coupled with a radio resource that is to be allocated to the terminals within the cell. The nature of the radio resource depends upon the particular wireless protocol being implemented to service the cells. For example, in an network implementing carrier aggregation, the radio resource takes the form of a carrier having a certain bandwidth at a frequency or a set of carriers under a carrier aggregation scenario. A carrier in a carrier aggregation scenario is referred as component carrier (CC)).
Regardless of the particular form of the resource group being allocated, many challenging wireless network management problems concern the allocation of two resource groups. For example, in the carrier aggregation scenario having two component carriers, it is necessary to decide for each terminal whether to serve it with either of the two CCs or both. In such a carrier aggregation network, a single CC (or a set of CCs) comprises a resource group. Many factors may need to be considered when allocating component carriers, such as the number of terminals, diversity, power consumption, channel feedback overhead, and so on. If there is only one terminal in the cell, the terminal may be served with both CCs, to increase the peak throughput. However, if there are large number of terminals in the cell, the amount of service assigned to each terminal may be small enough that it can be accommodated by only a single CC. In such a case, a terminal may be served with a single CC in order to decrease the power consumption of the terminal along the associated channel feedback and scheduling overhead. Due to the loss of frequency diversity on the other CC, the terminal throughput may decrease, but it should not be significant if the carrier bandwidth is large enough. If it is decided that each terminal is to be served with only one CC or that the number of terminals served with both CCs is to be minimized to one, the present invention provides a number of ways of deciding with which CC or CCs serve each terminal so that the proportional fairness as a system objective is satisfied.
Note that the resource group of the present invention need not be the same as the physical resource unit. For example, if there are two CCs in the 2 GHz band and one CC in the 3.5 GHz band, the two CCs in the 2 GHz band may be grouped together and form one resource group while the CC in the 3 GHz band may form the other resource group by itself. Thus, the size of the two resource groups may or may not be the same. Conversely, a large radio resource may be split into two smaller resource groups. For example, a CC may be split into two sets of resource partitions (RPs) in the frequency domain, in the time domain, or any other means, where each RP comprises one resource group. In such a case, the resource partition (RP) assignment problem may be also modeled as the radio resource management problem with two resource groups as discussed further herein.
FIG. 2 shows an example of time domain resource partition. In this example, the radio resource is slotted into subframes in the time domain and then indexed according to two resource partitions: RP1, which corresponds to the odd subframes and RP2, which corresponds to the even subframes. On the other hand, FIG. 3 shows an example of frequency domain resource partition. In this particular example, there are two resource partitions: RP1, which is the one in the higher frequency portion of the CC and RP2, which is the other one in the lower frequency portion of the CC.
The handoff (or cell association) decision problem can be regarded as yet another example of radio resource management with two resource groups. Here, a resource group is the radio resource of a single cell in the handoff decision problem, and the present invention provides a number of ways of deciding with which cell to serve the terminal so that the proportional fairness as a system objective is to be satisfied. The present invention applies to the above and other radio resource management problems with regard to the allocation of two radio resource groups. Moreover, any resource can be grouped or split to form the two radio resource groups. For the sake of simplicity, the present invention is explained hereinafter, with reference to a generic resource group only, and the specifics of the resource groups is no longer discussed.
The quality of two resource groups may be different due to a number of reasons related to the specifics of the radio environment of the groups. For example, interference coordination is often used to reduce the performance degradation due to inter-cell interference. Such interference coordination is typically performed using different resource groups or, if they use the same resource group, they use it with different transmit power. As a result, the link quality perceived by a wireless terminal can be different depending on the resource group in which it is served and on the specifics of the interference coordination rule that applies to the resource group.
In the example of FIG. 2, macrocells such as C1 and C3 of FIG. 1 do not transmit in odd-indexed subframes (RP1), to reduce the interference from macrocells to picocells, while at even-indexed subframes (RP2) both macrocells C1 and C3 as well as picocell C2 transmit. Similar coordination can be done with the resource groups comprising frequency-domain resource partitions as in FIG. 3 or the multiple CCs in a carrier-aggregated scenario. For example, in FIG. 3, macrocells such as C1 and C3 of FIG. 1 use frequency band A only. However, a picocell such as picocell C2 uses both frequency band A and also frequency band B.
FIG. 4 illustrates the radio quality due to the interference coordination of FIG. 2. The path loss and the transmission power difference between the macrocells and the picocell are considered but for illustration clarity the impact of shadowing and small scale fading are ignored. It should be noted, however, that the scope of the present invention is applicable with or without shadowing and/or small scale fading. In the example of FIG. 2, the first resource group represents the odd-indexed sub-frames whereas the even-indexed sub-frames represents the second resource group. Here rm,n(i) represents the rate for a terminal i using resource group n in a cell m. Thus, r1,2(i) represents the rate for an ith terminal as served by macrocell C1 using the second resource group. Similarly, r2,2(i) represents the rate for an ith terminal as served by picocell C2 using the second resource group. Conversely, r2,1(i) represents the rate for an ith terminal as served by picocell C2 using the first resource group. The rates vary depending upon the distance between a terminal and the serving cell. For example, rate r1,2(i) is of course strongest in the vicinity of macrocell C1 and then drops toward zero as the terminal ranges from macrocell C1 toward cells C2 and C3. Since the first resource group is not used by the macrocells, the rate achievable from the odd-indexed subframes r2,1(i) is clearly higher than that from the even-indexed subframes r2,2(i). In this scenario, picocell C2 needs to decide how to allocate the resource groups. In that regard, a simple solution would be to assign each wireless terminal to the second resource group since it offers a higher data rate to each terminal than that achievable with the first resource group. Such a solution wastes the resources of the first resource group. Note that in the vicinity of the C2 base station of FIG. 2, the rate achievable with the first resource group is reasonably close to that achievable with the second resource group. A compromise that achieves a proportional fairness would thus be to assign those terminals with the smaller difference in rate between the two resource groups to the first resource group while assigning all remaining to terminals to the second resource group. Such a proportional fairness solution will be discussed further herein. The following discussion provides a rigorous mathematical proof for the proportional fairness of algorithm 1 with regard to Table 1 above. The remaining algorithms will be merely summarized as the required mathematics is analogous.
Proportional Fairness
In general, a throughput distribution for N terminals, {x(i), i=1, 2, . . . , N}, is proportional fair (PF) if it maximizes the following objective function:




  
    
      
        f
        =
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            log
            ⁡
            
              (
              
                x
                ⁡
                
                  (
                  i
                  )
                
              
              )
            
          
        
      
    
    
      
        (
        1
        )
      
    
  




where

x(i)=r1(i)·b1(i)+r2(i)·b2(i)  (2)

and r1(i) is the unit share rate achievable by terminal i from a unit share of the first resource group resource, r2(i) is the unit share rate achievable by terminal i from a unit share of the second resource group resource, and b1(i) and b2(i) are the respective shares of the first and second resource group resource allocated to terminal i. By definition,





  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
              b
              1
            
            ⁡
            
              (
              i
              )
            
          
        
        ≤
        1
      
    
    
      
        (
        3
        )
      
    
  
  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
              b
              2
            
            ⁡
            
              (
              i
              )
            
          
        
        ≤
        1
      
    
    
      
        (
        4
        )
      
    
  
  
    
      
        
          
            b
            1
          
          ⁡
          
            (
            i
            )
          
        
        ≥
        0
      
    
    
      
        (
        5
        )
      
    
  
  
    
      
        
          
            b
            2
          
          ⁡
          
            (
            i
            )
          
        
        ≥
        0
      
    
    
      
        (
        6
        )
      
    
  
  
    
      
        
          
            r
            1
          
          ⁡
          
            (
            i
            )
          
        
        ≥
        0
      
    
    
      
        (
        7
        )
      
    
  
  
    
      
        
          
            r
            2
          
          ⁡
          
            (
            i
            )
          
        
        ≥
        0
      
    
    
      
        (
        8
        )
      
    
  




The equality in equations (3) and (4) holds when resource groups 1 and 2 are fully utilized by the terminals. The inequality in equations (3) and (4) holds when there is any unassigned resource.

If r1(i)=r2(i)=0 and x(i)=0, the objective function (1) goes to negative infinity and is thus plainly not maximized. Furthermore, there is no need to allocate any radio resource to such a terminal for radio efficiency purposes. Hence, a terminal having no achievable rate using either resource group is not considered under the resource group allocations disclosed herein. A zero-rate terminal may have to wait without being scheduled until its radio quality is improved in at least one of the resource groups. Or, the terminal may be handed off to another cell with better radio quality so as to be scheduled from that cell. Accordingly, without loss of generality, the proportional fair allocation techniques disclosed herein assume (unless stated otherwise) that at least one of the rates in the two resource groups of each wireless terminal is greater than zero. That is, for all i=1, . . . , N

r1(i)>0 and r2(i)=0, r1(i)=0 and r2(i)>0, or r1(i)>0 and r2(i)>0,  (9)

The disclosed allocation algorithms concern the case of N≧2, since for N=1 there exists a trivial solution, which allocates all resource of both resource groups to the single terminal. Hereinafter it is thus assumed that N≧2.
The throughput x(i) can be formulated in many ways. For example, if B1 and B2 denote the respective sizes of the first and the second resource groups, and {tilde over (b)}1(i) and {tilde over (b)}2(i) denote the respective amount of the first and second resource group resource allocated to terminal i, then

{tilde over (b)}1(i)=B1·b1(i)  (10)

{tilde over (b)}2(i)=B2·b2(i)  (11)

Also denote, as {tilde over (r)}1(i) and {tilde over (r)}2(i), the respective rates achievable by terminal i from the unit amount of the first resource group resource and the unit amount of the second resource group resource. Then





  
    
      
        
          
            
              r
              ~
            
            1
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          
            
              r
              1
            
            ⁡
            
              (
              i
              )
            
          
          
            B
            1
          
        
      
    
    
      
        (
        12
        )
      
    
  
  
    
      
        
          
            
              r
              ~
            
            2
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          
            
              r
              2
            
            ⁡
            
              (
              i
              )
            
          
          
            B
            2
          
        
      
    
    
      
        (
        13
        )
      
    
  
  
    
      
        
          x
          ⁡
          
            (
            i
            )
          
        
        =
        
          
            
              
                
                  r
                  ~
                
                1
              
              ⁡
              
                (
                i
                )
              
            
            ·
            
              
                
                  b
                  ~
                
                1
              
              ⁡
              
                (
                i
                )
              
            
          
          +
          
            
              
                
                  r
                  ~
                
                2
              
              ⁡
              
                (
                i
                )
              
            
            ·
            
              
                
                  b
                  ~
                
                2
              
              ⁡
              
                (
                i
                )
              
            
          
        
      
    
    
      
        (
        14
        )
      
    
  




Hereinafter, we use the throughput description of equation (2). However the present invention can be easily modified to use the throughput description of equation (14). Regardless of how the throughputs are described, it can be seen that the resulting expression for the unit share rates takes into account the respective sizes of the two resource groups. And because the differentiation factor discussed further below is derived from the unit share rates, the differentiation factor also takes into account the respective sizes of the two resource groups. This is quite advantageous in that different-sized resource groups are not uncommon yet existing techniques for allocating resource groups cannot accommodate such variations.

FIG. 5 illustrates a flow chart of determining the proportional fair resource allocation when there are two resource groups. An initial act 500 of determining the differentiation factor D(i) for each terminal may be performed as follows:
Differentiation Factors
Step 500 of FIG. 5 is further detailed in the flowchart of FIG. 6. A first step 600 is to determine r1(i), the unit share rate achievable from a unit share of the first resource group resource, and r2(i), the unit share rate achievable from a unit share of the second resource group resource. The unit share rate can be an instantaneous rate as seen in a particular instance of time or frequency domain resource unit (within a resource group), or an average rate that is averaged over a large time or frequency span (again within a resource group). The unit share rates depend not only on the radio quality of the resource groups but also upon their respective sizes as is apparent from equations (12) and (13).
For example, if the resource groups are time-domain resource partitions as in FIG. 2, the unit share rate may represent what is instantaneously achievable at specific subframes. In other words, r1(i) and r2(i) may represent the unit share rate achievable at a subframe 2n+1 and that at a subframe 2n+2, respectively. On the other hand, the unit share rate may represent what is obtained through averaging over a number of subframes. For example, with respect to subframes 2n+1 and 2n+2, r1(i) and r2(i) may respectively represent the unit share rate averaged over the last 100 odd subframes and that averaged over the last 100 even subframes. In this fashion, a fast fading radio channel can be either closely tracked or averaged out. Similarly, a channel with frequency selective fading can be either closely tracked or averaged out by the frequency component within a resource group.
The proportional fair resource allocation of the present invention may be applied in any of the unit share rate definitions discussed above. The association and the allocation to be explained later may be executed in line with the time and frequency span of the unit share rate definition. For example, when the unit share rate is instantaneous, the association and the resource allocation of terminals are enforced so that they comply with the association and the resource allocation of the present invention at each instance. If the unit share rate is averaged, the association and the resource allocation of terminals are enforced so that they comply with the association and the resource allocation of the present invention in an average sense.
The differentiation factor determination 500 continues by determining for the ith terminal if both r1(i) and r2(i) equal zero in a step 605. If so, the resulting zero-rate terminal is removed from consideration. The zero-rate terminal may have to wait without being scheduled until its radio quality is improved in at least one of the resource groups. Or, the terminal may be handed off to another cell with better radio quality so as to be scheduled from the new cell. Because both r1(i) and r2(i) equaling zero will thus be ruled out, in other words, because at least one of the unit share rates is greater than zero, the differentiation factor of a terminal can be defined as the ratio of the two rates in a step 610, for example,




  
    
      
        
          D
          ⁡
          
            (
            i
            )
          
        
        =
        
          
            
              r
              1
            
            ⁡
            
              (
              i
              )
            
          
          
            
              r
              2
            
            ⁡
            
              (
              i
              )
            
          
        
      
    
    
      
        (
        15
        )
      
    
  




If the unit share rate r2(i)=0, then the differentiation factor D(i) goes to (positive) infinity. If the differentiation factor goes to infinity for all terminals, then the trivial solution is to evenly allocate the resource of the second resource group to all terminals (as shown further below with regard to Lemma 2). If the differentiation factor of only some of the terminals goes to infinity, on the other hand, the resource allocation scheme according to the present invention provides non-trivial solutions by appropriately handling those terminals with infinite factor value at the sorting process as discussed further herein. Having thus completed step 500 of FIG. 5, the proportional fair resource allocation continues in a step 505, which concerns the determination of the first and second resource group shares (that is, b1(i) and b2(i)).

As discussed above, the proportional fair resource allocation disclosed herein may be organized into four different algorithms of Table 1. The following discussion will focus on algorithm 1. Algorithms 2 through 4 may then be discussed more briefly in that these algorithms are performed analogously as discussed with regard to algorithm 1.
Proportional Fair Resource Allocation
Step 505 is further explained with reference to the flowchart of FIG. 7. If the differentiation factors of the terminals are either all zero or all infinity, then the proportional fair resource allocation is quite straightforward from Lemma 2. In a step 700, the unit share rates for the first resource groups are examined to see if they are all zero, in other words, r1(i)=0 for all i=1, 2, . . . , N. If so, then the second resource group share b2(i) is set to 1/N in a step 705 as discussed further with regard to Lemma 2. In conjunction, b1(i) can take any value as long as equations (3) and (5) are satisfied. In a step 710, the second resource group rates are examined to determine if they equal zero for all terminals (indicating that the differentiation factors of the terminals are all infinity). In other words, step 710 determines if r2(i)=0 for all i=1, 2, . . . , N. Should step 710 determine that the differentiation factors are all infinity, then again by Lemma 2, the first resource group share b1(i) for the terminal may be set to 1/N in a step 715. In that case, b2(i) can take any values as long as equations (4) and (6) are satisfied. After these steps, there should be at least one terminal with above-zero, finite rate in each of the resource groups. If there is just one such terminal as determined in a step 720, then it should have an above-zero, finite rate in both resource groups. And the proportional fair resource allocation for such a case is to allocate the resource of both resource groups to the single terminal as performed in a step 725.
If step 725 determines that there are two or more such terminals, on the other hand, the proportional fair resource allocation with two resource groups may be obtained according to the procedures of FIG. 8 or FIG. 9. These figures concern alternative embodiments for algorithm 1 of Table 1 discussed above. A first step 800 in both procedures is thus to sort the differentiation factors in a monotonically decreasing order. The terminals with infinite differentiation factors are located at the beginning of the list. The sorted differentiation factors may be denoted as d(k), (k=1, 2, . . . , N), the index of the sorted differentiation factors as k, and the index of the unsorted differentiation factors as i.
Then

d(1)≧d(2)≧ . . . ≧d(N)  (16)

∀k, ∃i such that k=Π(i)  (17)

where Π(i) is a permutation function that re-indexes the terminals according to the sorting. Hereinafter, i shall denote the terminal index before differentiation factor sorting whereas k denotes the terminal index after sorting.

A next step 805 in the procedures of FIGS. 8 and 9 is to determine an index of a terminal Kε{0, 1, . . . , N−1} in the sorted differentiation factor list, such that

G(d(K+1))−K<G(d(K))  (18)

where





  
    G
    ⁡
    
      (
      x
      )
    
  
  =
  
    
      
        N
        ·
        x
      
      
        1
        +
        x
      
    
    .
  




An alternative to step 805 is discussed below with regard to FIGS. 10 and 11. With regard to step 805, the proportional fair resource allocation with two resource groups can be determined in a step 810 of FIG. 8 as:





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      λ
                      1
                    
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  1
                
                ,
                ...
                ⁢
                
                  
                
                ,
                K
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      a
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    
                      λ
                      1
                    
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      -
                      
                        a
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                    
                      λ
                      2
                    
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  k
                
                =
                
                  K
                  +
                  1
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      λ
                      
                        2
                        ⁢
                        
                          
                        
                      
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    K
                    +
                    2
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        19
        )
      
    
  




where

λ1=max(G(d(K+1)),K)  (20)

λ2=N−λ1  (21)

α(K+1)=max(G(d(K+1))−K,0)  (22)

Alternatively, the proportional fair resource group allocation can be determined in a step 910 of FIG. 9 as:





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    λ
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  1
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  ⌊
                  λ
                  ⌋
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      λ
                      -
                      
                        ⌊
                        λ
                        ⌋
                      
                    
                    λ
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      +
                      
                        ⌊
                        λ
                        ⌋
                      
                      -
                      λ
                    
                    
                      N
                      -
                      λ
                    
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  k
                
                =
                
                  
                    ⌊
                    λ
                    ⌋
                  
                  +
                  1
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      N
                      -
                      λ
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    
                      ⌊
                      λ
                      ⌋
                    
                    +
                    2
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        23
        )
      
    
  




where └x┘ is a flooring function, which returns the largest integer no greater than x, and

λ=max(G(d(K+1)),K)  (24)

Here, b1(k) and b2(k) are the resource shares at the first and the second resource groups of the kth terminal in the sorted differentiation factor list. These are different, in terms of the terminal indexing, from b1(i) and b2(i), the resource shares at the first and the second resource groups of the terminal in the unsorted differentiation factor list. It is straightforward to convert between those two by equation (17). Therefore, at steps 810 and 910, the resource shares of each terminal in the first and the second resource groups are determined by either equations (19) through (22) or equations (23) and (24), respectively. It will be appreciated that the alternative procedures of FIGS. 8 and 9 produce the exactly the same resource allocation.

Referring back to FIG. 5, the resource group shares determined with regard to the procedures of FIG. 8 or 9 are used in a step 505 to determine the resource shares of each terminal in the first and the second resource groups with reference to the terminal index in the sorted list or the terminal index in the unsorted list (through a re-indexing of terminals by equation (17)). Then, at a next step 510, based on the resource shares of each terminal in the first and the second resource groups, each terminal is associated with the resource groups. To be more specific, each terminal is associated with the first resource group if the first resource group share for the terminal is above zero. Similarly, each terminal is associated with the second resource group if the second resource group share for the terminal is above zero. If associated with a resource group, a terminal may be allocated with the resource of the resource group at the allocation step as discussed further with regard to a step 515 of FIG. 5.
Association may require additional procedures. For example, if a resource group comprises a CC or CCs in a carrier aggregation scenario, a terminal may need to activate the CC or CCs to be associated with the resource group. As another example, in a resource partition assignment problem, association of a terminal with a resource group may involve a configuration of measurement, reporting, and scheduling of the terminal to be performed on the resource partition constituting the associated resource group. Finally, in a handoff scenario, association of a terminal with a resource group may involve a handoff to another cell, unless the associated resource group is the resource of the current cell.
Referring again to FIG. 5, at step 515, based on the resource shares of each terminal in the first and the second resource groups, each terminal is allocated with the resource group(s) accordingly. To be more specific, the resource group share allocated to each terminal is determined by b1(k) and b2(k) as discussed above. In that regard, a terminal is allocated with a resource group only if the terminal is already associated with the resource group. It should be noted, however, the present invention is agnostic to the specific ways of enforcing the resource shares in the allocation. For example, two weighted round robin schedulers in charge of allocating the resource of one of the two resource groups can be used together with the present invention by setting the weight of each terminal according to the resource shares.
The resource shares of terminals may be enforced in instantaneous sense or in an average manner. For example, in a time-domain resource partition embodiment as in FIG. 2, the resource of subframes 2n+1 and 2n+2 can be divided into smaller units and then allocated to the terminals so that the shares of the resource allocated to terminals correspond to b1(k) and b2(k), respectively. In that case, the allocation of the subframe occurs on an instantaneous basis. Alternatively, the shares of the resource allocated to terminals can be made to correspond to b1(k) and b2(k), in a larger time and frequency span (e.g. for the last one hundred odd subframes and 100 even subframes), although at the specific subframes 2n+1 and 2n+2, the resource allocation may diverge from b1(k) and b2(k). One example of such alternative with average compliance is to allocate the large chunk of resource within a resource group one (two) to a terminal with the allocation probability of b1(k) (b2(k)) at each subframes. Although not guaranteed in each subframe, the compliance is achieved in the long term due to the law of large numbers by repeating such probabilistic allocation for a long enough period of time.
Depending on the scenario, it may not be appropriate (in terms of complexity and battery consumption, for example) to compute the resource shares when determining the association. In such case, the association can be determined without computing the resource shares as in steps 810 and 910 of FIGS. 8 and 9, respectively. As an alternative to step 805, the index of terminal k (in the sorted differentiation factor list) can be determined in a number of steps with regard to three classifications of the sorted differentiation factors, which are designated herein as cases 1 through 3. Case 1 corresponds to the existence of an index k such that G−1(k) equals d(k). Otherwise, either case 2 or case 3 is true. In case 2, there is a k such that G−1(k)<d(k+1), G−1(k+1)>d(k+1), and G−1(k)<d(k). In case 3, there is a k such that G−1(k)<d(k), G−1(k+1)>d(k+1), and G−1(k)≧d(k+1). The derivation of these cases is discussed further below.
Given these 3 cases, the index k can be determined and the terminals associated accordingly as follows. Referring now to FIG. 10, it is first tested in a step 1000 if there exists Kε{1, . . . , N−1} such that G(d(K+1))≦K≦G(d(K)). If so, the resource allocation corresponds to case 1 or case 3. In particular, as shown below in equations (106) and (152), the resource share of a terminal is above zero for the first resource group if the terminal's sorted index k belongs to the set k=1, . . . , K; and the resource share of a terminal for the second resource group is above zero if its sorted index k belongs to the set k=K+1, . . . , N. So at a subsequent step 1005 in FIG. 10, a terminal is associated with the allocated resource group accordingly. If the result of the determination in step 1000 is false, then it corresponds to case 2 as discussed further below, and the procedure of FIG. 11 follows.
Referring to FIG. 11, because it corresponds to case 2, the resource share of a terminal can be determined by equation (130) discussed below. In an initial step 1100, the sorted index of a terminal K such that K<G(d(K+1))<K+1 is determined. Then it is tested if K=0 at a step 1105. If so, there is no terminal that is allocated with the first resource group only according to a step 1110. More specifically, b1(k)=1,




  
    
      b
      2
    
    ⁡
    
      (
      k
      )
    
  
  =
  
    
      1
      -
      
        G
        ⁡
        
          (
          
            d
            ⁡
            
              (
              1
              )
            
          
          )
        
      
    
    
      N
      -
      
        G
        ⁡
        
          (
          
            d
            ⁡
            
              (
              1
              )
            
          
          )
        
      
    
  




if k=1 and b1(k)=0,





  
    
      b
      2
    
    ⁡
    
      (
      k
      )
    
  
  =
  
    1
    
      N
      -
      
        G
        ⁡
        
          (
          
            d
            ⁡
            
              (
              1
              )
            
          
          )
        
      
    
  




for k=2, . . . , N.

Therefore, if a terminal's index k=1, then the terminal is associated with both the first and the second resource groups; and a terminal is associated with the second resource group if its index k=2, . . . , N.

If the result of test 1105 is false, on the other hand, it is tested in a step 1115 if Kε{1, . . . , N−2}. Then as shown below in equation (130), the resource share of a terminal is above zero in a step 1120 for the first resource group if the terminal's index k=1, . . . , K+1; and the resource share of a terminal for the second resource group is above zero if its index k=K+1, . . . , N. A terminal having sorted index k equaling K+1 is associated with both resource groups. If the result of test 1115 is false again, then a step 1125 tests whether k=N−1. In that case, there is no terminal that is allocated with the second resource group only in a step 1130. More specifically,




  
    
      
        b
        1
      
      ⁡
      
        (
        k
        )
      
    
    =
    
      1
      
        G
        ⁡
        
          (
          
            d
            ⁡
            
              (
              N
              )
            
          
          )
        
      
    
  
  ,




b2(k)=0 if k=1, . . . , N−1 and





  
    
      
        b
        1
      
      ⁡
      
        (
        k
        )
      
    
    =
    
      
        
          G
          ⁡
          
            (
            
              d
              ⁡
              
                (
                N
                )
              
            
            )
          
        
        -
        N
        +
        1
      
      
        G
        ⁡
        
          (
          
            d
            ⁡
            
              (
              N
              )
            
          
          )
        
      
    
  
  ,




b2(k)=1 for k=N. Therefore, if a terminal's index belongs to the set k=1, . . . , N−1 then the terminal is associated with the first resource group; and a terminal is associated with the first and the second resource groups if its index satisfies k=N.

The derivation of cases 1 through 3 for the proportional fair allocations schemes will now be discussed.
Mathematical Derivation for Algorithm 1 with Respect to Cases 1 Through 3.
The derivation of the PF schemes uses the Kuhn-Tucker condition as follows. Since the objective function of equation (1) is strictly concave and the feasible region defined by equations (3) through (6) is compact, the optimal solution to the maximization problem exists. Let




  L
  =
  
    f
    -
    
      
        ∑
        
          n
          =
          1
        
        2
      
      ⁢
      
        
      
      ⁢
      
        
          λ
          n
        
        ·
        
          
            (
            
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  N
                
                ⁢
                
                  
                
                ⁢
                
                  
                    b
                    n
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
              -
              1
            
            )
          
          .
        
      
    
  




The Kuhn-Tucker condition for the maximization problem of equation (1) is:

for all i=1, . . . , N and for all n=1, 2





  
    
      
        
          
            d
            L
          
          
            d
            
              
                b
                n
              
              ⁡
              
                (
                i
                )
              
            
          
        
        =
        
          
            
              
                d
                f
              
              
                d
                
                  
                    b
                    n
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
            -
            
              λ
              n
            
          
          =
          
            
              
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
                
                  x
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
              -
              
                λ
                n
              
            
            ≤
            0
          
        
      
    
    
      
        (
        25
        )
      
    
  
  
    
      
        
          
            b
            n
          
          ⁡
          
            (
            i
            )
          
        
        ≥
        0
      
    
    
      
        (
        26
        )
      
    
  
  
    
      
        
          
            
              b
              n
            
            ⁡
            
              (
              i
              )
            
          
          ·
          
            
              d
              L
            
            
              d
              
                
                  b
                  n
                
                ⁡
                
                  (
                  i
                  )
                
              
            
          
        
        =
        
          
            
              
                b
                n
              
              ⁡
              
                (
                i
                )
              
            
            ·
            
              (
              
                
                  
                    
                      r
                      n
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  
                    x
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
                -
                
                  λ
                  n
                
              
              )
            
          
          =
          0
        
      
    
    
      
        (
        27
        )
      
    
  




and for all n=1, 2





  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
          
          ⁢
          
            
              b
              n
            
            ⁡
            
              (
              i
              )
            
          
        
        ≤
        1
      
    
    
      
        (
        28
        )
      
    
  
  
    
      
        
          λ
          n
        
        ≥
        0
      
    
    
      
        (
        29
        )
      
    
  
  
    
      
        
          
            λ
            n
          
          ·
          
            (
            
              1
              -
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  N
                
                ⁢
                
                  
                
                ⁢
                
                  
                    b
                    n
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
            )
          
        
        =
        0
      
    
    
      
        (
        30
        )
      
    
  




where N(≧2) represents the number of terminals, i=1, . . . , N represent the unsorted terminal index and n=1, 2 represent the resource group number.

If the throughput x(i) equals zero, the objective function of equation (1) goes to negative infinity and clearly is not maximized. Thus, for all i=1, . . . , N

x(i)>0  (31)

The derivation of cases 1 through 3 requires the following lemmas.

Lemma 1

If there is iε{1, . . . , N} and nε{1, 2} such that rn(i)>0, then for such n




  
    
      
        
          λ
          n
        
        >
        0
      
    
    
      
        (
        32
        )
      
    
  
  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
          
          ⁢
          
            
              b
              n
            
            ⁡
            
              (
              i
              )
            
          
        
        =
        1
      
    
    
      
        (
        33
        )
      
    
  




A proof of lemma 1 begins by letting rn(i)>0 for i=î and n={circumflex over (n)}. Then from equation (25)





  
    
      
        
          λ
          
            n
            ^
          
        
        ≥
        
          
            
              r
              
                n
                ^
              
            
            ⁡
            
              (
              
                i
                ^
              
              )
            
          
          
            x
            ⁡
            
              (
              
                i
                ^
              
              )
            
          
        
      
    
    
      
        (
        34
        )
      
    
  




Then from equation (31) and the assumption of the lemma,





  
    
      
        
          λ
          
            n
            ^
          
        
        ≥
        
          
            
              r
              
                n
                ^
              
            
            ⁡
            
              (
              
                i
                ^
              
              )
            
          
          
            x
            ⁡
            
              (
              
                i
                ^
              
              )
            
          
        
        >
        0
      
    
    
      
        (
        35
        )
      
    
  




which proves equation (32). Now plugging equation (32) into equation (30) proves equation (33).

Lemma 2

If rn(1)= . . . =rn(N)=0 for n=n0ε{1, 2}, then the solution to the maximization problem of equations (1) through (8) is as follows:
If n=n0, then bn(i), i=1, . . . , N take any values that satisfies equations (26) and (28).
If n≠n0, then for all i=1, . . . , N,




  
    
      
        
          
            b
            n
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          1
          N
        
      
    
    
      
        (
        36
        )
      
    
  




As a proof of lemma 2, it is first assumed that n=n0. Since rn0(1)= . . . =rn0(N)=0, and x(i)>0 (due to equation (31)), equation (47) below can be expressed by

∀i=1, . . . ,N, bn0(i)·λn0=0  (37)

By equation (37), λn0=0 or bn0(1)= . . . =b (N)=0. Assume the former is true. Then equations (46), (47), (29), and (30) are satisfied. So it is sufficient for bn0(i), i=1, . . . , N to satisfy equations (26) and 28). Now assume the latter is true. Then by equation (30), λn0=0. Also bn0(1)= . . . =bn0(N)=0 satisfy equations (26) and (28). Under either case, only equations (26) and (28) need to be satisfied. So the lemma is proven for n=n0.

Now it is assumed that n≠n0. For brevity, the following discussion will refer to equations simply using their numbers in parentheticals. By (9),

∀i=1, . . . ,N, rn≠n0(i)>0  (38)

Then by Lemma 1





  
    
      
        
          λ
          
            n
            ≠
            
              n
              0
            
          
        
        >
        0
      
    
    
      
        (
        39
        )
      
    
  
  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
          
          ⁢
          
            
              b
              
                n
                ≠
                
                  n
                  0
                
              
            
            ⁡
            
              (
              i
              )
            
          
        
        =
        1
      
    
    
      
        (
        40
        )
      
    
  




On the other hand, from (2)

x(i)=rn0(i)·bn0(i)+rn≠n0(i)·bn≠n0(i)=rn≠n0(i)·bn≠n0(i)  (41)

From (31),

∀i=1, . . . ,N, bn≠n0(i)>0  (42)

Then by (42) and (27)





  
    
      
        
          
            
              
                r
                
                  n
                  ≠
                  
                    n
                    0
                  
                
              
              ⁡
              
                (
                i
                )
              
            
            
              x
              ⁡
              
                (
                i
                )
              
            
          
          -
          
            λ
            
              n
              ≠
              
                n
                0
              
            
          
        
        =
        0
      
    
    
      
        (
        43
        )
      
    
  




From (41) and (43),





  
    
      
        
          
            b
            
              n
              ≠
              
                n
                0
              
            
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          1
          
            λ
            
              n
              ≠
              
                n
                0
              
            
          
        
      
    
    
      
        (
        44
        )
      
    
  




From (40) and (44)

λn≠n0=N  (45)

Plugging (45) into (44) gives (36). So the lemma is proven for n≠n0.

Hereinafter, unless stated otherwise, it is assumed that the resource allocation does not concern Lemma 2. In order words, we assume that for all n=1, 2, there is at least one iε{1, . . . , N} such that rn(i)>0. The Kuhn-Tucker condition for the maximization problem of (1) under such an assumption is:
for all i=1, . . . , N and for all n=1, 2




  
    
      
        
          
            d
            L
          
          
            d
            
              
                b
                n
              
              ⁡
              
                (
                i
                )
              
            
          
        
        =
        
          
            
              
                d
                f
              
              
                d
                
                  
                    b
                    n
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
            -
            
              λ
              n
            
          
          =
          
            
              
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
                
                  x
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
              -
              
                λ
                n
              
            
            ≤
            0
          
        
      
    
    
      
        (
        46
        )
      
    
  
  
    
      
        
          
            
              b
              n
            
            ⁡
            
              (
              i
              )
            
          
          ·
          
            
              d
              L
            
            
              d
              
                
                  b
                  n
                
                ⁡
                
                  (
                  i
                  )
                
              
            
          
        
        =
        
          
            
              
                b
                n
              
              ⁡
              
                (
                i
                )
              
            
            ·
            
              (
              
                
                  
                    
                      r
                      n
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  
                    x
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
                -
                
                  λ
                  n
                
              
              )
            
          
          =
          0
        
      
    
    
      
        (
        47
        )
      
    
  




and for all n=1, 2





  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            
          
          ⁢
          
            
              b
              n
            
            ⁡
            
              (
              i
              )
            
          
        
        =
        1
      
    
    
      
        (
        48
        )
      
    
  
  
    
      
        
          λ
          n
        
        >
        0
      
    
    
      
        (
        49
        )
      
    
  




where N(≧2) represents the number of terminal, i=1, . . . , N represent the terminal index and n=1, 2 represent the resource group number.

Note that b1(i)=b2(i)=0 should be ruled out since then the throughput satisfies x(i)=0, violating (31). Thus, for all i=1, . . . , N, one of the following needs to be satisfied:

b1(i)>0 and b2(i)=0  (50)

b1(i)>0 and b2(i)>0  (51)

b1(i)=0 and b2(i)>0  (52)

If (5) is satisfied, by (2), (47), and (46)





  
    
      
        
          
            
              r
              1
            
            ⁡
            
              (
              i
              )
            
          
          
            x
            ⁡
            
              (
              i
              )
            
          
        
        =
        
          
            
              
                r
                1
              
              ⁡
              
                (
                i
                )
              
            
            
              
                
                  r
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
              ·
              
                
                  b
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
            
          
          =
          
            
              1
              
                
                  b
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
            
            =
            
              λ
              1
            
          
        
      
    
    
      
        (
        53
        )
      
    
  
  
    
      
        
          
            
              r
              2
            
            ⁡
            
              (
              i
              )
            
          
          
            x
            ⁡
            
              (
              i
              )
            
          
        
        =
        
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              
                
                  r
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
              ·
              
                
                  b
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
            
          
          ≤
          
            λ
            2
          
        
      
    
    
      
        (
        54
        )
      
    
  




Plugging (53) into (54) and rearranging for the same resource group,





  
    
      
        
          
            
              r
              2
            
            ⁡
            
              (
              i
              )
            
          
          
            λ
            2
          
        
        ≤
        
          
            
              r
              1
            
            ⁡
            
              (
              i
              )
            
          
          
            λ
            1
          
        
      
    
    
      
        (
        55
        )
      
    
  




If (52) is satisfied, by symmetry,





  
    
      
        
          1
          
            
              b
              2
            
            ⁡
            
              (
              i
              )
            
          
        
        =
        
          λ
          2
        
      
    
    
      
        (
        56
        )
      
    
  
  
    
      
        
          
            
              r
              2
            
            ⁡
            
              (
              i
              )
            
          
          
            λ
            2
          
        
        ≥
        
          
            
              r
              1
            
            ⁡
            
              (
              i
              )
            
          
          
            λ
            1
          
        
      
    
    
      
        (
        57
        )
      
    
  




Finally, if (51) is satisfied, by (47)





  
    
      
        
          
            
              r
              1
            
            ⁡
            
              (
              i
              )
            
          
          
            x
            ⁡
            
              (
              i
              )
            
          
        
        =
        
          
            
              
                r
                1
              
              ⁡
              
                (
                i
                )
              
            
            
              
                
                  
                    r
                    1
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ·
                
                  
                    b
                    1
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
              +
              
                
                  
                    r
                    2
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ·
                
                  
                    b
                    2
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
          
          =
          
            λ
            1
          
        
      
    
    
      
        (
        58
        )
      
    
  
  
    
      
        
          
            
              r
              2
            
            ⁡
            
              (
              i
              )
            
          
          
            x
            ⁡
            
              (
              i
              )
            
          
        
        =
        
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              
                
                  
                    r
                    1
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ·
                
                  
                    b
                    1
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
              +
              
                
                  
                    r
                    2
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ·
                
                  
                    b
                    2
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
          
          =
          
            λ
            2
          
        
      
    
    
      
        (
        59
        )
      
    
  




Rearranging (58) and (59) for 1/x(i),





  
    
      
        
          1
          
            x
            ⁡
            
              (
              i
              )
            
          
        
        =
        
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              λ
              2
            
          
          =
          
            
              
                r
                1
              
              ⁡
              
                (
                i
                )
              
            
            
              λ
              1
            
          
        
      
    
    
      
        (
        60
        )
      
    
  




Multiplying (58) and (59) respectively by b1(i) and b2(i) and summing them up,





  
    
      
        
          
            
              
                
                  
                    λ
                    1
                  
                  ·
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
                +
                
                  
                    λ
                    2
                  
                  ·
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
              
              =
              
              ⁢
              
                
                  
                    
                      
                        r
                        1
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                    ·
                    
                      
                        b
                        1
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                  
                  
                    
                      
                        
                          r
                          1
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                      ·
                      
                        
                          b
                          1
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                    +
                    
                      
                        
                          r
                          2
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                      ·
                      
                        
                          b
                          2
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                  
                
                +
              
            
          
        
        
          
            
              
              ⁢
              
                
                  
                    
                      r
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  ·
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                
                
                  
                    
                      
                        r
                        1
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                    ·
                    
                      
                        b
                        1
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                  
                  +
                  
                    
                      
                        r
                        2
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                    ·
                    
                      
                        b
                        2
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                  
                
              
            
          
        
        
          
            
              =
              
              ⁢
              1
            
          
        
      
    
    
      
        (
        61
        )
      
    
  




Note that (53) and (56) can also be represented by (61) by plugging (50) and (52), respectively. Therefore, regardless of the three cases (50) through (52), each terminal should satisfy

λ1·b1(i)+λ2·b2(i)=1  (62)

Also, depending on the cases, one of (54), (57), and (60) should be satisfied.

By distinguishing the equality and the inequality in (54) and (57), each terminal should satisfy (62) and one of the following:





  
    
      
        
          
            
              b
              1
            
            ⁡
            
              (
              i
              )
            
          
          >
          0
        
        ,
        
          
            
              b
              2
            
            ⁡
            
              (
              i
              )
            
          
          =
          0
        
        ,
        
          
            and
            ⁢
            
              
            
            ⁢
            
              
                
                  r
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
              
                λ
                1
              
            
          
          >
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              λ
              2
            
          
        
      
    
    
      
        (
        63
        )
      
    
  
  
    
      
        
          
            
              b
              1
            
            ⁡
            
              (
              i
              )
            
          
          >
          0
        
        ,
        
          
            
              b
              2
            
            ⁡
            
              (
              i
              )
            
          
          =
          0
        
        ,
        
          
            and
            ⁢
            
              
            
            ⁢
            
              
                
                  r
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
              
                λ
                1
              
            
          
          =
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              λ
              2
            
          
        
      
    
    
      
        (
        64
        )
      
    
  
  
    
      
        
          
            
              b
              1
            
            ⁡
            
              (
              i
              )
            
          
          >
          0
        
        ,
        
          
            
              b
              2
            
            ⁡
            
              (
              i
              )
            
          
          >
          0
        
        ,
        
          
            and
            ⁢
            
              
            
            ⁢
            
              
                
                  r
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
              
                λ
                1
              
            
          
          =
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              λ
              2
            
          
        
      
    
    
      
        (
        65
        )
      
    
  
  
    
      
        
          
            
              b
              1
            
            ⁡
            
              (
              i
              )
            
          
          =
          0
        
        ,
        
          
            
              b
              2
            
            ⁡
            
              (
              i
              )
            
          
          >
          0
        
        ,
        
          
            and
            ⁢
            
              
            
            ⁢
            
              
                
                  r
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
              
                λ
                1
              
            
          
          =
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              λ
              2
            
          
        
      
    
    
      
        (
        66
        )
      
    
  
  
    
      
        
          
            
              b
              1
            
            ⁡
            
              (
              i
              )
            
          
          =
          0
        
        ,
        
          
            
              b
              2
            
            ⁡
            
              (
              i
              )
            
          
          >
          0
        
        ,
        
          
            and
            ⁢
            
              
            
            ⁢
            
              
                
                  r
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
              
                λ
                1
              
            
          
          <
          
            
              
                r
                2
              
              ⁡
              
                (
                i
                )
              
            
            
              λ
              2
            
          
        
      
    
    
      
        (
        67
        )
      
    
  




Plugging (63) through (67) into (62) and rearranging,





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        1
                      
                    
                    >
                    0
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        
                          r
                          1
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                      
                        λ
                        1
                      
                    
                  
                  >
                  
                    
                      
                        r
                        2
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                    
                      λ
                      2
                    
                  
                
                ⁢
                
                  
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        1
                      
                    
                    >
                    0
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  0
                
                ,
              
            
            
              
                
              
            
          
          
            
              
                
                  
                    
                      
                        
                          
                            
                              λ
                              1
                            
                            ·
                            
                              
                                b
                                1
                              
                              ⁡
                              
                                (
                                i
                                )
                              
                            
                          
                          +
                          
                            
                              λ
                              2
                            
                            ·
                            
                              
                                b
                                2
                              
                              ⁡
                              
                                (
                                i
                                )
                              
                            
                          
                        
                        =
                        1
                      
                      ,
                    
                  
                
                
                  
                    
                      
                        
                          
                            b
                            1
                          
                          ⁡
                          
                            (
                            i
                            )
                          
                        
                        >
                        0
                      
                      ,
                      
                        
                          
                            b
                            2
                          
                          ⁡
                          
                            (
                            i
                            )
                          
                        
                        >
                        0
                      
                      ,
                      or
                    
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      
                        r
                        1
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                    
                      λ
                      1
                    
                  
                
                =
                
                  
                    
                      r
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  
                    λ
                    2
                  
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        2
                      
                    
                    >
                    0
                  
                
              
            
            
              
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        2
                      
                    
                    >
                    0
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      
                        r
                        1
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                    
                      λ
                      1
                    
                  
                
                <
                
                  
                    
                      r
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  
                    λ
                    2
                  
                
              
            
          
        
      
    
    
      
        (
        68
        )
      
    
  




Lemma 3

If (68) is the solution to the maximization problem of (1) through (8), then.

λ1+λ2=N  (69)

To begin the proof, note that if (68) is the solution, it satisfies (3), (4), and (62). Summing up (62) for all i





  
    
      
        
          
            ∑
            
              i
              =
              1
            
            N
          
          ⁢
          
            (
            
              
                
                  λ
                  1
                
                ·
                
                  
                    b
                    1
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
              +
              
                
                  λ
                  2
                
                ·
                
                  
                    b
                    2
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
            )
          
        
        =
        N
      
    
    
      
        (
        70
        )
      
    
  




Plugging (3) and (4) into (70) proves the lemma.

A discussion of the remaining lemmas is prefaced by the following discussion of sorting. With sorted differentiation factors as in (16), the Kuhn-Tucker conditions (68) can be rewritten as




  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        1
                      
                    
                    >
                    0
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    
                      d
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                  
                  >
                  
                    
                      λ
                      1
                    
                    
                      λ
                      2
                    
                  
                
                ⁢
                
                  
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        1
                      
                    
                    >
                    0
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
              
            
            
              
                
              
            
          
          
            
              
                
                  
                    
                      
                        
                          
                            
                              λ
                              1
                            
                            ·
                            
                              
                                b
                                1
                              
                              ⁡
                              
                                (
                                k
                                )
                              
                            
                          
                          +
                          
                            
                              λ
                              2
                            
                            ·
                            
                              
                                b
                                2
                              
                              ⁡
                              
                                (
                                k
                                )
                              
                            
                          
                        
                        =
                        1
                      
                      ,
                    
                  
                
                
                  
                    
                      
                        
                          
                            b
                            1
                          
                          ⁡
                          
                            (
                            k
                            )
                          
                        
                        >
                        0
                      
                      ,
                      
                        
                          
                            b
                            2
                          
                          ⁡
                          
                            (
                            k
                            )
                          
                        
                        >
                        0
                      
                      ,
                      or
                    
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  
                    d
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                
                =
                
                  
                    λ
                    1
                  
                  
                    λ
                    2
                  
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        2
                      
                    
                    >
                    0
                  
                
              
            
            
              
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        2
                      
                    
                    >
                    0
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  
                    d
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                
                <
                
                  
                    λ
                    1
                  
                  
                    λ
                    2
                  
                
              
            
          
        
      
    
    
      
        (
        71
        )
      
    
  




Taking advantage of (16) and rearranging the case of





  
    d
    ⁡
    
      (
      k
      )
    
  
  =
  
    
      λ
      1
    
    
      λ
      2
    
  




in (71) gives





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        1
                      
                    
                    >
                    0
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      k
                    
                    =
                    1
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    n
                    1
                  
                
                ⁢
                
                  
                
              
            
          
          
            
              
                
                  
                    
                      
                        
                          
                            
                              λ
                              1
                            
                            ·
                            
                              
                                b
                                1
                              
                              ⁡
                              
                                (
                                k
                                )
                              
                            
                          
                          +
                          
                            
                              λ
                              2
                            
                            ·
                            
                              
                                b
                                2
                              
                              ⁡
                              
                                (
                                k
                                )
                              
                            
                          
                        
                        =
                        1
                      
                      ,
                    
                  
                
                
                  
                    
                      
                        
                          
                            b
                            1
                          
                          ⁡
                          
                            (
                            k
                            )
                          
                        
                        >
                        0
                      
                      ,
                      
                        
                          
                            b
                            2
                          
                          ⁡
                          
                            (
                            k
                            )
                          
                        
                        >
                        0
                      
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    
                      n
                      1
                    
                    +
                    1
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  
                    n
                    2
                  
                  -
                  1
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      
                        λ
                        2
                      
                    
                    >
                    0
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    n
                    2
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        72
        )
      
    
  




where n1 and n2 are integers satisfying 0≦n1<n2≦N+1, n1=0 indicating that there is no k such that b1(k)>0, b2(k)=0, n2=n1+1 indicating that there is no k such that b1(k)>0, b2(k)>0, and n2=N+1 indicating there is no k such that b1(k)=0, b2(k)>0.

A resource allocation scheme where there is at least one terminal whose resource group shares are both non-zero (i.e. b1(k)>0 and b2(k)>0) is referred to herein as an overlapping scheme. Otherwise, the resource allocation scheme is referred as a non-overlapping scheme. By (72) and its definition, for a non-overlapping scheme,

n2=n1+1  (73)

For an overlapping scheme,

n2=n1+m  (74)

where m=2, . . . , N−n1. Here we need examine only m=2, because overlapping schemes for other cases exist only for limited instances of differentiation factor distribution and are not desirable in terms of resource allocation overhead issues, such as power consumption and feedback. Here, we are interested in n1, n2, λ1, and λ2 that makes (72) the solution to the maximization problem of (1) through (8). We first prove the following lemma.

Lemma 4

If (72) is the solution to the maximization problem of (1) through (8), then

n1≦λ1  (75)

n2≧λ1+1  (76)

As a proof, first we prove (75). If n1=0, (75) follows immediately from λ1>0. If n1≧1, then there exists k such that 1≦k≦n1 and





  
    
      
        b
        1
      
      ⁡
      
        (
        k
        )
      
    
    =
    
      
        1
        
          λ
          1
        
      
      >
      0
    
  
  ,
  
    
      
        b
        2
      
      ⁡
      
        (
        k
        )
      
    
    =
    0.
  




Then by (3) and (72),





  
    
      
        
          
            ∑
            
              k
              =
              1
            
            
              n
              1
            
          
          ⁢
          
            
              b
              1
            
            ⁡
            
              (
              k
              )
            
          
        
        =
        
          
            
              n
              1
            
            
              λ
              1
            
          
          ≤
          1
        
      
    
    
      
        (
        77
        )
      
    
  




Hence (75) is proven. Now we prove (76). If n2=N+1, by Lemma 3

n2=N+1=(λ1+λ2)+1  (78)

Then n2>λ1+1 follows from λ2>0 and (78). Now, if n2≦N then there exists k such that n2≦k≦N and b1(k)=0,




  
    
      b
      2
    
    ⁡
    
      (
      k
      )
    
  
  =
  
    
      1
      
        λ
        2
      
    
    >
    0.
  




Then by (4) and (72):





  
    
      
        
          
            ∑
            
              k
              =
              
                n
                2
              
            
            N
          
          ⁢
          
            
              b
              2
            
            ⁡
            
              (
              k
              )
            
          
        
        =
        
          
            
              N
              -
              
                n
                2
              
              +
              1
            
            
              λ
              2
            
          
          =
          
            
              
                N
                -
                
                  n
                  2
                
                +
                1
              
              
                N
                -
                
                  λ
                  1
                
              
            
            ≤
            1
          
        
      
    
    
      
        (
        79
        )
      
    
  




and

N−n2+1≦N−λ1  (80)

Hence, (80) is proven.

Note that equality in (75) and (76) holds if and only if n2=n1+1.

By Lemma 3, the threshold in (71) can be expressed using a function,





  
    G
    ⁡
    
      (
      x
      )
    
  
  =
  
    
      
        N
        ·
        x
      
      
        1
        +
        x
      
    
    .
  








  
    
      
        
          
            λ
            1
          
          
            λ
            2
          
        
        =
        
          
            
              λ
              1
            
            
              N
              -
              
                λ
                1
              
            
          
          =
          
            
              G
              
                -
                1
              
            
            ⁡
            
              (
              
                λ
                1
              
              )
            
          
        
      
    
    
      
        (
        81
        )
      
    
  




where





  
    
      G
      
        -
        1
      
    
    ⁡
    
      (
      x
      )
    
  
  =
  
    x
    
      N
      -
      x
    
  




is the inverse of G(x). Then the following lemmas hold.

Lemma 5

Let (71) and (72) be the solution to the maximization problem of (1) through (8), then if





  
    
      d
      ⁡
      
        (
        k
        )
      
    
    >
    
      
        λ
        1
      
      
        λ
        2
      
    
  
  =
  
    
      G
      
        -
        1
      
    
    ⁡
    
      (
      
        λ
        1
      
      )
    
  




for kε{1, 2, . . . , N} then 1≦k≦n1 

Lemma 6

Let (71) and (72) be the solution to the maximization problem of (1) through (8), then if





  
    
      d
      ⁡
      
        (
        k
        )
      
    
    <
    
      
        λ
        1
      
      
        λ
        2
      
    
  
  =
  
    
      G
      
        -
        1
      
    
    ⁡
    
      (
      
        λ
        1
      
      )
    
  




for kε{1, 2, . . . , N} then n2≦k≦N

Lemma 7

Let (71) and (72) be the solution to the maximization problem of (1) through (8), then if n1+1≦k≦n2−1 for kε{1, 2, . . . , N} then





  
    d
    ⁡
    
      (
      k
      )
    
  
  =
  
    
      
        λ
        1
      
      
        λ
        2
      
    
    =
    
      
        G
        
          -
          1
        
      
      ⁡
      
        (
        
          λ
          1
        
        )
      
    
  




From (71), (72) and (81), it is straightforward to prove Lemmas 5-7; hence their proof is left out for brevity. Here, it is important to note that the converses of the above lemmas are not generally true. The derivation of cases 1 through 3 may now be addressed.

Note that G(x) and its inverse,




  
    
      
        G
        
          -
          1
        
      
      ⁡
      
        (
        x
        )
      
    
    =
    
      x
      
        N
        -
        x
      
    
  
  ,




are strictly increasing for 0≦x<N. Also the range of G−1(x) is [0,∞) for 0≦x<N. On the other hand, d(k) is monotonically decreasing for k=1, 2, . . . , N and there is at least one finite positive d (k). (Otherwise, the solution is to be handled by Lemma 2.) Therefore, d(N) is always finite. By putting d(0)=∞, G−1(0)<d(0) and G−1(N)>d(N). Therefore, G−1(k)=d(k) for some k=1, 2, . . . , N−1, or there is no k s.t. G−1(k)=d(k) and G−1(k)<d(k) for k=0, 1, . . . , K and G−1(k)>d(k) for k=K+1, . . . , N, where K=0, 1, . . . , N−1. The former is denoted as case 1 as discussed above. The latter is further classified into case 2 and case 3 based on whether or not G−1(K)<d (K+1). Therefore, any differentiation factor distribution {d(k),k=1, 2, . . . , N} falls into one of the following three cases.

Case 1

∃Kε{1, . . . , N−1} s.t.

d(K)=G−1(K)  (82)

Case 2

∃Kε{0, . . . , N−1} s.t.

G−1(K)<d(K) and G−1(K+1)>d(K+1)  (83)

and in addition

G−1(K)<d(K+1)  (84)

Or equivalently,

∃Kε{0, . . . , N−1} s.t.

G(d(K+1))−1<K<G(d(K+1))  (85)

Case 3

∃Kε{0, . . . , N−1} s.t.

G−1(K)<d(K) and G−1(K+1)>d(K+1)  (86)

and in addition

G−1(K)≧d(K+1)  (87)

Or, equivalently

∃Kε{0, . . . , N−1} s.t.

G(d(K+1))≦K<G(d(K))  (88)

In the subsequent sections, we derive the proportional fair resource allocation for each of the cases.

Case 1

First we prove the following lemma.

Lemma 8

Let (71) and (72) be the solution to the maximization problem of (1) through (8). If the differentiation factor distribution {d(k),k=1, 2, . . . , N} falls into Case 1 with G−1(K)=d(K) for Kε{1, 2, . . . , N−1}, then

λ1=K  (89)

We prove it by contradiction. First, assume K<λ1. Because G−1(x) is strictly increasing,

G−1(K)<G−1(λ1)  (90)

Since G−1(K)=d(K) from the definition of K

d(K)<G−1(λ1)  (91)

Then by lemma 6

n2≦K≦N  (92)

By the assumption and (92)

n2≦K<λ1  (93)

However, by lemma 4

n2≧λ1+1  (94)

This contradicts with (93). Therefore,

λ1≦K  (95)

Now, assume K>λ1. Because G−1(x) is strictly increasing,

G−1(K)>G−1(λ1)  (96)

From definition of K and (96)

d(K)>G−1(λ1)  (97)

Then by lemma 5

1≦K≦n1  (98)

By the assumption and (98)

λ1<K≦n1  (99)

However, by lemma 4

n1≦λ1  (100)

This contradicts to (93). Therefore,

K≦λ1  (101)

The lemma follows from (95) and (101).

Now we derive a non-overlapping scheme as the solution to the maximization problem of (1) through (8) for case 1, and then show that an overlapping scheme with n2=n1+2 does not exist for case 1.
Non-Overlapping Scheme
For a non-overlapping scheme, the equality in (75) and (76) is

n1=λ1  (102)

n2=λ1+1  (103)

Because n1 is an integer, from (89) and (102)

n1=λ1=K  (104)

and

n2=K+1  (105)

Plugging (104) and (105) into (72) results in a non-overlapping resource allocation scheme as follows:





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    K
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  1
                
                ,
                ...
                ⁢
                
                  
                
                ,
                K
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      N
                      -
                      K
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    K
                    +
                    1
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        106
        )
      
    
  




where Kε{1, . . . , N−1}, and

d(K)=G−1(K)  (107)

Overlapping Scheme

We show that an overlapping scheme with n2=n1+2 does not exist for case 1. We prove this by contradiction. Assume there is an overlapping scheme with n2=n1+2 for Case 1. For overlapping scheme, the equality does not hold in lemma 4. Thus

n1<λ1<n1+1  (108)

However, from (89) λ1 is an integer, and no integer satisfies (108). Due to the contradiction, we conclude that an overlapping scheme with n2=n1+2 does not exist for case 1.

Case 2 will now be considered as follows:

Case 2

Derivation of case 2 uses the following lemma.
Lemma 9
Let (71) and (72) be the solution to the maximization problem of (1) through (8). If the differentiation factor distribution {d(k),k=1, 2, . . . , N} falls into case 2 with G(d(K+1))−1<K<G(d(K+1)) for Kε{0, . . . , N−1}, then

λ1=G(d(K+1))  (109)

We prove (109) by the similar technique used in the proof of lemma 8. First, assume G(d(K+1))<λ1. Because K<G(d(K+1)) from the definition of K

K<λ1  (110)

Then by lemma 4,

K<λ1≦n2−1  (111)

and

K+1<n2  (112)

However, because G(d(K+1))<λ1 from lemma 6

n2≦K+1  (113)

But (113) contradicts with (112). Therefore,

G(d(K+1))≧λ1  (114)

So, now assume G(d(K+1))>λ1. Since G(d(K+1))<K+1 from definition of K

λ1<K+1  (115)

Then by lemma 4,

n1≦λ1<K+1  (116)

and

n1<K+1  (117)

However, because G(d(K+1))>λ1, from lemma 5

K+1≦n1  (118)

But (118) contradicts with (117). Therefore,

G(d(K+1))≦λ1  (119)

The lemma thus follows from (114) and (119).

In the following, we show that a non-overlapping scheme does not exist for case 2 and then drive an overlapping scheme with n2=n1+2 as the solution to the maximization problem of (1) through (8) for case 2.
Non-Overlapping Scheme
Assume there is a non-overlapping scheme that is the solution to the maximization problem of (1) through (8), then equality holds in lemma 4:

n1=λ1  (120)

From (109)

n1=λ1=G(d(K+1))  (121)

On the other hand, by the definition of K,

K<G(d(K+1))<K+1  (122)

Because n1 is an integer, G(d(K+1)) should be an integer due to (121). However, from (122), G(d(K+1)) cannot be an integer. Hence, there is a contradiction that proves that a non-overlapping scheme does not exist for case 2.

Overlapping Scheme

In this subsection, we derive an overlapping scheme with n2=n1+2 for case 2. By lemma 4,

n1<λ1<n1+1  (123)

From (109) and the definition of K,

K<G(d(K+1))=λ1<K+1  (124)

Because n1 and K are integers, from (123) and (124)

n1=K  (125)

Because n2=n1+2

n2=K+2  (126)

From (3), (72), and (125)





  
    
      
        
          1
          -
          
            
              ∑
              
                i
                =
                1
              
              N
            
            ⁢
            
              
                b
                1
              
              ⁡
              
                (
                i
                )
              
            
          
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              
                
                  n
                  1
                
                +
                1
              
            
            ⁢
            
              
                b
                1
              
              ⁡
              
                (
                i
                )
              
            
          
          =
          
            
              
                ∑
                
                  i
                  =
                  1
                
                
                  K
                  +
                  1
                
              
              ⁢
              
                
                  b
                  1
                
                ⁡
                
                  (
                  i
                  )
                
              
            
            =
            
              
                K
                
                  λ
                  1
                
              
              +
              
                
                  b
                  1
                
                ⁡
                
                  (
                  
                    K
                    +
                    1
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        127
        )
      
    
  




From (127) and (109)





  
    
      
        
          
            b
            1
          
          ⁡
          
            (
            
              K
              +
              1
            
            )
          
        
        =
        
          
            1
            -
            
              K
              
                λ
                1
              
            
          
          =
          
            
              
                
                  λ
                  1
                
                -
                K
              
              
                λ
                1
              
            
            =
            
              
                
                  G
                  ⁡
                  
                    (
                    
                      d
                      ⁡
                      
                        (
                        
                          K
                          +
                          1
                        
                        )
                      
                    
                    )
                  
                
                -
                K
              
              
                λ
                1
              
            
          
        
      
    
    
      
        (
        128
        )
      
    
  




By (62) and (128)





  
    
      
        
          
            b
            2
          
          ⁡
          
            (
            
              K
              +
              1
            
            )
          
        
        =
        
          
            
              1
              -
              
                
                  λ
                  1
                
                ·
                
                  
                    b
                    1
                  
                  ⁡
                  
                    (
                    
                      K
                      +
                      1
                    
                    )
                  
                
              
            
            
              λ
              2
            
          
          =
          
            
              1
              -
              
                G
                ⁡
                
                  (
                  
                    d
                    ⁡
                    
                      (
                      
                        K
                        +
                        1
                      
                      )
                    
                  
                  )
                
              
              -
              K
            
            
              λ
              2
            
          
        
      
    
    
      
        (
        129
        )
      
    
  




Now, from (72), (128), and (129) we have an overlapping resource allocation scheme as follows:





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      λ
                      1
                    
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  1
                
                ,
                ...
                ⁢
                
                  
                
                ,
                K
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      a
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    
                      λ
                      1
                    
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      -
                      
                        a
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                    
                      λ
                      2
                    
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  k
                
                =
                
                  K
                  +
                  1
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      λ
                      2
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    K
                    +
                    2
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        130
        )
      
    
  




where Kε{0, . . . , N−1}, and

K<G(d(K+1))<K+1  (131)=

λ1=G(d(K+1))  (132)

λ2=N−λ1  (133)

α(K+1)=G(d(K+1))−K  (134)

Finally, case 3 will be addressed as follows:
Case 3
Case 3 relies on the following lemma:
Lemma 10
Let (71) and (72) be the solution to the maximization problem of (1) through (8). If the differentiation factor distribution {d(k), k=1, 2, . . . , N} falls into case 3 with G(d(K+1))≦K<G(d(K)) for Kε{0, . . . , N−1}, then

λ1K  (135)

A proof of (135) begins by assuming K<λ1. Because G−1(x) is strictly increasing,

G−1(K)<G−1(λ1)  (136)

Since G(d(K+1)) K from the definition of K

d(K+1)≦G−1(K)<G−1(λ1)  (137)

Then by lemma 6

n2≦K+1≦N  (138)

By the assumption and (138)

n2≦K+1<λ1+1  (139)

However, by lemma 4

n2≧λ1+1  (140)

This contradicts with (139). Therefore,

λ1≦K  (141)

Now, assume K>λ1. Because G−1(x) is strictly increasing,

G−1(K)>G−1(λ1)  (142)

From definition of K and (142)

d(K)>G−1(λ1)  (143)

Then by lemma 5

1≦K≦n1  (144)

By the assumption and (144)

λ1<K≦n1  (145)

However, by lemma 4

n1≦λ1  (146)

This contradicts with (145). Therefore,

K≦λ1  (147)

The lemma follows from (141) and (147)

Now we derive a non-overlapping scheme as the solution to the maximization problem of (1) through (8) for case 3, and then show that overlapping scheme with n2=n1+2 does not exist for case 3.
Non-Overlapping Scheme
For a non-overlapping scheme, the equality holds in lemma 4:

n1=λ1  (148)

n2=λ1+1  (149)

Because n1 is an integer, from (135) and

n1=λ1=K  (150)

and

n2=K+1  (151)

Plugging (150) and (151) into (72) results in a non-overlapping resource allocation scheme as follows:





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    K
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  1
                
                ,
                ...
                ⁢
                
                  
                
                ,
                K
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      N
                      -
                      K
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    K
                    +
                    1
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        152
        )
      
    
  




where Kε{1, . . . , N−1}, and

G(d(K+1))≦K<G(d(K))  (153)

Overlapping Scheme

We show that an overlapping scheme with n2=n1+2 does not exist for case 3 by contradiction. Assume there is an overlapping scheme with n2=n1+2 for case 3. For an overlapping scheme, the equality does not hold in lemma 4. Thus

n1<λ1<n1+1  (154)

From (135) λ1 must be an integer. But no integer satisfies (1534). Due to the resulting contradiction, we conclude that an overlapping scheme with n2=n1+2 does not exist for case 3.

Regardless of whether an overlapping or non-overlapping scheme is implemented, the resulting scheme is required to operate in any of the three cases: case 1 to 3. As shown in the previous sections, however, neither the non-overlapping nor the overlapping scheme is capable of meeting that requirement. So, adaptive switching between the two schemes is necessary for implementation.
The following discussion proves the single form of the solution to the maximization problem of (1) through (8) discussed with regard to FIG. 8. Specifically




  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      λ
                      1
                    
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  1
                
                ,
                ...
                ⁢
                
                  
                
                ,
                K
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      a
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    
                      λ
                      1
                    
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    
                      1
                      -
                      
                        a
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                    
                      λ
                      2
                    
                  
                
              
            
            
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  k
                
                =
                
                  K
                  +
                  1
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      λ
                      2
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    K
                    +
                    2
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        155
        )
      
    
  




where Kε{0, 1, . . . , N−1}, such that

G(d(K+0)−1≦K<G(d(K))  (156)

and

λ1=max(G(d(K+1)),K)  (157)

λ2=N−λ1  (158)

α(K+1)=max(G(d(K+0))−K,0)  (159)

Case 1

First, note that Case 1 is equivalent to the case where the equality in the LHS of (156) holds. That is, for a Kε{0, . . . , N−1},

G(d(K+1))=K+1  (160)

Plugging (160) into (157) and (159) leads to

λ1=K+1  (161)

α(K+1)=1  (162)

From (155), (161), (158), and (162):





  
    
      
        {
        
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      K
                      +
                      1
                    
                  
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  1
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  K
                  +
                  1
                
              
            
          
          
            
              
                
                  
                    
                      b
                      1
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  0
                
                ,
                
                  
                    
                      b
                      2
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  =
                  
                    1
                    
                      N
                      -
                      
                        (
                        
                          K
                          +
                          1
                        
                        )
                      
                    
                  
                
              
            
            
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    K
                    +
                    2
                  
                
                ,
                ...
                ⁢
                
                  
                
                ,
                N
              
            
          
        
      
    
    
      
        (
        163
        )
      
    
  




Then (106) and (107) follows from (160) and (163) by putting {circumflex over (K)}=K+1. Thus, (155) through (159) correctly represent the non-overlapping solution to the maximization problem of (1) through (8) for case 1.

Case 2

Case 2 is the case where (84) and the inequalities of (156) hold. Because G−1(K)<d(K+1) by (84), and from (157) and (159)

λ1=max(G(d(K+1)),K)=G(d(K+1))  (164)

α(K+1)=max(G(d(K+1))−K,0)=G(d(K+1))−K  (165)

(164) and (165) are respectively the same as (132) and (134). Thus, (155) through (159) correctly represent the overlapping scheme solution to the maximization problem of (1) through (8) for case 2.

Case 3

Case 3 is the case where (87) and the inequalities of (156) hold. Because G−1(K)≧d(K+1) by (87) and from (157) and (159)=

λ1=K  (166)

α(K+1)=0  (167)

(152) results from plugging (166) and (167) into (155). Thus, (155) through (159) correctly represent the non-overlapping solution to the maximization problem of (1) through (8) for case 3.

As discussed above with regard to FIG. 9, an alternative solution to (155) through (159) is given by




   
  
    
      
        
          {
          
            
              
                
                  
                    
                      
                        b
                        1
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    =
                    
                      1
                      λ
                    
                  
                  ,
                  
                    
                      
                        b
                        2
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    =
                    0
                  
                
              
              
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      k
                    
                    =
                    1
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    ⌊
                    λ
                    ⌋
                  
                
              
            
            
              
                
                  
                    
                      
                        b
                        1
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    =
                    
                      
                        λ
                        -
                        
                          ⌊
                          λ
                          ⌋
                        
                      
                      λ
                    
                  
                  ,
                  
                    
                      
                        b
                        2
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    =
                    
                      
                        1
                        +
                        
                          ⌊
                          λ
                          ⌋
                        
                        -
                        λ
                      
                      
                        N
                        -
                        λ
                      
                    
                  
                
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    k
                  
                  =
                  
                    
                      ⌊
                      λ
                      ⌋
                    
                    +
                    1
                  
                
              
            
            
              
                
                  
                    
                      
                        b
                        1
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    =
                    0
                  
                  ,
                  
                    
                      
                        b
                        2
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    =
                    
                      1
                      
                        N
                        -
                        λ
                      
                    
                  
                
              
              
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      k
                    
                    =
                    
                      
                        ⌊
                        λ
                        ⌋
                      
                      +
                      2
                    
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  N
                
              
            
          
        
      
      
        
          (
          168
          )
        
      
    
  




where └x┘ is a flooring function, which returns the largest integer no greater than x, and

λ=max(G(d(K+1)),K)  (169)

and Kε{0, 1, . . . , N−1}, such that

G(d(K+1))−1≦K<G(d(K))  (170)

Showing the equivalence of two representations is straightforward from





  
    
      
        
          ⌊
          λ
          ⌋
        
        =
        
          {
          
            
              
                K
              
              
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      
                        G
                        ⁡
                        
                          (
                          
                            d
                            ⁡
                            
                              (
                              
                                K
                                +
                                1
                              
                              )
                            
                          
                          )
                        
                      
                    
                    -
                    1
                  
                  <
                  K
                  <
                  
                    G
                    ⁡
                    
                      (
                      
                        d
                        ⁡
                        
                          (
                          K
                          )
                        
                      
                      )
                    
                  
                
              
            
            
              
                
                  K
                  +
                  1
                
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    
                      G
                      ⁡
                      
                        (
                        
                          d
                          ⁡
                          
                            (
                            
                              K
                              +
                              1
                            
                            )
                          
                        
                        )
                      
                    
                  
                  =
                  
                    K
                    +
                    1
                  
                
              
            
          
        
      
    
    
      
        (
        171
        )
      
    
  




Algorithms 2 through 4 will now be discussed in a more summary fashion in that the mathematical analysis to show their proportional fairness is analogous to that discussed above for algorithm 1. Algorithm 3 will be discussed first. Algorithm 3 is simply a more general form of algorithm 1 discussed above in that the indexing of the sorted differentiation factors starts from an arbitrary integer a as opposed to 1 in the case of algorithm 1. Such a re-indexing of the sorted differentiation factors is advantageous in that software solutions will require less memory for the implementation of algorithm 3.
Algorithm 3 also sorts the differentiation factors in a monotonically descending order but indexed from k=α, α+1, . . . , α+N−1. Such an indexing also covers N terminals as discussed with regard to algorithm 1 but does not start from 1 but instead from an arbitrary integer a, which can be positive or negative. The border terminal is then defined with regard to an index Kε{a−1, a, . . . , a+N−2} such that G(d(K+1))−1≦K<G(d(K), where the border determining function G(x) equals (a−1+(N+a−1)x)/(1+x). It can be seen that such a border definition is analogous to act 805 of FIG. 8. Similarly, the first resource group share b1(k) and the second resource group share b2(k) can be defined analogously to step 810 as follows: if k is a member of the set {a, a+1, . . . , K} then b1(k)=1/λ1 and b2(k)=0. On the other hand, if k equals K+1, then the resource group shares are given by b1(k)=α/λ1 and b2(k)=(1−α)/λ2. Finally, if k is a member of the set {K+2, . . . , a+N−1}, then the resource group shares are given by b1(k)=0 and b2(k)=1/λ2, where λ1 equals the maximum of (G(d(K+1)),K)−a+1, λ2 equals N−λ1, and α equals λ1−K+a−1, which in turn equals the max(G(d(K+1))−K,0). An alternative expression for algorithm 3 may be derived analogously as discussed with regard to FIG. 9 and also FIGS. 10 and 11.
In contrast to algorithm 1, algorithm 2 sorts the differentiation factors in a monotonically increasing order as indexed from k equals 1 to N. The border terminal is then defined with regard to an index Kε{2, 3, . . . , N+1} such that G(d(K))<K≦G(d(K−1))+1, where the border determining function G(x) equals (N+1+x)/(1+x). This border definition is also analogous to step 805 of FIG. 8. Similarly, the first resource group share b1(k) and the second resource group share b2(k) can be defiled analogously to step 810 as follows: If k belongs to the set {1, . . . , K−2}, then b1(k)=0 and b2(k)=1/λ2. On the other hand, if k equals K−1, then b1(k)=α/λ1 and b2(k)=(1−α)/λ2. Finally, if k is a member of the set {K, . . . , N}, then b1(k)=1/λ1 and b2(k)=0, where λ2 equals the min(G(d(K−1)),K)−1, λ1 equals N−λ2, and α equals (K−1−λ2), which in turn equals max(K−G(d(K−1)),0). An alternative expression for algorithm 2 may be derived analogously as discussed with regard to FIG. 9 and also FIGS. 10 and 11.
Algorithm 4 is the general case of algorithm 1 where the sorted differentiation factors are indexed from a to a+N−1 as in algorithm 3. The border terminal is then defined with regard to an index Kε{a+1, a+2, . . . , a+N} such that G(d(K))<K≦G(d(K−1))+1, where the border determining function G(x) equals (N+a+ax)/(1+x). Again, this border definition is analogous to step 805 of FIG. 8. Similarly, the first resource group share b1(k) and the second resource group share b2(k) can be defined analogously to step 810 as follows: If k belongs to the set {a, a+1, . . . , K−2}, then b1(k)=0 and b2(k)=1/λ2. On the other hand, if k equals K−1, then the resource group shares are given by b1(k)=α/λ1 and b2(k)=(1−α)/λ2. Finally, if k is a member of the set {K, . . . , a+N−1}, then the resource group shares are given by b1(k)=1/λ1 and b2(k)=0, where λ2 equals min (G(d(K−1)),K)−a, λ1 equals N−λ2, and a equals K−a−λ2, which in turn equals max(K−G(d(K−1)),0).
Regardless of which algorithm is implemented, the allocation of resource groups may be applied in either the uplink or the downlink. A base station may measure the uplink data rates directly. However, the downlink data rates are preferably determined by the terminals. Thus step 1200 of FIG. 12 discussed further below may not be necessary for the uplink but is preferably used in the downlink.
The overhead required for downlink allocation is illustrated in FIG. 12. Terminals determine their downlink rates and deliver the information for deriving the differentiation factors in a step 1200. In that regard, each terminal may measure the downlink rates and determine its differentiation factor so that it may transmit the differentiation factor directly to the base station in step 1200. Alternatively, the terminals may simply transmit the rates in step 1200 such that the base station determines the differentiation factors. The base station may transmit an indication 1205 to the terminals to indicate what resource group or groups each terminal should associate with. The terminals may then confirm their corresponding association (or associations) in a step 1210.
Association is yet another example which may require the collaboration of terminals and network nodes. Association may require terminals to transmit a certain message to the network based on the knowledge of which resource group or groups the terminals are to be associated. For example, in a carrier aggregation scenario, the CC or CCs to be activated is determined by the network and delivered to the terminals. The terminals then transmit a CC activation message to the network to complete the association. In a resource partition scenario, the network determines on which resource partition or partitions a terminal should monitor and delivers the decision to the terminals. The terminals, in response to this association indication, monitor the corresponding resource partition(s) and send a measurement report on the resource partitions to the network. In a handoff scenario, the network decides which cell for a terminal to handoff. In return, the terminals, transmit handoff related messages to the network.
FIG. 13 shows a base station 600 and a mobile station 650 configured to perform the downlink allocation discussed with regard to FIG. 12. A transmit/receive module 665 in mobile station 650 couples to a measurement unit 675 so that the downlink data rates for each resource group can be measured. The resulting rates are transmitted to base station 600 as shown symbolically as path 605. Base station 600 includes a processor 635 that determines the proportional fair downlink allocations according to one of algorithms 1 through 4 discussed above. The resulting allocations may be stored in a memory 640 and also communicated back to mobile station 650 over symbolic path 605. Mobile station 650 may then proceed to receive downlink transmissions from base station 605 as generated in a transmit/receive module 620 according to its calculated resource allocation share.
The above-described embodiments of the present invention are representative of many possible embodiments. It will thus be apparent to those skilled in the art that various changes and modifications may be made to what has been disclosed without departing from this invention. The appended claims encompass all such changes and modifications as falling within the true spirit and scope of this invention.

## Claims

1. A method of associating a plurality of mobile stations between a first resource group and a second resource group, comprising:
for each mobile station, determining a first unit share rate for the mobile station for a first one of the resource groups and a second unit share rate for the mobile station for a remaining second one of the resource groups;
for each mobile station, determining a corresponding differentiation factor from the mobile station's first unit share rate and the mobile station's second unit share rate;
sorting the differentiation factors into one of a monotonically ascending order or a monotonically descending order to produce sorted differentiation factors;
applying a proportional fair border determining function to the sorted differentiation factors to determine a border one of the sorted differentiation factors, wherein a first portion of the sorted differentiation factors includes the border differentiation factor and any differentiation factors that are less than or equal to the border differentiation factor and a second portion includes the border differentiation factor and any differentiation factors that are greater than or equal to the border differentiation factor, and
associating the mobile stations corresponding to the first portion with the first resource group and associating the mobile stations corresponding to the second portion with the second resource group.

2. The method of claim 1, wherein each differentiation factor depends upon a relative size of the first resource group as compared to a relative size of the second resource group.

3. The method of claim 1, wherein the first and second resource groups are selected from the group consisting of time domain resource partitions and frequency domain resource partitions.

4. The method of claim 1, wherein the association is a downlink association, the method further comprising:
from a base station, transmitting downlink symbols to the mobile stations according to the association.

5. The method of claim 4, wherein each mobile station determines its first and second unit share rates, the method further comprising:
from each mobile station, transmitting the first and second unit data rates to the base station.

6. The method of claim 4, wherein each mobile station determines its first and second unit share rates and also its differentiation factor, the method further comprising:
from each mobile station, transmitting its differentiation factor to the base station.

7. The method of claim 1, wherein the sorting is a monotonically decreasing order, and wherein the plurality equals an integer number N, and wherein the proportional fair border determining function for each sorted differentiation factor equals N times the sorted differentiation factor divided by a sum of one plus the sorted differentiation factor.

8. The method of claim 1, further comprising: allocating the first resource group to the mobile stations corresponding to the first portion and allocating the second resource group to the mobile stations corresponding to the second portion.

9. A base station, comprising:
a processor configured to sort a plurality of differentiation factors corresponding to a plurality of mobile stations, wherein each differentiation factor is a ratio of a first unit share rate for the corresponding mobile station using a first resource group to a second unit share rate for the corresponding mobile station using a second resource group, the processor being configured to sort the differentiation factors into one of a monotonically ascending order or a monotonically descending order to produce sorted differentiation factors and to apply a proportional fair border determining function to the sorted differentiation factors to determine a border one of the sorted differentiation factors, wherein a first portion of the sorted differentiation factors includes the border differentiation factor and any differentiation factors that are less than or equal to the border differentiation factor and a second portion includes the border differentiation factor and any differentiation factors that are greater than or equal to the border differentiation factor, and wherein the processor is further configured to associate the mobile stations corresponding to the first portion with the first resource group and to associate the mobile stations corresponding to the second portion with the second resource group; and
a memory to store the resource group associations.

10. The base station of claim 9, further comprising: a receive/transmit module configured to transmit downlink transmissions to the mobile stations according to the resource group associations.

11. The base station of claim 10, wherein the receive/transmit module is further configured to receive the first and second unit share rates from each mobile station, and wherein the processor is configured to determine the differentiation factors from the received first and second unit data rates.

12. The base station of claim 10, wherein the receive/transmit module is further configured to receive the differentiation factors from the plurality of mobile stations.

13. The base station of claim 10, wherein the processor is further configured to sort the differentiation factors into monotonically ascending order.

14. The base station of claim 10, wherein the processor is further configured to allocate the first resource group among the mobile stations corresponding to the first portion and to allocate the second resource group among the mobile stations corresponding to the second portion.