In the one-sided matching problem (often referred to as the house allocation problem), agents have preferences over a set of items, and the goal is to find an allocation in which every agent receives a single item, while maximizing some objective. Typically, as well as in this paper, this objective is the (utilitarian) social welfare, i.e., the total utility of the agents. Since its introduction by Hylland and Zeckhauser (1979), this has been one of the most fundamental problems in the literature of economics (e.g., see (Bogomolnaia and Moulin, 2001; Svensson, 1999)), and has also been extensively studied in computational social choice (e.g., see (Klaus et al., 2016)).
The classic work on the problem (including Hylland and Zeckhauser’s seminal paper) assumes that the preferences of the agents are captured by cardinal valuation functions, assigning numerical values to the different items; these can be interpreted as their von Neuman-Morgenstern utilities (Von Neumann and Morgenstern, 1947). From a more algorithmic viewpoint, one can envision a weighted complete bipartite graph (with agents and items forming the two sides of the partition), where the weights of the edges are given by these values. Crucially, most of the related literature assumes that the designer only has access to the preference rankings of the agents over the items (i.e., the ordinal preferences) induced by the underlying values, but not to the values themselves.111 The pseudo-market mechanism of Hylland and Zeckhauser (1979) is a notable exception to this. This is motivated by the fact that it is fairly standard to ask the agents to simply order the items, while it is arguably much more demanding to require them to specify exact numerical values for all of them.
This begs the following natural question: What is the effect of this limited information on the goals of the algorithm designer? In 2006, Procaccia and Rosenschein defined the notion of distortion to measure precisely this effect, when the goal is to maximize the social welfare. Their original research agenda was put forward for settings in general social choice (also referred to as voting), but has since then flourished to capture several different scenarios, including the one-sided matching problem. For the latter problem, Filos-Ratsikas et al. (2014), showed that the best possible distortion achieved by any ordinal algorithm is , even if one allows randomization, and even if the valuations are normalized. For deterministic algorithms, the corresponding bound is (Theorem 1).
While the aforementioned bounds establish a stark impossibility when one has access only to ordinal information, they do not rule out the prospect of good approximations when it is possible to elicit some cardinal information. Indeed, the cognitive burden of eliciting cardinal values in the literature has mostly been considered in the two extremes; either full cardinal information or not at all. Conceivably though, if the agents needed to come up with only a few cardinal values, the elicitation process would not be very demanding, while it could potentially have wondrous effects on the social welfare. This approach was advocated recently by Amanatidis et al. (2020), who proposed to study the tradeoffs between the number of cardinal value queries per agent and distortion. For the general social choice setting of Procaccia and Rosenschein (2006), Amanatidis et al. (2020) actually showed that with a limited number of such queries, one can significantly improve upon the existing strong impossibilities (Boutilier et al., 2015; Caragiannis et al., 2017). Motivated by the success of this approach for general social choice settings, we extend this research agenda and aim to answer the following question for the one-sided matching problem:
What are the best possible information-distortion tradeoffs in one-sided matching? Can we achieve significant improvements over the case of only ordinal preferences, by making only a few cardinal value queries per agent?
1.1 Our Contribution
We consider the one-sided matching problem with the goal of maximizing the social welfare under limited information. We adopt the standard assumption in the related literature that the agents provide as input their ordinal preferences over the items, and that these are induced by their cardinal valuation functions. Following the agenda put forward by Amanatidis et al. (2020), we also assume implicit access to the numerical values of the agents via value queries; we may ask for an agent and an item , and obtain the agent’s value, , for that item.
We measure the performance of an algorithm by the standard notion of distortion, and our goal is to explore the tradeoffs between distortion and the number of queries we need per agent. As the two extremes, we note that if we use queries per agent, we recover the complete cardinal valuation profile and thus the distortion is , whereas if we use queries, i.e., we use only the ordinal information, the best possible distortion is (see Theorem 1). The latter bound holds even if we consider valuation functions that satisfy the unit-sum normalization, i.e., the sum of the values of each agent for all the items is . As we mentioned earlier, even when allowing randomization, the best possible distortion is still quite large ( (Filos-Ratsikas et al., 2014)) without employing any value queries. In this work, we only consider deterministic algorithms, and leave the study of randomized algorithms for future work.
We provide the following results:
In Section 3, we present an algorithm parametrized by , which achieves distortion by making queries per agent. In particular, by setting and we achieve respectively
distortion using queries per agent;
constant distortion using queries per agent.
The algorithm is inspired by a conceptually similar idea presented by Amanatidis et al. (2020) for the social choice setting. In Section 6 we adapt our algorithm to provide analogous information-distortion tradeoffs for a wide range of well-studied optimization problems, including two-sided matching, general graph matching and the clearing problem for kidney exchange.
Next, still in Section 3, motivated by the analysis of the class of algorithms mentioned above as well as our lower bounds in Section 4, we consider a class of instances (coined -well-structured instances) that captures the case where the agents (roughly) agree on the ranking of the items. We present a simple algorithm achieving distortion by making only queries per agent for these instances.
In Section 4 we show a lower bound of on the distortion of any algorithm that makes queries per agent. An immediate consequence of this bound is that it is impossible to achieve constant distortion without asking almost queries! When is a constant, our aforementioned results on -well-structured instances also establish the tightness of our construction, since the proof uses instances of this type. Furthermore, using a construction which exploits the same ordinal but different cardinal information, we show that even under the stronger assumption of unit-sum normalization, the distortion cannot be better than with queries per agent.
In Section 5 we present our main algorithmic result for unit-sum valuations, namely a novel algorithm which achieves distortion using only two queries per agent.
Our results are summarized in Figure 1. We note that our upper bounds are robust to “errors” in the responses to the queries (albeit not stated this way for the sake of simplicity). As long as the reported values are within a constant multiplicative factor from the true values, qualitatively there is no change in any of our bounds.
Our parametrized class of algorithms developed in Section 3 is based on the following idea. First, every agent is queried for their favorite item. Then, for each agent, the algorithm partitions the items into sets so that the value of the agent for all items in a set is lower-bounded by a carefully defined quantity; these sets are constructed via a sequence of binary search subroutines. Finally, the algorithm outputs a matching that maximizes the social welfare, with respect to the “simulated” values obtained via this process.
A similar idea was proposed by Amanatidis et al. (2020) for the social choice setting. We remark, however, that if one translates their result directly to our setting (by interpreting matchings as alternatives and running their algorithm), it yields inconsequential distortion bounds, as well as an exponential-time running time for the algorithm. To obtain meaningful bounds, the key is to adopt the principle of their approach rather than the exact solution proposed. As a matter of fact, in Section 6
, we show that the same principle can be further refined and applied to a plethora of other combinatorial optimization problems on graphs with additive objectives. In particular, we show bounds of similar flavor for several well-studied problems, such as
two-sided (perfect) matching (i.e., a (perfect) matching on a bipartite graph with agents on each side);
general graph matching (i.e., a matching on a general graph with agents being the vertices);
general resource allocation (i.e., the allocation of items to agents under various constraints);
max -sum clustering (i.e., a generalization of matchings on graphs, see (Anshelevich and Sekar, 2016a));
the clearing problem for kidney exchanges (i.e., a cycle cover with restricted cycle length, see (Abraham et al., 2007)).
With regard to our results for -well-structured instances in Section 3, we note that we obtain a notable improvement over the tradeoffs achieved by the aforementioned approach. For instance, a distortion of is achievable here using only two queries! To provide some intuition, one can think of
-well-structured instances as capturing cases for which there is a general agreement on the set of the “most valuable items”, although the agents might rank the items in this set in different ways. For example, most researchers in Artificial Intelligence would agree on the top 5 publication venues, although they might rank those 5 venues differently. The parametercaptures the different “levels” of agreement.
An interesting class of instances that are -well-structured for every is that of instances where all the agents have the same ranking over all items. These instances are important because intuitively, they highlight the challenge of social welfare maximization under ordinal information. How is an algorithm in that case supposed to distinguish between pairs of high and low value? Perhaps somewhat surprisingly, it turns out that such instances are more amenable to handling via a smaller number of queries. In fact, the related literature has been concerned in the past with this type of instances; e.g., Filos-Ratsikas et al. (2014) used such instances in their lower bound constructions and referred to them as ordered instances, and Plaut and Roughgarden (2020) and Barman and Krishnamurthy (2020) considered such instances in the context of fair division of indivisible items. We also use such instances for our lower bound constructions in Section 4; in that sense, we do not only provide improved upper bounds for an interesting class of instances but we also show the tightness of the analysis for our lower bound constructions.
We remark that the results of Section 3 and Section 6 do not require any normalization assumptions. For agents with unit-sum normalized valuations, in Section 5, we present an algorithm which achieves a distortion of using only two queries per agent. The algorithm is adaptive, and uses the second query differently, depending on the maximum value that it sees after querying all agents at the first position. While this result is not tight based on our lower bound of for this case, we consider it as one of the highlights of this work. In particular, it shows that sublinear distortion is possible even with a deterministic algorithm using a constant number of queries per agent.
1.2 Related Work
The one-sided matching problem in the context of agents with preferences over items was firstly introduced by Hylland and Zeckhauser (1979). The classic literature in economics (e.g., see (Bogomolnaia and Moulin, 2001; Svensson, 1999) and references therein) was mostly concerned with axiomatic properties, and has proposed several solutions and impossibilities; see the surveys of Sönmez and Ünver (2011) and Abdulkadiroglu and Sönmez (2013) for more information.
The effects of limited information on the social welfare objective were studied most notably in the work of Filos-Ratsikas et al. (2014) mentioned earlier. Further, a line of work (Anshelevich and Sekar, 2016a, b; Anshelevich and Zhu, 2017; Abramowitz and Anshelevich, 2018) studied related settings on graphs, and showed distortion bounds for matching problems and their generalizations. A crucial difference from our work is that they consider symmetric weights on the edges of the graph, which corresponds to cases where agents are paired with other agents (e.g., matching or clustering) and the value of an agent for another agent is the same as the value of for . In contrast, in the graph problems that we consider, the weights are assumed to be asymmetric; the weight of an edge is given by the sum of weights of incident vertices.222 Anshelevich et al. (2013) refer to this setting as “Asymmetric Edge-Labeled Graphs” as opposed to “Symmetric Edge-Labeled Graphs”, which is the setting of (Anshelevich and Sekar, 2016a) and the other works mentioned above. This makes the results markedly different. Another important distinction is that most of the aforementioned works operate in the setting where the edge weights satisfy the triangle inequality, whereas we impose no such restriction. Caragiannis et al. (2016) study one-side matching settings in metric spaces, and thus their work also falls into this category, but is quite distinct as they focus on cost objectives rather than welfare.
For general social choice settings (i.e., voting), the distortion of ordinal algorithms has been studied in a long list of papers, e.g., see (Procaccia and Rosenschein, 2006; Anshelevich and Postl, 2017; Anshelevich et al., 2018; Boutilier et al., 2015; Caragiannis et al., 2017; Benade et al., 2017; Caragiannis et al., 2018; Fain et al., 2019; Filos-Ratsikas and Miltersen, 2014; Goel et al., 2017; Munagala and Wang, 2019; Feldman et al., 2016; Gkatzelis et al., 2020). Most of the related work considers the standard case where only ordinal information is given, with a few notable exceptions (Abramowitz et al., 2019; Benade et al., 2017; Bhaskar et al., 2018; Filos-Ratsikas et al., 2020; Filos-Ratsikas and Voudouris, 2020).
The approach of enhancing the expressiveness of algorithms by equipping them with cardinal queries that we adopt in this paper was first suggested by Amanatidis et al. (2020). It should be noted that this is in nature quite different from another related recent approach proposed by Mandal et al. (2019, 2020), which considers the communication complexity of voting algorithms. In that setting, the algorithm must elicit a limited number of bits of information from the agents and it is not assumed that the ordinal preferences are already known. Moreover, the agents are allowed within that number of bits to communicate partial information about all of their different values.
2 Model definition
We consider the one-sided matching problem, where there is a set of agents and a set of items , such that . Each agent has a valuation function indicating the agent’s value for each item; that is is the value of agent for item . The valuation functions we consider are either
unrestricted, in which case the values for the items can be any non-negative real numbers, or
unit-sum, in which case the sum of values of each agent for all items is : .
We denote by the (cardinal) valuation profile of the agents. Let be a matching according to which each agent is matched to exactly one item , such that for every . Given a profile , the social welfare of , , is the total value of the agents for the items they are matched to according to :
By we denote the set of all perfect matchings on our instance. Our goal is to compute a matching with maximum social welfare, i.e.,
In case the valuation functions of the agents are known, then computing can be done efficiently, e.g., via the Hungarian method (Kuhn, 1956). However, our setting is a bit more restrictive. The exact valuation functions of the agents are their private information, and they can instead report orderings over the items, which are consistent with their valuations. In particular, every agent reports a ranking of the items such that if and only if for all . Given a valuation profile , we denote by the ordinal profile induced by ; observe that different valuation profiles may induce the same ordinal profile. On top of the ordinal preferences of the agents, we can obtain partial access to the valuation profile, by making a number of value queries per agent. In particular, a value query takes as input an agent and an item , and returns the value of agent for item . This leads us to the following definition of a deterministic algorithm in our setting.
A matching algorithm takes as input an ordinal profile , makes value queries per agent and, using as well as the answers to the queries, it computes a matching . If , is an ordinal algorithm, whereas if , is a cardinal algorithm.
As already mentioned, we can efficiently compute the optimal matching using a cardinal algorithm. However, if an algorithm is allowed to make a limited number of queries per agent, the computed matching might not be optimal. The question then is how well does such an algorithm approximate the optimal social welfare of any matching. Approximation here is captured by the notion of distortion.
The distortion of an algorithm is the worst-case ratio (over all possible valuation profiles ) between the social welfare of an optimal matching and the social welfare of the matching computed by :
2.1 Warm-up: Ordinal Algorithms
Before we proceed with our more technical results on tradeoffs between information and distortion, we consider the case of ordinal algorithms. When the valuation functions of the agents are unrestricted, the distortion of any ordinal algorithm is unbounded. To see this, consider any instance that contains two agents who agree on which the most valuable item is. Since only one of them can be matched to this item, it might be the case that the other agent has an arbitrarily large value for it, leading to unbounded distortion. Even for the more restrictive case of unit-sum valuations, however, the distortion of ordinal algorithms can be quite large.
The distortion of the best ordinal matching algorithm is .
For the upper bound, consider any algorithm that outputs a matching so that some agent is matched to her top-ranked item. As the valuations are unit-sum, this agent must have value at least for this item, and thus the social welfare of the matching computed by the algorithm is in turn also at least . Since the value of every agent for any item is at most , the maximum possible social welfare is upper-bounded by , and thus the distortion of the algorithm is at most .
For the lower bound, we assume that
is even; our instance can be easily adjusted for odd. We consider an instance with set of items . The ordinal profile is such that, for , agents and have the same ordinal preference , defined as
Consider any ordinal algorithm which, given as input this profile, outputs a matching . We define a valuation profile which is consistent with the ordinal profile, and the value of agent depends on the structure of . For convenience, let denote the second favorite item of agent , i.e., if and if .
If , then agent has value for all items;
If , then agent has value for and for every other item;
Otherwise, agent has value for , for and for every other item.
Since only one agent can be matched to , and everyone else will be matched to an item of value , the social welfare of computed by the algorithm is . However, observe that there exists a matching with social welfare . In particular, we can go through the agents and match each agent to if she is not already matched to or to in . This way we will end up with a matching where at least agents will have value each for the corresponding items. Our claim about the social welfare follows. Therefore, the distortion of any ordinal algorithm is . ∎
3 Distortion Guarantees for Unconstrained Valuations
Here we present -ThresholdStepFunction (-TSF), an algorithm that works for any valuation functions. At a high level, for each agent, we do the following. We first query the agent’s value for her highest ranked item. Then, we partition the items into sets, so that the agent’s value for all the items in a set is lower-bounded by a carefully selected quantity related to the agent’s top value. Based on this partition, we then define a new simulated valuation function for the agent, where the value of an item is equal to the lower bound that corresponds to the set the item belongs to. Finally, we compute a maximum weight matching with respect to the simulated valuation functions. Formally: [backgroundcolor=white!90!gray, leftmargin=rightmargin=skipabove=5pt,skipbelow=5pt]
Let for .
For every agent :
Query for her top-ranked item ; let be this value.
Let and .
For every , using binary search, compute
and let for every .
Let and set for .
Return a matching . The next theorem follows (asymptotically) from the more general Theorem 9, which is stated in Section 6 and applies to a number of well-known graph problems. To aid the reader, we also include a self-contained, cleaner proof of Theorem 2 which applies only to one-sided matching and gives a slightly better bound.
-TSF makes queries per agent and achieves a distortion of .
Consider an arbitrary valuation profile . Let be an optimal matching, and be the solution returned by -TSF; recall that maximizes the social welfare according to the simulated valuation functions . Let be the set of agents such that , and . Then, the optimal social welfare can be written as
We will bound the two terms separately. We begin with the first one:
The first inequality follows directly by the definition of . The second inequality follows since . The third inequality follows since maximizes the social welfare according to the profile and the algorithm has queried all agents for their most-preferred items. Finally, the last inequality follows since the simulated values of an agents are lower bounds on her true ones.
For the second term, let be the restriction of on agents for whom , . Then,
Now, let us assume that ; we will deal with the simpler case where later. By definition, for any and any , we have that . Also, for , we have . Hence,
The second inequality follows by considering all agents. The third inequality follows from the optimality of with respect to the simulated valuation functions. Finally, the last inequality follows follows since the simulated values of an agents are lower bounds on her true ones.
Now we can put everything together:
and this settles the bound on the distortion when .
When , we clearly have that
Then, the analog of (1) is
This concludes the proof. ∎
By appropriately setting the value of , we obtain several tradeoffs between the distortion and the number of queries per agent. In particular, we have the following statement.
We can achieve
distortion by making one query per agent;
distortion for any constant integer by making queries per agent;
distortion by making queries per agent.
3.1 Well-structured instances
We now consider instances in which the agents exhibit quite similar ordinal preferences. For any positive integer , we define the class of -well-structured (-WS) instances. Let be a constant (e.g., ). In a -WS instance, the set of items can be partitioned into sets , …, , such that
and every agent has the ordinal preference
where denotes some ordering of the items in set which depends on agent ; that is, different agents may order the items in differently. Observe that an instance in which all agents have the same ranking over the items is a -WS instance for every . We will use such instances in our lower bounds in the next section.
For the class of -WS instances we present a simple algorithm, names -FixedMaxMatching (-FMM), which achieves a distortion of by making queries per agent. It works as follows:
For every , query the value of each agent for her least-preferred item in ; denote this value by .
For each , define the simulated valuation function :
for every , ;
for every .
Return a matching .
For the class of -well-structured instances with , -FMM makes queries per agent and achieves a distortion of .
Consider an arbitrary -WS instance with valuation profile . For , denote by the set of agents with the highest values for the last item in (breaking ties arbitrarily). Since there exists a matching of the items in to the agents of , the algorithm maximizes the simulated welfare, and for every agent and item , the social welfare of the matching computed by the algorithm is
for every . Observe that since consists of just one item, the inequality for can be simplified to
Now, let be an optimal matching, and denote by the agent matched to item . Then,
where the inequality follows since consists of just one item, and the values of the agents for every item in are at most their values for the last item in (since all items in are ranked higher than the items in ). Let us focus on the right-most term of the above expression. We have
By the definition of , for every agent , it holds that , and thus
Observe that the internal double sum of the first term can sum over at most all agents in , while the internal double sum of the second term can sum over at most agents. Using the fact that and the lower bounds for the social welfare of the matching computed by the algorithm, we obtain
Putting everything together, we obtain the theorem. ∎
We conclude our discussion on -WS instances with a lower bound on the distortion of the -TSF algorithm; here, the value of the parameter is chosen to be because of the structure of -WS instances. Combined together with the queries that it requires to operate, we have that when is sub-logarithmic, the -FMM algorithm presented above matches the distortion of -TSF on -WS instances, using a factor of less queries per agent.
For every constant , there exists a -well-structured instance such that the distortion of -TSF when given this instance as input is .
Consider an instance in which all agents have the same ordinal preference over the items, which can be easily seen to be a -WS instance for every . Let us now define the cardinal values which are revealed when the -TSF algorithm queries the agents:
for queries about items in , ;
for queries about items in .
Because the rankings of the agents for the items and the revealed information due to the queries of the algorithm are the same among the agents, the algorithm will define the same simulated valuation function for all agents. In particular, based on the revealed values, we have that for every . By considering a valuation profile according to which an agent that is matched to an item in set has value for it, we have that the social welfare of the matching computed by the algorithm is
Now, observe that when binary search is restricted to run over only the items in the set , , it does not query all the items in ; in particular, because of the way binary search operates, the value of the first items therein will never be revealed. Hence, even if the algorithm matches the agents to items for which they have not been queried for, there must exist a matching such that for every the first items of are matched to agents different than the ones chosen by the algorithm, who have not been queried for their values. By setting the real values of the agents for these items to be , and observing that for some constant , we have
Hence, the distortion is . ∎
4 Lower bounds
In this section we show unconditional lower bounds for algorithms for one-sided matching which are allowed to make at most queries per agent. We present a generic matching instance which can be fine-tuned to yield lower bounds for both unrestricted and unit-sum valuation functions. Let denote any of these two classes of valuation functions.
Let be a function of , and be some constant. We want to define an instance in which the items are partitioned into sets such that
Note that because we have restricted the possible values of to be at most and have chosen , these sets of items can be defined; in particular, . We assume that is large enough so that and that is such that the cardinalities are indeed integers; the latter is only assumed to simplify the notation. We use to denote some fixed arbitrary ranking of the elements of set (which is common for all agents). Given that, we define the ordinal preference of every agent to be
We reveal the following information, depending on the queries of the algorithm:
For every , any query for some item in reveals a value of ;
Every query for some item in reveals a value of .
Observe that for , we have actually defined a -well-structured instance in which all agents have the same ordinal preference. As we will see below, this choice of in fact yields the best lower bound if is the class of unrestricted valuations. However, when is the class of unit-sum valuations, we will have to choose differently.
Next, we define two types of conditional valuation functions that an agent may have, depending on the behavior of the algorithm. These functions have to be consistent to the information that is revealed by the queries of the algorithm. Let be some constant.
(T1) If there exists , such that is not queried for any item in and she does not get an item from either, then ’s values are
at least for each item in if ;
at least for the item in if ;
for every item in , for ;
for every item in .
(T2) If is queried for some item in different sets out of , then her values are
for every item in , for ;
at most for every item in .
Observe that the conditions specified in (T1) and (T2) capture all possible cases about the queries of the algorithm and the possible assignments of the items to the agents.
Let be the class of unrestricted or unit-sum valuation functions. If there exists a function such that it is possible to define valuation functions in of types (T1) and (T2), the distortion of any matching algorithm which makes queries per agent is .
Observe that if the values of the agents for all items in a set are consistent to the revealed values, then the total value for all items in set is equal to . Since there are valuation functions of types (T1) and (T2), we can indeed define a valuation profile so that the value of every agent for the item she is matched to by the algorithm is exactly the value she would reveal if she was queried for it. So, the items of every set , , contribute exactly to the social welfare of the matching computed by the algorithm, while the items in contribute . Hence,
Hence, to show the desired bound on the distortion of the algorithm, it suffices to show that there is always a matching with social welfare .
This is clearly the case when there exists an agent who is not queried for the item in and is not given this item, since her value for it in such a case can be set to be at least using a function of type (T1) for . Therefore, since this item can only be given to one agent, in the following we assume that there is at most one agent who is not queried for it, and if such an agent exists, she must be given the item.
Consider the set of agents who are not queried for any item in and also do not get any item in . If , then by defining the valuation function of every agent in to be of type (T1) for , we can obtain a matching (in which exactly agents in are given a different item from ) with social welfare at least . The latter follows by the fact that for all . Consequently, it must be . This further implies that there are at least agents who are queried for some item in each of and , and do not get any item in . Let be the set of these agents.
Consider the set of agents who are not queried for any item in and also do not get any item in . Like in the case of and above, if , then by defining the valuation function of every agent in to be of type (T1) for , we can obtain a matching (in which of the agents in are given a different item from ) with social welfare at least . So, it must be , which implies that there are agents in who are queried for some item in each of , and , and do not get any item in . Let be the set of these agents.
By induction, this process leads to the existence of the set of agents who have been queried for some item in each of , …, , such that . Since
there are agents who have not been queried for any item in and do not get any item in . Thus, by setting their valuation functions to be of type (T1) for , we can construct a matching with welfare at least , completing the proof. ∎
Theorem 5 is actually quite powerful and allows us to prove lower bounds for both unrestricted and unit-sum valuation functions. In particular, it reduces the problem to finding the largest possible , such that valuation functions in of types (T1) and (T2) can be defined.
For unconstrained valuation functions, the distortion of any matching algorithm which makes queries per agent is .
It is straightforward to observe that it is indeed possible to define unconstrained valuation functions of types (T1) and (T2) for the function . In particular, the valuation functions are such that
where is a generic index, while in the definition of is an index that corresponds to a set such that is not queried for any item in it and she does not get an item from it either.
Hence, by Theorem 5, any matching algorithm has distortion . ∎
For unit-sum valuations, we have the following bound.
Let be a constant. For unit-sum valuation functions, the distortion of any matching algorithm which makes queries per agent is .
Let be the constant used for defining the sets . We will show that for , the following two valuation functions satisfy the unit-sum normalization and are of types (T1) and (T2), respectively. Then, the statement will follow by Theorem 5 by substituting . The functions are defined as
where is a generic index, while in the definition of is an index that corresponds to a set such that is not queried for any item in it and she does not get an item from it either.
First, let us verify that both functions satisfy the unit-sum assumption. By the definition of , we have that for all . Therefore,