On the (in)-approximability of Bayesian Revenue Maximization for a Combinatorial Buyer

07/10/2020 ∙ by Natalie Collina, et al. ∙ Princeton University 0

We consider a revenue-maximizing single seller with m items for sale to a single buyer whose value v(·) for the items is drawn from a known distribution D of support k. A series of works by Cai et al. establishes that when each v(·) in the support of D is additive or unit-demand (or c-demand), the revenue-optimal auction can be found in poly(m,k) time. We show that going barely beyond this, even to matroid-based valuations (a proper subset of Gross Substitutes), results in strong hardness of approximation. Specifically, even on instances with m items and k ≤ m valuations in the support of D, it is not possible to achieve a 1/m^1-ε-approximation for any ε>0 to the revenue-optimal mechanism for matroid-based valuations in (randomized) poly-time unless NP ⊆ RP (note that a 1/k-approximation is trivial). Cai et al.'s main technical contribution is a black-box reduction from revenue maximization for valuations in class 𝒱 to optimizing the difference between two values in class 𝒱. Our main technical contribution is a black-box reduction in the other direction (for a wide class of valuation classes), establishing that their reduction is essentially tight.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

“Multi-dimensional mechanism design” has been a driving force in Mathematical Economics since Myerson’s seminal work Myerson81

, and also in Algorithmic Game Theory since its introduction to TCS by seminal work of Chawla, Hartline, and Kleinberg 

ChawlaHK07. The problem has gained broad interest within TCS owing to the complexity of optimal solutions Thanassoulis04; Pavlov11; BriestCKW10; HartN13; DaskalakisDT15; DaskalakisDT17; HartR15; RubinsteinW15; DaskalakisDT14; ChenDPSY14; ChenDOPSY15. In light of this, there now exists a substantial body of work providing algorithms to find optimal (or approximately optimal) auctions, accepting that the resulting solution may be randomized, non-monotone, or not particularly simple Alaei11; CaiDW12a; CaiDW12b; AlaeiFHHM12; AlaeiFHH13; CaiDW13a; CaiDW13b; DaskalakisW15; DaskalakisDW15.

To properly parse the results of our work, we need to be clear about the input model and objective. The seller has items for sale to a single buyer, and is given as input an explicit finite-support distribution over valuation functions in some class

(given by listing the valuations along with the probability with which they are drawn from

).111We will formally specify in Section 2 how valuation functions are presented as input, but quickly note that all results in this line of work (including ours) are compatible with any standard input format, such as value oracles, demand oracles, or an explicit poly-sized circuit which computes either query. The designer’s goal is to output a description of an auction which (approximately) maximizes expected revenue. The main positive results of these prior works provide poly-time algorithms for the revenue-optimal multi-buyer auction, when all buyers are additive/unit-demand/-demand (which of course imply poly-time algorithms for a single buyer as well, although the single-buyer case does not require many of the developed tools).222A valuation is -demand if . Additive valuations are -demand, and Unit-demand valuations are -demand. CaiDW13b also establishes a hardness result: there exists a constant such that it is not possible to guarantee a -approximation for a single buyer whose valuation is submodular333A function is submodular if for all . in poly-time unless NP RP. Our first main result establishes that revenue-maximization is inapproximable immediately beyond -demand valuations:

Informal Theorem 1 (See Theorem 13).

Unless NP RP, for all , there is no poly-time approximation to the revenue-optimal auction for a single buyer whose values for items are drawn from a distribution of support over matroid-based valuations.444A matroid-based valuation satisfies , where is a matroid.

Importantly, note that a -approximation is trivial, so Theorem 13 rules out essentially any non-trivial approximation. To best understand our proof of Theorem 13, we must first overview the proof approach of CaiDW13b for their positive results. CaiDW13b establishes an approximation-preserving black-box reduction from revenue-maximization when all valuations come from class (refer to this problem as MDMDP(), formal definition in Section 2) to maximizing the difference of two functions in (refer to this problem as ODP(), formal definition in Section 2). For simple classes like additive valuations, ODP is easy, and this yields their positive results. For complex valuation classes like submodular, CaiDW13b establish that ODP is hard, and this intuition drives their inapproximability result.

However, CaiDW13b lacks a formal reduction from ODP to MDMDP. Using intuition that ODP(submodular) is hard, they directly construct hard MDMDP instances. Our next main result is a reduction from ODP to MDMDP. That is, the CaiDW13b reduction is essentially tight.

Informal Theorem 2 (See Theorem 11).

For suitable , there is a black-box reduction from ODP() to MDMDP() which is almost approximation-preserving.

Theorem 11 allows us to reason exclusively about hardness of ODP, and conclude hardness for MDMDP. Our final result provides a clean framework to quickly establish when ODP() is inapproximable, and proves that ODP(matroid-based) is indeed inapproximable (and also that matroid-based is suitable for the reduction in Theorem 11).

1.1. Context and Related Work

The context in which to view our work is the following: CaiDW13b establishes a reduction from MDMDP to ODP, and our Theorem 11 establishes a reduction from ODP to MDMDP, so their reduction is tight. Moreover, ODP is now a simple lens through which one can study (tightly!) the computational complexity of mechanism design — revenue-maximizing Bayesian mechanism design for valuations in class is exactly as hard as maximizing the difference of two functions in (CaiDW13b provides one direction of the reduction, and we provide the other).

Two previous works prove hardness of revenue maximization in this model. As already discussed, CaiDW13b uses intuition from hardness of ODP(submodular) to directly construct hard instances for MDMDP(submodular). They even provide a partial framework for proving similar results (which we overview in Section 2). Our results improve these by replacing submodular with matroid-based (a vastly more restrictive class — it is a proper subset of gross substitutes), and by providing a true reduction from ODP to MDMDP.

The other known hardness result is from DobzinskiFK11, who establish that MDMDP(OXS)555OXS is defined in Section 2. is NP-hard to solve exactly. Their proof does follow a principled framework, and they establish roughly that whenever ODP() is hard to solve exactly, that MDMDP() is hard to solve exactly as well. Their framework, however, is very clearly limited to exact hardness.666This is because their produced MDMDP instances always have support , and it is trivial to get a -approximation on instances of support . Our results improve these by providing an approximation-preserving framework, which allows for hardness of approximation.

There is also a long series of related work in the independent items model ChawlaHK07; ChawlaHMS10; ChawlaMS15; HartN12; LiY13; BabaioffILW14; RubinsteinW15; Yao15; CaiDW16; ChawlaM16; CaiZ17. Here, the distribution is not given explicitly by listing its support, but some form of sample access (or other concise description) is given instead. The restriction is that satisfies “independent items”. We refer the reader to RubinsteinW15 for the general definition, but the example to have in mind is an additive buyer, where independent items simply means that is drawn independently of for all . Observe that inputting such a distribution explicitly in our model would require input of size . So the way to reconcile works such as DaskalakisDT14; ChenDPSY14; ChenDOPSY15 (which prove hardness of exact optimization for a single additive/unit-demand buyer) with folklore LPs (which provide poly-time algorithms for exact optimization for a single additive/unit-demand buyer) is that the hardness results rule out -time solutions, whereas the LPs run in time (which is the size of the support of the distribution). Similarly, the way to reconcile our results (which prove strong hardness of approximation for matroid-based) with RubinsteinW15; ChawlaM16; CaiZ17 (which provides constant-factor approximations for a single subadditive buyer) is that these constant-factor approximations require the independent items assumption.

1.2. Summary and Roadmap

Our main results complete the picture for the CaiDW13b reduction, establishing an approximation-presering reduction from ODP to MDMDP, and moreover that MDMDP is inapproximable within non-trivial factors as soon as we move beyond -demand valuations. Section 2 formally states the problems we study, and recaps prior work CaiDW13b in more detail. Section 3 establishes a clean framework to prove when ODP is inapproximable. Section 4 provides our reduction and concludes with our main theorem statements. The appendix contains all omitted proofs, along with some examples demonstrating interesting facts about some of our tools along the way.

2. Preliminaries

2.1. Valuation Functions and Input

A valuation function takes as input a set of items and outputs a value . Throughout the paper, will denote the “base set” of items (although our reductions will create additional items). For ease of notation, and to help the reader parse parameters, we will w.l.o.g. scale all valuation functions so that for all (this is w.l.o.g. when is rational for all , which is itself w.l.o.g. due to -truthful-to-truthful reductions of, e.g., (RubinsteinW15, Theorem 5.2)). Moreover, all valuations considered in this paper are normalized (), monotone ( for all ), and have no trivial items ( for all ).777We will confirm that no trivial items is w.l.o.g. once we define our formal problems. Finally, when

is a random variable, we will abuse notation and let

. Below are the two main classes of valuations that our main results reference. Appendix E contains definitions of related classes of interest. Note that OXS Matroid-based Gross Substitutes Submodular.

  • [noitemsep]

  • OXS: there is a weighted bipartite graph with nodes on the left and on the right. is the size of the max weight matching using nodes on the left and on the right. When all weights are or , call this binary OXS.

  • Matroid-based: let be independent sets of a matroid on , and be weights for each . Then . When each , call this matroid-rank.

Representing Valuation Functions.

All problems we consider require a valuation function to be “input.” Our theorem statements will be precise about what input models are assumed, although our results hold for most reasonable input models not explicitly discussed.

  • Value oracle: each is given via a black box which takes as input a set and outputs .

  • Demand oracle: each

    is given via a black box which takes as input a vector

    of prices and outputs a set in .

  • Explicit input: each

    is given explicitly via a circuit or Turing machine which takes as input a set

    and outputs . We will only consider succinct representations (that is, circuits/Turing machines which are of polynomial size/runtime for inputs of size ).

2.2. Formal Problem Statements

The first problem we study is simply Bayesian revenue maximization, but we will be precise with how the input is specified to correctly place it with prior work. We use the language of CaiDW13b when possible to draw connections, although we will drop unnecessary parameters.

MDMDP() — Multi-Dimensional Mechanism Design Problem for class :
Input: an explicit distribution over valuation functions in (given by listing all in the support, and the probability with which they are drawn from ).
Output: for each in the support of , a (possibly randomized) set and a price such that for all in the support of .
Objective: maximize , the expected revenue.
Approximation: a solution guarantees an -approximation if .

The lens by which we study MDMDP is the following standard optimization problem.

ODP() — Optimize Difference Problem for class :
Input: two functions and , both in .
Output: a (possibly randomized) set, .
Objective: maximize .
Approximation: a solution guarantees an -approximation if .888Observe above that if both and are subadditive, and , then for all , while for all . Therefore, it is without loss to remove the items in from consideration. Similarly, if , then for all , while for all . Therefore, it is without loss to solve ODP after removing , and then add all items in back at the end. We therefore will pre-process any input to ODP by first finding all items such that and removing them, and all items such that and removing them (to add back later). Therefore, it is indeed w.l.o.g. to assume no trivial sets.999We will also assume w.l.o.g. that there exists an for which . This is without loss because if we have an algorithm which succeeds only on such instances, we can first run this algorithm on an arbitrary instance to get a set , and check if . If so, then output this (and either we were in a case where the algorithm succeeds, or the optimum is and the algorithm succeeds anyway). If not, then output (because would prove that our algorithm failed, and therefore we are in a case where the optimum must be ). So we will also assume this w.l.o.g. for our future reductions.

The final problem we study was introduced by CaiDW13b, and shown to have connections to MDMDP. SADP essentially provides a list of related ODPs, and allows a solution to any of them.

SADP() — Solve Any Differences Problem for class :
Input: a finite list of functions , all in .
Output: a (possibly randomized) set, .
Objective: for some , have maximize .
Approximation: a solution guarantees an -approximation if there exists a such that .

2.3. Recap of CaiDW13b

Finally, we briefly recap the main tools/results from CaiDW13b which are relevant for this paper. Recall that the focus of this paper is on hardness, and we establish our results with just a single buyer. Therefore, we will not recap the results of CaiDW13b in their full multi-buyer generality, but just focus on the single-buyer implications. Below, for any valuation class , denotes its conic closure. That is, denotes the closure of under non-negative linear combinations. Many natural valuation classes (e.g. submodular, XOS, subadditive, additive) are already closed under conic combinations, but others (unit-demand, -demand, OXS, matroid-based, gross substitutes) are not.

Theorem 1 (CaiDW13b).

For all , there is a poly-time, approximation-preserving black-box reduction from MDMDP() to ODP(). That is, an -approximation algorithm for (in any input model) exists using black-box queries to an -approximation algorithm for ODP() (in that same input model), and additional runtime .

For a single buyer, the positive applications of Theorem 1 are not particularly impressive, and imply only that MDMDP can be solved exactly whenever buyers are

-demand (which could alternatively be deduced by a simple linear program) — their main positive results are for multiple buyers. Again, our main result is an approximation-preserving reduction in the other direction, from

ODP to MDMDP.

2.3.1. CaiDW13b’s Hardness of Approximation

As referenced above, CaiDW13b also proves hardness of approximation for MDMDP(submodular). We make use of their machinery, which requires several definitions to precisely state. Without repeating the entire CaiDW13b hardness of approximation, it is perhaps impossible to motivate why these precise definitions are relevant, as they are technical in nature. However, we do give intuition to parse what the definitions are stating, and roughly the role they serve in prior work.

The first definition, Compatibility, is given below. Immediately afterwards, we provide context to help parse the condition.

Definition 1 (Compatibility).

We say that a list of valuation functions and a list of (possibly randomized) sets are compatible if:

  • and are cyclic monotone. That is, the welfare-maximizing matching of valuations to allocations (that is, which maximizes ) is to match to for all .

  • For any , the welfare-maximizing matching of valuations to allocations is to match allocation to valuation for all .

One should parse Compatibility as a stronger condition than cyclic monotonicity (indeed, the first bullet is precisely cyclic monotonicity). Cyclic monotonicity requires that a particular matching on the complete bipartite graph is max-weight. Compatibility requires that a particular matching on several proper subgraphs are also max-weight. Intuitively, the particular restrictions in bullet two assert that higher-indexed allocations are “better”, and higher-index valuations are “more important” (and therefore, the welfare-maximizing allocation always gives “better” allocations to “more important” valuations).

The next technical definition is a restriction on potential inputs to SADP. Intuitively, this condition serves the following purpose: the CaiDW13b reduction from SADP to MDMDP will take an input to SADP, and pass it on to MDMDP, and one part of their proof needs to establish the existence of a high-revenue solution to the produced MDMDP instance (so that any -approximation must also produce high revenue). -compatibility suffices for this (but we will not attempt to explain further why this is the case, and refer the reader to CaiDW13b for more detail).

Definition 2 (-compatible).

A list of valuation functions is -compatible if there exist integers , all at most , and allocations such that:

  • For all , .

  • is compatible with .

The final technical definition in their reduction is balanced-ness. This condition is used in their reduction to guarantee quality of approximation for the original SADP instance. The intuition to have in mind is that when given as input to MDMDP a distribution of support , it is trivial to get a -approximation simply by targeting the valuation in the support which maximizes (and setting price for , and no other options). Put another way, it’s possible to guarantee a (or comparably poor) approximation to MDMDP without engaging with the instance at all. The purpose of their -balanced property guarantees that sufficiently good approximations to the MDMDP instance produced by their reduction must actually engage the initial SADP instance.

Definition 3 (-balanced).

A list of functions is -balanced if for all , .

Following the intuition of the preceding paragraph, -balanced aims to upper bound the revenue a seller could get on a SADP instance by simply selling to and ignoring everything else. With these two definitions, we may state the reduction of CaiDW13b from SADP to MDMDP:101010This is indeed a correct statement of CaiDW13b Theorem 7 after chasing through their SADP choice of parameters.

Theorem 2 (CaiDW13b).

Let be an -approximation algorithm for MDMDP(). Then a solution to any -compatible instance of SADP() can be found in polynomial time plus one black-box call to . The solution has the following properties:

  • (Quality) If the SADP input is -balanced, then the solution is an -approximation.

  • (Complexity) If for all , then for all input to . Moreover, all probabilities input to can be written as the ratio of two integers at most .

The intended application of Theorem 2 is then to find a hard instance of SADP which is (a) -balanced — this guarantees that the resulting guarantee on SADP is close to , and (b) -compatible — this guarantees that the input passed on to MDMDP blows up by only a factor. The appealing feature of Theorem 2 is that it suffices to establish that MDMDP(submodular functions) is inapproximable within any polynomial factor, by directly constructing a hard instance of SADP with valuations which is -balanced and -compatible.

The unappealing feature of Theorem 2 is that SADP is not a particularly natural problem to think about, nor are the compatibility/balanced properties (hence, the need for a substantial preliminary section just to state their result). Additionally, ODP is a very special case of SADP  whose solution suffice for MDMDP  but Theorem 2 only establishes that MDMDP is hard when SADP is hard for large values of .

Our work addresses both shortcomings. Theorem 11 provides a formal statement, which essentially replaces SADP with ODP (truly establishing that the CaiDW13b reduction is tight), and removes any compatibility/balanced requirements on the input instance (allowing greater ease of application to valuation classes significantly more restrictive than submodular).

3. When is Odp Hard?

Before diving into the technical part of our reduction, we’d first like a clean way to reason about valuation classes for which ODP is hard. Becuase ODP has a mixed-sign objective, one naturally expects that it is either solvable exactly in poly-time, or hard to even distinguish whether the optimum is non-zero (although there are sometimes exceptions to this intuition DaskalakisDW15). What’s not immediately clear is how rich needs to be before ODP becomes unsolvable in poly-time (e.g. it is solvable for additive functions, but not for submodular, what about in between?). In this section, we show that even ODP(binary OXS) is inapproximable. We begin with a general construction of hard instances:

Definition 4 (Perturbable).

For , define if , and . Class is -perturbable if there exists a such that for distinct , and .

is efficiently -perturbable if further there is a computationally-efficient bijection from the sets to , and there is a poly-sized circuit/poly-time Turing machine which computes .

The parameter will not be used in this section, and is not necessary to establish when ODP is hard, but we will need to reference the parameter in the technical parts of our reduction. Lemma 3 establishes that ODP is hard for highly-perturbable (-perturbable for large ) classes. Intuitively, this is because the ODP instances of the form each have disjoint solutions, but are hard to distinguish. Proofs of the following two lemmas appear in Appendix A.

Lemma 3.

Let be -perturbable. Then any value- or demand-oracle algorithm for ODP() which guarantees an -approximation for any with probability makes queries.

If is efficiently -perturbable for , then no randomized, poly-time algorithm for explicit input guarantees an -approximation for any w.p. , unless NP RP.

Lemma 4.

Binary OXS is efficiently -perturbable.111111So every superclass of Binary OXS (including Matroid-based) is efficiently -perturbable as well.

Lemmas 3 and 4 together immediately conclude that ODP(Binary OXS) is inapproximable within any non-zero factor with value or demand queries, or within poly-time unless NP RP.

4. From Odp to Sadp

Now that we know ODP is hard even for fairly basic combinatorial valuations, we wish to leverage this to establish that the particular SADP instances needed for Theorem 2 are also hard. Again, the goal of this section is to provide a reduction from ODP to SADP, while also chasing through the parameters it implies for a full reduction from ODP to MDMDP. Before providing our reduction, let’s get some intuition for the main challenges through some simple failed attempts. Recall that an approximation for MDMDP implies an approximation for SADP. We want this to be as close to as possible, so the properties we care about are:

  • How balanced is the resulting SADP instance? (Smaller is better).

  • How many functions are input to the SADP instance? (Larger is better).

  • Is the instance -compatible? (Necessary for the reduction to be valid — otherwise it will produce inputs to MDMDP of super-polynomial size).

Failed Attempt 1. The obvious first attempt is to just observe that ODP is a special case of SADP and simply “reduce” from ODP to SADP by copying the original instance itself into Theorem 2. This reduction is clearly correct, but let’s examine what parameters we get from this reduction, using our -perturbable as a representative instance:

  • In that construction, , and , so it is -balanced.

  • There are two functions input to ODP, so .

From above, . So even if the instance were -compatible, an -approximation for MDMDP wouldn’t even imply a non-trivial guarantee for any . Recall again the intuition for this: in the CaiDW13b reduction, will be the size of the support of the produced for MDMDP. If , it’s trivial to get a -approximation without engaging SADP at all. So in order to get stronger hardness of approximation, we need much larger .

Failed Attempt 2. Here is a next attempt, which takes as large as desired. Let be the given ODP instance, and define . Observe that for any , , so every consecutive difference is solving exactly the ODP instance we care about, and an -approximation for this SADP() will indeed yield an -approximation for ODP(). Let’s check the parameters when we apply Theorem 2 with our hard ODP instance:

  • , and our . Also, , so for all , and the instance is -balanced.

  • We can set as we please.

Again, even if the instance were -compatible, an -approximation for MDMDP still wouldn’t imply non-trivial guarantees for any (because still ). What we learn from these first two failed attempts is that we need to somehow let be large in our construction (have many functions), while simultaneously not letting grow too big.

Failed Attempt 3. Our final failed attempt will also demonstrate one of our key insights: introduce extra items in the SADP instance. Specifically (for this construction), if we are initially given an ODP instance on items, and wish to produce a SADP instance with valuation functions, add an additional items. Call the initial items and the additional items . For any set , write it as (where ).121212As , . We use the disjoint union notation here (and in several other places) to remind the reader that these sets are always disjoint. Define to be equal to if and only if , and if and only if (note that this is a somewhat bizarre valuation function, which essentially treats the items in as a bit to decide whether the items in are valued using or ). It is not hard to see that any -approximation on this SADP instance implies an -approximation on our desired ODP instance. Let’s again compute the parameters of the reduction for our hard ODP instance.

  • , and our . Also, it is not hard to see that for a given , . So the instance is -balanced.

  • We can set as we please.

Now, we’re in good shape with parameters: we could (for example) set for any constant , and establish that any -approximation for MDMDP instances with items implies a -approximation for ODP on items, which we ruled out in Section 3. The catch is that our produced SADP instance has bizarre valuation functions. So all we have done is shown that MDMDP(bizarre valuation class) is hard.

4.1. Our Reduction

The previous examples illustrate the reasoning one needs to go through to analyze a reduction, and also identify some of the technical challenges. The two main (good) ideas we saw from the failed attempts were (a) introducing extra items and (b) “truncating” the valuations in a way that let grow large while keeping small. The challenge we did not yet overcome was how to do this in a way that preserves membership in interesting valuation classes, and we did not attempt to address Compatibility. We’ll present our construction in two steps. The first adds additional items, but does not yet truncate.

Reduction Step One: Scaled Disjoint Unions.
Input: , both in (input to ODP()), (desired number of valuations for SADP).
Output: . Each takes as input subsets of items. Partition these items into , with each . For any , write it as (with each ). Define .

That is, we make copies of the items, have each behave either as or (scaled) on each copy, and then sum them. Observe that switches from to exactly at copy , and that each is a disjoint union of valuations in , formally defined below. This operation happens to preserve membership in the valuation classes we care about.

For scaling, observe that all classes we consider except for Binary OXS and matroid-rank (because they insist on binary values) are closed under non-negative scaling. The scaling in each partition will not become relevant until the very end when we need to prove that the produced instance is -compatible.

Definition 5 (Disjoint Union of Valuations).

The disjoint union of two valuations and each on items creates two copies , and outputs a valuation such that .

Fact 1.

Additive, Binary OXS, OXS, Matroid-rank, Matroid-Based, Gross Substitutes, Submodular, XOS, and Subadditive valuations are closed under Disjoint Union. Unit-demand/-demand are not.

So we’re in good shape so far in the sense that if we start with (say) matroid-based valuations in our ODP instance, we get back matroid-based valuations in our SADP instance. But we have not yet made any progress towards bounding the balanced-ness. Our next step is to properly truncate the valuations to make the valuations more balanced. We define two truncations below, which may inspire different related work. However, only Item Truncation is necessary for our main result, so we will focus the remaining presentation and formal statements on Item Truncation.

Reduction Step Two: Item Truncation.
Input: , a valuation function and , a desired truncation.
Output: , defined so that .

Alternate Reduction Step Two: Value Truncation.
Input: , a valuation function and , a desired truncation.
Output: , defined so that .

We prove in Appendix B that matroid-based valuations are closed under item truncation, as this is the class/truncation we’ll use for our main results. We state afterwards which other classes are closed under each truncation (proofs omitted, as we will not use these results elsewhere).

Lemma 5.

The class of matroid-rank valuations is closed under item truncation for any .

Fact 2.

Unit-demand, Submodular, XOS, and Subadditive are closed under value truncation for all . Additive, -demand, Binary OXS, OXS, Matroid-rank, Matroid-based, Gross Substitutes are not (there exist , and a function in each of these classes for which value-truncating at is no longer in that class).

Fact 3.

Unit-demand, Matroid-rank, Gross Substitutes, XOS, and Subadditive are closed under item truncation for all .131313Of these, the claim for Gross Substitutes (like most properties of Gross Substitutes) is non-trivial to establish, and uses the fact that Gross Substitutes functions are well-layered Leme17. Additive, -demand, Binary OXS, OXS, and Submodular are not.

Again, recall that Lemma 5 is all that’s necessary for our main results (as hardness for matroid-rank implies hardness for all superclasses). Facts 2 and 3 are included for the sake of better understanding the truncation operations. One curious conclusion of Fact 3 is that the property of being closed under item-truncation “skips” submodular functions. Note also that value-truncation preserves submodularity but not Gross Substiutes, whereas item-truncation preserves Gross Substitutes but not submodularity.

4.2. Correctness, Balancedness, and Compatibility

Now, we want to establish that our reduction correctly solves the initial ODP instance, and also examine the parameters of the produced SADP instance. Our full reduction takes an ODP instance and first puts it through the Scaled Disjoint Union reduction with parameter to get valuations each on items. Then, it puts each of these valuations through item truncation with parameter . For a given ODP instance , call the resulting SADP instance . Appendix B contains a proof of Lemma 6, and Appendix C contains analogous claims for value truncation.

Lemma 6.

Let be an -approximation to the SADP instance . Then with an additional runtime/value queries (to the item-truncated values), an -approximation to the ODP instance can be found.

Next, we want to see how well-balanced the instance is. Importantly, observe that the bound in Lemma 7 does not grow with .

Lemma 7.

For any ODP instance , the instance is -balanced.

So at this point we have a reduction from ODP to very balanced instances of SADP, which also preserve valuation class membership for matroid-based valuation functions. Our last steps are to ensure that we can indeed compute value queries for our generated functions, and also to ensure that the resulting instance is -compatible. Lemma 8 below is necessary for the following reason: Lemma 6 requires value queries on values generated for . However, our input to ODP only provides access to , which may not suffice for this.

Definition 6.

Say that a list of valuation functions is query-sufficient for a list if (a) it is possible to execute value queries for every function in using polynomially-many value queries for functions in and (b) it is possible to write succinct circuits/Turing machines to compute value queries for every function in using succinct circuits/Turing machines computing value queries for every function in .

Matroid-based , due to connections with greedy algorithms, are indeed query-sufficient.

Lemma 8.

When are matroid-based, are query-sufficient for .

Lemma 8 confirms that if our ODP instance is given via explicit input or value queries, then this is enough to simulate value queries on each we construct. The last step is compatibility. We’ll begin with a general sufficient condition for an instance to be Compatible, and finally establish that our instances satisfy this condition.

Lemma 9.

Let be such that there exists allocations satisfying:

  1. For all , .

  2. for all .

  3. , for all .

Then is -Compatible.

Our last step is to establish that our instance satisfies the hypotheses of Lemma 9.

Corollary 10.

is -Compatible.

4.3. Putting Everything Together

With all the pieces now in place, we can now prove Theorem 11. We briefly note that Theorem 11 also holds after replacing item truncation with value truncation (and the proof simply replaces Lemma 6 with Lemma 14).

Theorem 11.

Let be closed under non-negative scaling, disjoint union, and item truncation, and let be query-sufficient for whenever . Let also be an -approximation algorithm for MDMDP() using either value oracles or explicit input. Then for any integer , given black-box access , there is a -time algorithm for ODP() making a single black-box call to plus an additional value queries to the ODP input with the following properties:

  • (Quality) On ODP input , the algorithm produces an -approximation.

  • (Complexity) Each value input to takes as input subsets of , and satisfies . Moreover, all probabilities input to can be written as the ratio of two integers at most .

Proof.

To complete the proof, we just need to carefully track all the pieces we put together. The fact that is closed under non-negative scaling, disjoint union, and item truncation guarantees that will only contain valuations in (they will also take as input subsets of ). By Lemma 6, any -approximation to the SADP instance yields an -approximation to the ODP instance (in poly-time, because is query-sufficient for ). So our goal is to solve the SADP instance , which is an instance of SADP().

Lemma 7 establishes that is -balanced, and Corollary 10 establishes that is -Compatible. Therefore, we can solve the SADP instance using Theorem 2, and the approximation/complexity guarantees match up. ∎

We can now apply Theorem 11 to establish that MDMDP() is hard for perturbable .

Theorem 12.

Let be closed under non-negative scaling, disjoint union, and item truncation, and let be query-sufficient for whenever .

  • For any integer , if is -perturbable, then no better than a -approximation for MDMDP() can be guaranteed with probability on instances with items with fewer than queries the value oracle model.141414Observe that because of the , this result only has bite when .

  • For any , if is efficiently -perturbable for , then no better than a -approximation for MDMDP() can be guaranteed with probability on instances with items in the explicit input model, unless NP RP.

Theorem 12 implies that MDMDP(matroid-based) is inapproximable within non-trivial factors.

Theorem 13.

For all , there does not exist an algorithm making value queries in the value oracle model, demand queries in the demand oracle model, or a poly-time algorithm in the explicit input model (unless NP RP) guaranteeing an -approximation with probability at least for MDMDP(matroid-based) on instances with items and values in the support of .

References

Appendix A Omitted Proofs from Section 3

Proof of Lemma 3.

Let witness that is -perturbable, and consider being given the ODP input , for some such that chosen uniformly at random. Then is the unique optimum, and the only set which guarantees an -approximation for any . First consider any (randomized) value-oracle algorithm which makes at most queries. Using the principle of deferred decisions, first select the (random) prices to query conditioned on all previous responses being consistent with . Then as only one possible query () will be inconsistent with , and is chosen uniformly at random, we have that except with probability , all queries are consistent with . When all queries are consistent with , the algorithm must make some guess, which will be correct with probability at most . So the total success probability is at most . Setting has this always at most .

Next, consider (randomized) demand-oracle algorithms which make at most queries. Observe first that the only difference between a demand query for and a demand query for can come on a vector of prices for which the demand query for on outputs (this is because if any set is ’s favorite, it is certainly ’s favorite. But if is ’s favorite, it may not be ’s favorite). So again use the principle of deferred decisions, and select the (random) sets to query conditioned on all previous responses being consistent with . Then for each query made, there is at most one for which might have output something different. Therefore, except with probability , all queries are consistent with . Again, the algorithm’s total success probability is therefore at most .

To see the final claim in the explicit input model, we develop a reduction from unique-SAT (3-SAT where the promise is that there is exactly one or zero satisfying assignments). Given an instance of 3-SAT, consider a circuit/Turing machine which takes as input an assignment and outputs yes if that assignment is satisfying (so the circuit would be poly-sized, and the Turing machine would run in poly-time). Define now a circuit/Turing machine for a valuation fuction which takes as input a set and outputs if is not one of the perturbing sets. Otherwise, first map to , and then take the corresponding assignment . If satisfies , output . Otherwise, output . Note that this entire procedure is computationally-efficient/can be done with a poly-sized circuit because is efficiently perturbable.

Now, assume for contradiction that there is a randomized algorithm for ODP() which guarantees a non-zero approximation with probably at least . Given an instance of unique-SAT, run the algorithm on , and let denote the output set. Observe that by the unique-SAT promise, . Check if the assignment corresponding to satisfies , and if so, output “yes” (otherwise, output “no”). This algorithm will clearly never mistakenly guess that is satisfiable. To see that it correctly says yes with probability at least (which, as usual, can be amplified to or if desired), observe that whenever is satisfiable uniquely by , that the set corresponding to is the only set guaranteeing an -approximation for any . Therefore, this set must be output with probability at least by our algorithm, implying that we will output (and correctly guess yes) with probability at least . But no such algorithm for unique-SAT can exist unless NP RP. ∎

Proof of Lemma 4.

Consider the complete bipartite graph with item nodes on the left and nodes on the right. Let denote the binary OXS valuation corresponding to this graph. Then , and is efficiently computable. Observe also that if we pick any set of size and remove all edges from each left-hand node in to (say) the top right-hand node (so we remove a total of edges), then we still have a binary OXS function. Moreover, we claim that this function is now for the removed .

Indeed, observe that for any set of size , there is still a perfect matching from to the RHS, so we’ll still have . For any set of size , perhaps . If so, then clearly the max-weight matching has size , as desired. Otherwise, contains an element not in , which has an edge to the top node. There are at least left-hand nodes remaining, which have edges to every other right-hand node, and therefore form a matching of size , for a total matching of .

Therefore, can be perturbed at any set of size . We can index these sets lexicographically to get an efficient mapping from these sets to , as desired. ∎

Appendix B Omitted Proofs from Section 4

Proof of Lemma 5.

To see the claim, consider the independent sets for the matroid defining . It is well-known that updating results in being a matroid.151515This is also easy to check: Clearly is downwards closed. For any two independent sets in , with , the fact that satisfies the augmentation property immediately implies that there exists such that . As , as well, so has the augmentation property too. It is now easy to see that item-truncated at is exactly the matroid-based valuation corresponding to (with the exact same weights for all items ), so it is matroid-based as well. ∎

Proof of Lemma 6.

Throughout the proof, we’ll let denote one copy of the original items, denote the copy, and use variables to denote subsets of , and variables to denote subsets of .

Let denote the approximation to the SADP instance . First, we wish to refine so that , but it is still an -approximation. To do this, observe that if then we are done. Otherwise, for each there is a subset with and . To find this , go through each item one-by-one and check whether . If so, remove and continue (because there is still a set of size inside with ). If not, we know that every such must contain , so keep it. Stop when . Observe that this procedure must terminate, because any will be removed when processed (and that it can be implemented with only value queries to ).

Do the above process for each , to get candidate sets , each of size at most . Next, simply output as the solution to the ODP instance . We claim this must be an -approximation.

Consider first the solution , and the index for which . First, obesrve that indeed . This is because one candidate for is to set , and for all (which results in exactly this difference). So we may now conclude that:

Next, we claim that we must have . This is simply because , but by definition. Therefore, we get:

Finally, observe that , so we know that:

Therefore, we may conclude further that:

The output of our algorithm is at least as good as , because we take the maximum of this over all potential , so we get an -approximation. ∎

Proof of Lemma 7.

No matter how large is, any set with items can get value from at most copies of . Within each copy, the maximum possible is , so the total value for any set is at msot . Also, for all , . So the instance is -balanced. ∎

Proof of Lemma 8.

The challenge is that, when , it’s not clear how to find the best of size . Indeed, it is not necessarily possible in poly-time when are submodular, and therefore some assumption on valuation classes is necessary.

But when are matroid-based, recall that each is matroid-based as well. This suggests that a greedy algorithm can find the best of size . Indeed, the following algorithm works:

  1. For each , find . This can be done with a single value query to either or .

  2. Sort the elements in in decreasing order of .

  3. Initialize .

  4. Process elements one at a time.

    1. If , stop.

    2. Else, compute . This can be done with two queries to either or because .

    3. If , add to . Otherwise, don’t.

  5. Output .

The algorithm above finds the max-weight independent subset of , for the matroid defining the matroid-based valuation , and the correct weights. Therefore, it correctly computes . ∎

Proof of Lemma 9.

Consider the given allocations and the multipliers . Observe first that all multipliers are integers at most , as desired. Also, we are already given that for all . So we just need to establish that is compatible with .

First, let’s establish that and are cyclic monotone. We proceed inductively from down to and prove that must be matched to . Assume for inductive hypothesis that the max-weight matching must match to for all and consider now . Then consider the weight contributed by the edge between and , versus and any , . By property 3, the former edge contributes at least more than any other potential edge. At the same time, by property 2, the maximum possible contribution from all edges is at most . Therefore, the maximum possible weight we can get from edges not adjacent to is less than what we lose by not matching to , and the max-weight matching must match to .

A nearly-identical argument establishes that the max-weight matching of valuations to allocations is to match to for all . Again proceed inductively from down to , and assume for inductive hypothesis that the max-weight matching must match to for all . Consider again the weight contributed by the edge between and versus and any , . By property 3, the former edge contributes at least more than any other potential edge. At the same time, by property 2, the maximum possible contribution from all edges is at most . Therefore, the maximum possible weight we can get from edges not adjacent to is less than what we lose by not matching to , and the max-weight matching must match to .

This completes the proof that is -Compatible. ∎

Proof of Corollary 10.

Consider the allocations defined so that , and for all . Then we clearly satisfy hypothesis 1 in Lemma 9. To see this, recall that for any set , , and is the optimal set contained in .

Hypothesis 2 is also clearly satisfied for . This follows because for all .

Hypothesis 3 is satisfied for the following reasons. First, let . We know that . We also know that , and for all . As , we Hypothesis 3 holds as well.

By Lemma 9, we may conclude that