Quantized VCG Mechanisms for Polymatroid Environments

by   Hao Ge, et al.

Many network resource allocation problems can be viewed as allocating a divisible resource, where the allocations are constrained to lie in a polymatroid. We consider market-based mechanisms for such problems. Though the Vickrey-Clarke-Groves (VCG) mechanism can provide the efficient allocation with strong incentive properties (namely dominant strategy incentive compatibility), its well-known high communication requirements can prevent it from being used. There have been a number of approaches for reducing the communication costs of VCG by weakening its incentive properties. Here, instead we take a different approach of reducing communication costs via quantization while maintaining VCG's dominant strategy incentive properties. The cost for this approach is a loss in efficiency which we characterize. We first consider quantizing the resource allocations so that agents need only submit a finite number of bids instead of full utility function. We subsequently consider quantizing the agent's bids.



There are no comments yet.


page 2

page 3

page 4

page 5

page 6

page 7

page 8

page 9


Incentive Compatible Mechanism for Influential Agent Selection

Selecting the most influential agent in a network has huge practical val...

Incentives in Resource Allocation under Dynamic Demands

Every computer system – from schedulers in public clouds (Amazon, Google...

An Efficient and Fair Multi-Resource Allocation Mechanism for Heterogeneous Servers

Efficient and fair allocation of multiple types of resources is a crucia...

Limitations of Incentive Compatibility on Discrete Type Spaces

In the design of incentive compatible mechanisms, a common approach is t...

Foundations of Transaction Fee Mechanism Design

In blockchains such as Bitcoin and Ethereum, users compete in a transact...

Characterization of Incentive Compatibility of an Ex-Ante Constrained Player

We consider a variant of the standard Bayesian mechanism, where players ...

Penalty Bidding Mechanisms for Allocating Resources and Overcoming Present Bias

From skipped exercise classes to last-minute cancellation of dentist app...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1. Introduction

Efficient allocation of limited resources is a fundamental problem in networked systems. Economic-based models are a common way of addressing this problem. In such models, agents are endowed with utility functions and the goal is to maximize the social welfare, given by the sum of the agents’ utilities. Hence, given the agents’ utility functions, efficient resource allocation then reduces to solving an optimization problem. In networked systems, two challenges to such an approach are (1) the agents are distributed and only limited communication may be available to communicate user utilities and resource allocations decisions, and (2) self-interested users may not have incentive to correctly report their utilities.

The incentive issue has been studied through the lens of mechanism design. One of the most celebrated results in this literature is the Vickrey-Clarke-Groves (VCG) mechanism (Vickrey, 1961; Clarke, 1971; Groves, 1973), which provides an elegant solution to the incentive issue. In the VCG mechanism, each agent is required to report her utility function and in turn receives an allocation and makes a payment based on the reports of every agent. Through a carefully designed payment, the VCG mechanism achieves the efficient outcome under a strong incentive guarantee. Namely, it is dominant strategy incentive compatible (DSIC) for agents to truthfully report their utility and if they do so, then the mechanism simply maximizes the sum of the reported utility, yielding the efficient outcome. However, in the context of divisible network resources, such as power, bandwidth or storage space, each agent’s utility may be infinite dimensional and hence VCG mechanisms do not address the issue of limited communication.

The limited communication issue has also been well studied. In particular, we highlight the seminal work of Kelly, (Kelly, 1997; Kelly et al., 1998), in which agents submit one-dimensional bids and receive an allocation determined by the ratio of their bid and a congestion price. For price-taking agents, who do not anticipate the impact of their actions on the price, this mechanism can lead to the socially optimal allocation, but as shown in (Johari and Tsitsiklis, 2004), when buyers can anticipate the impact of their actions on congestion price, this mechanism can lead to an efficiency loss.

In (Yang and Hajek, 2007; Johari and Tsitsiklis, 2009), a “VCG-Kelly” mechanism was proposed that combined the one-dimensional bids in Kelly’s mechanism and the VCG payment rule. This mechanism is shown to obtain the socially optimal outcome as with VCG. However, the incentive guarantee is relaxed to the weaker notion of Nash equilibria instead of a dominant strategy equilibria as in VCG.111Justifying a Nash equilibria requires that agents are aware of each others’ pay-offs (and rationality) or apply some type of dynamic process to reach this point.

In our previous work, (Ge and Berry, 2018a, b), we introduced an alternative approach for reducing communication costs while maintaining VCG’s dominant strategy incentive properties when allocating a single divisible resource. This approach was to quantize the resource and then run VCG on the quantized resource. This incurs some efficiency loss, which was bounded. We build on this approach in this paper, but instead of a single divisible resource, we consider resource allocations that are constrained to lie within a polymatroid in , where is the number of agents. Such a polymatroid environment is a natural and non-trivial generalization of a single divisible resource. For example, if the single divisible resource represents the rate on a given link in a network, then a polymatroid can be viewed as giving the region of rates obtainable by different source-destination pairs across a network with multiple links (see e.g. (Federgruen and Groenevelt, 1986)). As shown in (Yang and Hajek, 2005; Berry and Vohra, 2006), mechanisms for single links may not work when applied in a more general network setting. Polymatroid environments can also model many other network settings such as multiclass queueing systems (Shanthikumar and Yao, 1992), various network flow problems (Lawler and Martel, 1982a; Imai, 1983; Lawler and Martel, 1982b), spectrum sharing (Kang et al., 2014; Berry et al., 2013) and problems in network information theory (Tse and Hanly, 1998; Ge et al., 2015; Tse et al., 2004). Given a polymatroid feasible region, we study quantized VCG mechanisms and the resulting efficiency losses for strategic agents.

The contributions of this paper are the following:

  • Given a polymatroid environment, we determine a way to quantize the resource into partitions so that a feasible allocation of partitions lies in an integral polymatroid.

  • Based on the integral polymatroid, we propose a quantized VCG mechanism for allocating partitions. This mechanism inherits VCG’s DSIC property and further, due to the polymatroid structure, can be implemented using a greedy algorithm. We also characterize the worst-case efficiency loss of this mechanism due to the quantization.

  • In addition to the quantization of the resource, we further study a rounded VCG mechanism in which the agents’ bids are also quantized. The bid quantization results in the mechanism no longer being DSIC, but we show that -dominant strategies exist. We characterize the worst-case efficiency for three different types of such strategies.

  • We analyze the trade-off between communication cost and overall efficiency in our proposed mechanisms. We further discuss the impact of the parameters in each mechanism.

The rest of the paper is organized as follows: in Sect. 2, we review some properties of polymatroids and the VCG mechanism. Our two classes of quantized mechanisms are introduced and analyzed in Sect. 3-4. We conclude the paper in Sect. 5.

Notations: and

denote the set of nonnegative real-valued and integer-valued vectors of dimension

, respectively. We use for the floor, for the ceiling, and for the fractional part of . We denote by the subset of for everybody except for agent and denotes the set with the component replaced with . We write as the projection onto the nonnegative orthant. The indicator function equals 1 if the event happens, otherwise 0.

2. Model and Background

2.1. Polymatroids

We begin by reviewing some basic definitions and properties related to polymatroids.

Definition 2.1 ().

(Edmonds, 1970) Given a finite ground set , a set function : is submodular if:

for any subsets and of . If the inequality holds strictly, the set function is strictly submodular.

An equivalent definition for submodularity is:

for any and distinct .

A set function : is normalized if ; monotone (non-decreasing) if ; and integer-valued if .

Definition 2.2 ().


If the set function is normalized, monotone and submodular, then is a polymatroid with rank function .

If the rank function of a polymatroid is integer-valued, then it follows that all of corner points are also integer valued. Further, it can sometimes be convenient to regard an integral polymatroid, i.e., a polymatroid consisting of only points in instead of points in (Edmonds, 1970). We adopt this view here when discussing integral polymatroids.

The following are two well known properties of polymatroids.

Lemma 2.3 ().

Given a polymatroid , if , then the polyhedron

is also a polymatroid with rank function , where

Lemma 2.4 ().

For any polymatroid , there exists a such that .

The second lemma shows that the sum constraint over all is always tight for some point within the polymatroid. The set of all such points is referred to as the polymatroid’s dominant face, which is formally defined next.

Definition 2.5 ().

The dominant face of a polymatroid , denoted by , is defined as:

As defined in (Salimi et al., 2015), the minimum distance of a set function over a ground set is:


where the distance between two arbitrary subsets and is defined as:


This can be thought of as an indication of how strictly supermodular the set function is. For a submodular function , the distance between two arbitrary subsets is always non-negative. Furthermore, if the set function is strictly submodular, then the minimum distance is strictly greater than 0.

Following (Salimi et al., 2015), we have the following theorem:

Theorem 2.6 ().

Given a polymatroid with , then for any , there exists another polymatroid such that and .


Let be a normalized set function defined as for any nonempty set . Then let and for any nonempty set . With a small value of , we can make sure the difference between and is less than . Moreover, since is submodular with a nonnegative minimum distance, we can show is a rank function with . The detailed proof is omitted due to space consideration. ∎

The above theorem shows that given any polymatroid, we can find another polymatroid with positive minimum distance such that the new polymatroid lies in the given one and the discrepancy could be arbitrarily small. Due to this reason, in the remainder of the paper, we only consider polymatroids constrained by set functions with positive minimum distance.222If this is not the case, then we can use the above construction and as will be evident it would have negligible impact on the resulting efficiency of our mechanisms.

2.2. Social Welfare Maximization Problem

We consider a model where a set of agents are competing for a resource constrained by a polymatroid environment. Denote the set of agents as . A feasible allocation is then any point that lies in a polymatroid associated with a set function over . In particular, the agents in any subset could obtain a total allocation of at most , i.e., . Without loss of generality, we assume that . Moreover, each individual’s allocation must be non-negative and hence .

Each agent is endowed with a utility function , which only depends on the agent’s final allocation. Throughout this paper, these utility functions satisfy the following assumptions:

Assumption 1 ().

Each agent’s utility function is only known by that agent, i.e., it is private information.

Assumption 2 ().

The utility functions are nonnegative, concave, and strictly increasing.

Assumption 3 ().

For all agents, the marginal utility per unit resource is bounded, that is, there exist positive constants and such that for any agent , . These bounds are public information.

Assumption 4 ().

The utility functions are in monetary units and each agent’s quasilinear payoff is defined as , where is the payment for the allocated resource.

Assumption 1 results in the incentive issue: utilities are private information, each agent may lie about them. Assumption 2 and 3 show agents have “elastic” resource requirements and the unit value for the resource lies within some range, which is reasonable in many practical settings. The last assumption is widely adopted in pricing mechanisms and the quasilinear structure makes each agent’s strategy and the corresponding final allocation dependent on the payment rule in this game as well as the utility functions.

Under this setting, the goal of the allocator is to make the best use of the resource, i.e., to maximize the social welfare. This is given by solving the following optimization problem:


Since the total sum constraint is always binding in polymatroids, we have the following result from (Groenevelt, 1991). We give a proof of this for completeness.

Proposition 2.7 ().

The optimal solution to optimization problem (3) lies on the dominant face of the polymatroid.


We show this by means of contradiction. Suppose is the optimal solution, but . Then we can construct a new polymatroid by subtracting the optimal solution :


The new set function is , which satisfies the properties for set function to define a polymatroid. Since , the polymatroid is not empty and so we can find a nonzero vector inside. Moreover, each utility function is strictly increasing, hence , which is a contradiction. This finishes the proof. ∎

2.3. Vickrey-Clarke-Groves (VCG) Mechanism

Next we review the VCG mechanism. In this mechanism, the allocator asks agents to report their utility functions and determines the allocation which maximizes the social welfare under the reported utilities. The VCG payments for given agent is then given by the difference between the total utility the other agents would have received if the given agent was not present and the total utility that they received based on the reported utilities.333This is the most common form of VCG payments known as the Clarke pivot rule, more generally changing agent ’s payment by any function that does not depend on the reported utility of agent is also valid. In other words, each agent’s payment equals the increase in the others’ sum utility if she is absent.

Definition 2.8 ().

(Nisan et al., 2007) A mechanism where players have private information is said to be dominant-strategy incentive-compatible (DSIC) if it is a weakly-dominant strategy for every player to reveal his/her private information.

The VCG mechanism is DSIC, and given that agents follow the dominant strategy of reporting their true utility, the mechanisms will be efficient, i.e. it will maximize the social welfare.

2.4. Quantized VCG Mechanism

Given a divisible resource, the utility function an agent submits in the VCG mechanism can be an arbitrary real valued function of the amount of resource obtained. As we have discussed, this can result in the excessive communication overhead. Next we discuss the approach in (Ge and Berry, 2018a) for limiting this overhead via quantization, when the resource is a single divisible resource, i.e., the resource constraint is given by . In this approach, the allocator partitions the whole resource into divisions equally and restricts agents to get an integer number of divisions. Essentially, this mechanism then runs a VCG mechanism for the quantized resource. Under this setting, each agent only needs to submit bids: , where indicates agent ’s marginal utility from getting an th additional unit of resource. This reduces the information an agent needs to submit from specifying an infinite dimensional function to specifying an -dimensional vector. For small values of , this quantization also simplifies the optimization faced by the resource allocator as it can now determine the socially optimal allocation via a greedy algorithm instead of needing to solve a convex optimization problem.444Also note that using a greedy algorithm gives the exact social optimal for the quantized problem, while when solving the convex optimization, the solution will typically be with some specified by the algorithm used. For large , this in turn could impact the incentive guarantee of VCG. Finally, since this is still a VCG mechanism, it it still DSIC and implements the social optimal outcome with the quantized resource. However there is a loss in efficiency due to the quantization of the resource. In (Ge and Berry, 2018a), tight bounds on this loss are given. Specifically, the efficiency (defined as the ratio of the welfare with divisions to the optimal welfare without quantization) is shown to always be no less than


where is the number of agents. Here we extend this to polymatroid environments.

3. Quantizing VCG for Polymatroids

In this section, we give two toy examples that show blindly partitioning the resource into devisions may result in a large efficiency loss or the failure of greedy algorithm for determining the assignment.

Example 3.1 ().

Consider two agents competing for the resource, where the feasible region is a polymatroid , their utilities are and , respectively.

For the setting in Example 1, suppose we partition the total resource into 3 divisions equally (), so that the amount of each division is . The feasible region for the number of divisions each agent can get then becomes:555Here we are assuming that any quantized allocation has to respect the original constrains in ; hence, for example, agent 1 can not receive two divisions since .

Observe that here the constraint function is no longer submodular and the sum constraint in is never tight. In particular note that the maximum number of divisions allocated is now 2 (), which means that of the total resource is never allocated. For the given utilities this results in an efficiency of , which is lower than the value of given by the bound in (5).666Moreover this poor efficiency is obtained with linear utilities, which lead to no loss in the setting in (Ge and Berry, 2018a). By changing the parameters in this example, even lower efficiencies are possible.

Example 3.2 ().

Consider the following polymatroid as the feasible region: , the utility functions for the agents are , , .

Similarly, if we partition the resource in Example 2 into 3 divisions, then the feasible region for number of divisions each agent can get is:

In this case is a feasible solution and the corresponding allocation is . In this case, all of the resource is allocated and the social welfare is . However, if we use the greedy algorithm to find the optimal allocation given the true marginal valuations, the solution and the corresponding allocation are and , respectively. This results in a social welfare of which is less than the value of obtained by the feasible solution . In other words the greedy algorithm no longer gives the optimal quantized allocation. The issue again is that is not a polymatroid.

These two examples illustrate that in a polymatroid environment more care is needed when quantizing the resource. In both cases, the issue is that region resulting from quantization is no longer a polymatroid. Next we discuss an approach to ensure that this does not occur by ensuring that the region obtained after quantization is always an integral polymatroid.

3.1. Integral Polymatroid Construction

Given a real-valued polymatroid, ,we next show that if a large enough number of partitions are used, then the issues in the previous two examples do not arise. The construction for doing this is given in Algorithm 1. This algorithm specifies an integral set , which indicates the number of quantized partitions for each agent.

  Inputs: Polymatroid associated with set function , which has the minimum distance .
  Choose integer such that .
  for   do
  end for
Algorithm 1 Resource Partition

We next give several properties of the set given by Algorithm 1. First, it is straightforward to see the following lemma, which states that any constraint in is within of the corresponding constraint in and that the sum constraints are the same.

Lemma 3.3 ().

For any , ; further, .

Next we show that the constraints in always allow any set of users to have at least two partitions. (Note this is not the case for Example 1 in the previous section when ).

Proposition 3.4 ().

For any non-empty subset , .


First, according to the definition of the minimum distance, for any agent and , we have:

Hence, for any nonempty subset , we can find and

Finally we show that is an integral polymatroid.

Theorem 3.5 ().

The polyhedron, , associated with given by Algorithm 1 is an integral polymatroid.


First, we know , so is normalized.

For monotonicity, consider two sets and such that , since is monotonically increasing, then


Moreover, we have


where we used the definition of minimum distance and the fact that , respectively, in the last two steps. Therefore, is submodular and is an integral polymatroid. ∎

Since is a polymatroid, there always exists an allocation on its dominant face and by construction , so that any such allocation will utilize all of the available resource.

3.2. Quantized VCG Mechanism

Given the feasible region , we define a quantized VCG mechanism as a mechanisms in which the agents are only allocated an integer number divisions, where the set of allocations must lie in the integral polymatroid constructed in Algorithm 1.

Under this setting, the optimal allocation is , where is the optional allocation of divisions given by the following integer optimization problem:

Corollary 3.6 ().

The maximizer lies on the dominant face of .

This is a straightforward generalization of Proposition 1 to the discrete setting and can be proven in a similar manner. Note also from the discussion above, such a solution will utilize all of the resource.

To determine the allocation, the resource allocator essentially runs a VCG mechanism for the possible allocations in . This requires each agent to submit its valuation for each possible bundle of units it can obtain. Since each agent can get at most units, agent only needs to report values: , . Equivalently, agent can submit the marginal utility instead. Note that the range of the marginal values will be smaller than the range of the actual utility values and so in some sense reporting the marginal values also reduces the communication cost. This will be made more precise in the next section, when we also consider quantizing the bids. The marginal utility is denoted by , where


Furthermore, under Assumption 3, all utility functions have bounded marginal valuations and hence each bid is lower bounded by . To further reduce the range of bids, we can require agent to submit the surrogate marginal utility so that:


Notice that both and are non-increasing in due to the concavity of .

The detailed mechanism is as follows:

  • Determine the number of partitions and partition the resource into divisions equally using Algorithm 1. The feasible region for number of units is .

  • Solicit and accept sealed surrogate marginal utility vectors .

  • Determine the allocation of divisions that optimize (8) where the objective is the utility given by the given bids . The final allocation agent gets is . The sum of bids picked is denoted by

  • Set price for agent as:

We next give a greedy algorithm in Algorithm 2 to determine the allocation in (8).

  Inputs: Integer-valued polymatroid ; descending list: , the first element of is denoted by
  Initialization: Set , .
  while  is not empty do
      (break ties arbitrarily);
     Remove the first element from ;
     if not  then
        Remove from ;
     end if
  end while
Algorithm 2 Greedy allocation algorithm

With this algorithm, the resources are allocated unit by unit. At each pass through, the algorithm maintains a list of feasible agents who can still receive an additional unit of resource. It then assign the next unit to the agent from this set with the largest surrogate marginal utility.

Based on (Edmonds, 1971; Rado, 1957; Edmonds, 2003), (Glebov, 1973) establishes the following theorem:

Theorem 3.7 ().

Suppose is a down-monotone and finite family of integer nonnegative vectors. The greedy algorithm optimizes a separable concave function over if and only if is an integral polymatroid.

Using this result, we can show the following theorem:

Theorem 3.8 ().

Given the surrogate marginal utility vectors , for any set of concave and non-decreasing utility functions such that for each agent , , then given by Algorithm 2 is the optimizer to problem (8) and the optimal outcome is , i.e.,


Combining Theorem 3.7 and Corollary 3.6 yields (12). We can show (13) according to the definition of . The detailed proof is omitted here. ∎

This theorem shows the allocation determined by the greedy algorithm is the optimal solution to problem (8) assuming the submitted surrogate marginal utilities are truthful. Next we show telling the truth is the (weakly) dominant strategy for each agent.

Corollary 3.9 ().

The quantized VCG mechanism is DSIC.


The difference between marginal utility and surrogate utility is more of an implementation issue. There is a one to one mapping between them and having agents send one or the other is equivalent. The last term in the payment compensates the difference ensuring the quantized VCG mechanism is still DSIC. ∎

3.3. Examples of Quantized VCG Performance

In this section we examine the performance of the quantized VCG mechanism for the two examples introduced in the previous section. In the following section, we turn to analyzing the performance in more general settings.

Example 1 (continued): Recall, for the original polymatroid , the optimal allocation is . For , we can find the minimum distance is . Hence, following Algorithm 2, we have . Fig. 1 shows the allocation given by the quantized VCG mechanism as varies. Also shown are the optimal allocations in . It can be seen that with 10 partitions, the quantized VCG allocation is close to the optimal and approaches it further as increases.

Figure 1. Performance of the quantized VCG mechanism for Example 1.

Example 2 (continued): For this example, the optimal allocation is and the minimum distance is . Hence, from Algorithm 2 we have . Fig. 1 shows the allocation as a function of the number of divisions. Again, the allocation given by the quantized VCG mechanism is close to the optimal allocation for and becomes closer as increases.

Figure 2. Performance of the quantized VCG mechanism for Example 2.

Also these figures show the trade-off between the efficiency of the quantized VCG mechanism and the communication cost. As we increase the number of partitions, the difference between the allocation given by the quantized VCG mechanism and the optimal solution is smaller, giving better efficiency. On the other hand, a larger number of partitions means a larger communication cost (and larger computational costs).

3.4. Efficiency Analysis

As in much of the literature, we evaluate the performance of the quantized VCG mechanism via the worst-case efficiency. This is defined as the ratio between the social welfare given by the quantized VCG mechanism and the optimal social welfare without quantization in the worst case (over the class of admissible utilities). Specifically, the worst-case efficiency for our mechanism is:


where is any utility function satisfying Assumptions 2 and 3.

Theorem 3.10 ().

For a system with agents, suppose we partition the resource into divisions equally and run the quantized VCG mechanism as proposed, where satisfies the condition in Algorithm 2. In this case, the efficiency is at least


If is the optimal solution without quantization, then must lie in . In addition, we can always find on the dominant face of , which is also a polymatroid by Lemma 2.3 (and is also integral since is integer-valued). Hence, and so is a feasible allocation of divisions on the dominant face of .

Thus, the efficiency is lower bounded by


Recall that the utility functions are concave and for agent we have:




This indicates to find the lower bound for the efficiency, we should only focus on utility functions that are linear for .

Proposition 3.4 shows that for any subset . Hence, the greedy algorithm must pick the 2 greatest bids. Let and so we have:




which is increasing in because is always nonnegative. Since , we have and hence


Substituting (21) into (20) yields:

In either case, we can check that the lower bound is a decreasing function over and we know , therefore, we finish the proof by letting . ∎

This lower bound is tight. Consider the example with two agents: and , . We can see in this case and should be greater than 3. If we pick , then the resulting allocation is , while the optimal allocation is . Hence, the efficiency is . As goes to 0, we achieve the lower bound, which is .

Remark 2: When , the lower bound approaches 1 and is tight, which makes sense because in this case, all agents have the same valuations of the resource and so the allocation is always efficient.

The lower bound is an increasing function of number of partitions, which indicates the trade-off between the efficiency and the communication cost as well. As goes to infinity, the lower bound goes to 1 since the mechanism approaches the VCG mechanism. Moreover, for a fixed number of partitions, the lower bound decreases as the number of agents grows, and when , the lower bound becomes independent of the number of agents and is a constant given .

4. Rounded Quantized VCG Mechanism

In the last section, we specified the quantized VCG mechanism for allocating a divisible resource in a polymatroid environment and provided a lower bound for the worst-case efficiency. In the quantized VCG mechanism, agent only needs to send bids in total to indicate her utility for the possible allocation. This is a reduction of the dimensionality of the needed communication - a common measure used in both the engineering literature (e.g. (Yang and Hajek, 2007; Ge and Berry, 2018a)) and in economics (e.g., this is the notion of information efficiency used by Hurowitz and Reiter (Hurwicz and Reiter, 2006)). However, from an information theoretic point of view, conveying a real number still requires an infinite number of bits. In a small networked system, agents can send a very long bids to approximate the real value, but when the number of agents grows in the network, the total amount of communication may be unacceptable. Hence, in this section we further consider quantizing the bids sent by each agent in addition to the quantization of the resource in a large networked system (e.g., ).777Again this builds on work in (Ge and Berry, 2018a), which considered a similar approach for a single divisible resource and only one of the bidding strategies we discuss below.

Concretely, we determine a monetary unit . Each agent is restricted to give valuations that are integer multiple of . Thereby, to indicate the surrogate marginal utility, agent needs to send an integer vector to approximate her true utility. We call the resulting mechanism the rounded quantized VCG mechanism.

More precisely this mechanism is defined as follows:

  • Determine the number of partitions and partition the resource into divisions equally using Algorithm 1. Again, denote the feasible region for number of units by .

  • Determine and broadcast the monetary unit .

  • Solicit and accept sealed value vectors .

  • Run the quantized VCG mechanism with marginal utility vectors . Break ties randomly and determine the allocation and payment.

In other words, following this mechanism, agent equivalently reports another function to approximate , where


As shown in Theorem 3.8, the resource allocator aims to find allocation to maximize the sum of , e.g.,


Obviously, the social welfare given by the rounded quantized VCG mechanism is less than that given by the quantized VCG since each agent cannot report her utility accurately. We will analyze the loss due to this restriction later in this section. Also, here we require that agents submit a non-increasing sequence of bids (as we will see in the following, due to bid quantization agents may not have an incentive to do this without the restriction). The main reason for this restriction is that it is needed for us to use the greedy algorithm to correctly determine the outcome and payments.

4.1. Equilibrium Analysis

It is shown in (Ge and Berry, 2018a) that there is no dominant strategy when using such a mechanism over a single-link network. Hence, this is also true for our more general polymatroid setting. 888If we set all constraints to the same value, e.g., , for all , then our problem is reduced to a single-link problem. We instead adopt the following relaxed solution concept which allows for agents to tolerate some loss:

Definition 4.1 ().

Given any , a strategy for agent is called -dominant if for all and ,

In other words, for agent , any unilateral deviation from strategy leads to at most an gain. A dominant strategy is a special case of an -dominant strategy with .

Definition 4.2 ().

A strategy profile forms an -equilibrium if for every agent , is -dominant.

(a) The FLOOR strategy.
(b) The CEILING strategy.
(c) The CEILOOR strategy.
Figure 3. Equivalent utility function under different strategies, the three example equilibrium strategies, where the true utility function and the monetary unit .

For this section, we assume agents can tolerate a loss and adopt the above solution concept. Note that this solution concept shares the key properties of dominant strategies. For example, once again, agents do not need any knowledge of the actions or rationality of other players to determine their action.

One result of this relaxation in the solution concept is that agents no longer have a unique strategy. We illustrate this in the next three theorems, which each show a different equilibrium profile (see also Figure 3).

Theorem 4.3 ().

Under the rounded quantized VCG mechanism with given , if set , then for any agent , it is an -dominant strategy to report for the partition. Moreover, if all agents play this -dominant strategy, the maximum difference between social welfare given by the quantized VCG and the rounded quantized VCG is .


For agent , as shown in the last section, reporting the true surrogate marginal utility (equivalently reporting ) is optimal without the quantized bid constraint and the corresponding maximum payoff is:


Here, indicates the other agents’ bids, which correspond to , and Suppose agent reports and the corresponding utility function is . Given the final allocation , then agent ’s payoff is:



To show the strategy is dominant, it is sufficient to show , which implies that agent ’s loss under this strategy is less than compared with the maximum payoff she can get.

As shown in Fig. 3(a), by reporting the floor value, for ,


Hence, we have:


and so


Therefore, it is an -dominant strategy to report the floor value.

Next, we show that if all agents follow this strategy, the difference between the social welfare given by the quantized VCG and the rounded quantized VCG mechanism is upper bounded by . In other words, the loss in social welfare due to the quantized bid constraint is no greater than . According to the definition, the difference is: