Towards More Practical Linear Programming-based Techniques for Algorithmic Mechanism Design

R. Lavy and C. Swamy (FOCS 2005, J. ACM 2011) introduced a general method for obtaining truthful-in-expectation mechanisms from linear programming based approximation algorithms. Due to the use of the Ellipsoid method, a direct implementation of the method is unlikely to be efficient in practice. We propose to use the much simpler and usually faster multiplicative weights update method instead. The simplification comes at the cost of slightly weaker approximation and truthfulness guarantees.


Introduction
Algorithmic mechanism design is the art of designing and implementing the rules of a game to achieve a desired outcome from a set of possible outcomes. Each player (agent) has a valuation that assigns a value to each possible outcome. The desired outcome is the one that maximizes the sum of the valuations; this sum is usually called social welfare. The players are assumed to be selfish: they report valuations to the mechanism, which may differ from the true valuations. Players may lie about their valuations in order to direct the mechanism into an outcome favorable to them. The mechanism computes an outcome and payments for the players. The utility of a player is her/his value of the outcome computed by the mechanism minus her/his payment charged by the mechanism. The agents are interested in optimizing their personal utility. Social welfare and personal utilities are determined with respect to the true valuations of the players, although they are not public knowledge. The purpose of the payments is to incentivize the players to report their true valuations. A mechanism is truthful if reporting the truth is a best strategy for each player irrespective of the inputs provided by the other players. A mechanism is efficient if the outcome and the payments can be computed in polynomial time. The underlying optimization problem is the computation of an outcome maximizing social welfare given the valutions of the players.
If the underlying optimization problem can be efficiently solved to optimality, the celebrated VCG mechanism (see, e.g., [NRTV07]) achieves truthfulness, social welfare optimization, and polynomial running time. The computation of the outcome and the computation of the payments requires to solve the underlying optimization problem to optimality.
Many optimization problems are NP-hard and hence are unlikely to have an exact algorithm with polynomial running time. However, it might be possible to solve the problem approximately in polynomial running time.
An example is the combinatorial auction problem. There is a set of m items to be sold to a set of n players. The (reported) value of a set S of items to the i-th player is v i (S) with v i (∅) = 0 and v i (S) ≤ v i (T ) whenever S ⊆ T . Let x i,S be a 0-1 variable indicating that set S is given to player i. Then S x i,S ≤ 1 for every player i as at most one set can be given to i, and i S;j∈S x i,S ≤ 1 for every item j as any item can be given away only once. The social welfare is i,S v i (S)x i,S . The linear programming relaxation is obtained by replacing the integrality constraints for x i,s by 0 ≤ x i,S ≤ 1. Note that the number d of variables is exponential in the number of items, namely d = n2 m . The linear program is of the packing type, i.e., if x is feasible and y ≤ x, then y is feasible. For the combinatorial auction problem, O( √ n)-approximation algorithms exist and these ⋆ A preliminary version of these results was presented at SAGT 2015 [EMR15].
algorithms also provide the corresponding integrality-gap-verifier (the definition is given below) with α = 1/ √ n ([BKV05, KS98,Rag88]). For many integer linear programming problems, approximation algorithms are known that first solve the corresponding linear programming relaxation and then construct an integral solution either by rounding or by primal-dual methods. Lavi and Swamy ( [LS05,LS11]) showed that certain linear programming based approximation algorithms for the social welfare problem can be turned into randomized mechanisms that are truthful-in-expectation, i.e., reporting the truth maximizes the expected utility of a player. The LS-mechanism is powerful (see [LS05,LS11,CEF10,HKV11] for applications), but unlikely to be efficient in practice because of its use of the Ellipsoid method. We show how to use the multiplicative weights update method instead. This results in simpler algorithms at the cost of somewhat weaker approximation and truthfulness guarantees.
We next review the LS-mechanism. It applies to integer linear programming problems of the packing type for which the linear programming relaxation can be solved exactly and for which an α-integrality gap verifier is available. More precisely: ≥0 be a packing polytope, i.e., Q is a bounded convex polytope contained in the non-negative orthant of d-dimensional space with the property that if y ∈ Q and x ≤ y then x ∈ Q. The linear programming problem for Q asks to find for a given d-dimensional vector v a point x * = argmax x∈Q v T x. 2. We use Q I := Q ∩ Z d for the set of integral points in Q. The integer linear programming problem for Q I asks to find for a given d-dimensional vector v a point x * = argmax x∈QI v T x.
We use x 1 , x 2 , . . . , x j , . . . to denote the elements of Q I and N for the index set of all elements in Q I . 3. An α-integrality-gap-verifier for Q I for some α ∈ (0, 1] is an efficient algorithm that on input v ∈ R d and x * ∈ Q, returns an x ∈ Q I such that The mechanism consists of three main steps: be the reported valuation of the i-th player and let v = i v i be the accumulated reported valuation. Solve the LP-relaxation, i.e., find a maximizer x * = argmax x∈Q v T x for the social welfare of the fractional problem, and determine the VCG prices 4 p 1 , . . . , p n . The allocation x * and the VCG-prices are a truthful mechanism for the fractional problem. 2. Write α · x * as a convex combination of integral solutions in Q, i.e., α · x * = j∈N λ j x j , λ j ≥ 0, j∈N λ j = 1, and x j ∈ Q I . This step requires the α-integrality-gap-verifier.
3. Pick the integral solution x j with probability λ j , and charge the i-th player the price The LS-mechanism approximates social welfare with factor α (is α-socially efficient ) and guarantees truthfulness-in-expectation, i.e., it converts a truthful fractional mechanism into an αapproximate truthful-in-expectation integral mechanism. With respect to practical applicability, steps 1 and 2 are the two major bottlenecks.
Step 1 requires solving n + 1 linear programs, one for the fractional solution and one for each price; an exact solution requires the use of the Ellipsoid method (see e.g. [GLS88]), if the dimension is exponential. Furthermore, up to recently, the only method known to perform the decomposition in Step 2 is through the Ellipsoid method. An alternative method avoiding the use of the Ellipsoid method was recently given by Kraft, Fadaei, and Bichler [KFB14]. We comment on their result in the next section.

Our Results
Our result concerns the design and analysis of a practical algorithm for the LS-scheme. We first consider the case where the LP-relaxation of SWM (social welfare maximization) in Step 1 of the LS-scheme can be solved exactly and efficiently and then our problem reduces to the design of a practical algorithm for Step 2. Afterwards, we consider the more general problem where only an FPTAS for the LP-relaxation is available.
Convex Decomposition. Over the past 15 years, simple and fast methods have been developed for solving packing and covering linear programs [BI06,GK95,GK07,Kha04,KY07,PST91,You01] within an arbitrarily small error guarantee ε. These methods are based on the multiplicative weights update (MWU) method [AHK12], in which a very simple update rule is repeatedly performed until a near-optimal solution is obtained. We show how to replace the use of the Ellipsoid method in Step 2 by an approximation algorithm for covering linear programs. This result is the topic of Section 2.
Theorem 1. Let ε > 0 be arbitrary. Given a fractional point x * ∈ Q, and an α-integrality-gap verifier for Q I , we can find a convex decomposition The convex decomposition has size (= number of nonzero λ j ) at most s(1 + ⌈ε −2 ln s⌉), where s is the size of the support of x * (= number of nonzero components). The algorithm makes at most s⌈ε −2 ln s⌉ calls to the integrality-gap-verifier.
Kraft, Fadaei, and Bichler [KFB14] obtained a related result independently. However, their construction is less efficient in two aspects. First, it requires O(s 2 ε −2 ) calls of the integrality-gapverifyer. Second, the size of their convex decomposition might be as large as O(s 3 ε −2 ). In the combinatorial auction problem, s = n + m. Theorem 1 together with Steps 1 and 3 of the LS scheme implies a mechanism that is truthful-in-expectation and has (α/(1 + 4ε))-social efficiency. We leave it as an open problem whether the quadratic dependency of the size of the decomposition on ε can be improved 5 .
Approximately Truthful-in-Expectation Mechanism. We drop the assumption that the fractional SWM-problem can be solved optimally and assume instead that we have an FPTAS for it. We assume further that the problem is separable, which means that the variables can be partitioned into disjoint groups, one for each player, such that the value of an allocation for a player depends only on the variables in his group, i.e, where x i is the set of variables associated 6 with player i. Formally, any outcome x ∈ Q ⊆ R d can be written as x = (x 1 , . . . , x n ) where x i ∈ R di and d = d 1 + . . . + d n . We further assume that for each player i ∈ [n], there is a dominating allocation u i ∈ Q that maximizes his value for every for every v i ∈ V i , where V i denotes the possible valuations of player i. For the case of a combinatorial auction, the allocation u i allocates all items to player i.
Assuming that the fractional SWM-problem has an FPTAS, is separable, and has a dominant allocation for every player i, and that there is an α-integrality gap verifier for Q I , there is a polynomial time randomized integral mechanism with the following properties: 5 We remark that recent progress [ZO15,WRM15] on solving LPs of the packing/covering type has resulted in an almost linear dependence of the running time on 1 ε . However, the current methods do not work in the oracle model and hence cannot be directly applied in our setting. 6 In the combinatorial auction problem, xi comprises all variables xi,S. The value of an allocation x for player i is given by S vi(S)xi,S.
Our mechanism is based on constructing a randomized fractional mechanism with properties (C1) to (C3) and being (1 − ε)(1 − ε 0 )-socially efficient and then converting the mechanism into an integral mechanism with the properties above. The conversion is simple. Let us assume that x is a fractional allocation obtained from the fractional mechanism. We apply our convex decomposition technique and Step 3 of the Lavi-Swamy mechanism to obtain an integral randomized mechanism that satisfies (C1) to (C4).We show this result in Section 3.
Our fractional mechanism refines the one given in [DRVY11], where the dependency of ε on n and ε 0 is as ε = Θ(ε 0 /n 9 ). A recent experimental study of our mechanism on Display Ad Auctions [EJ15] shows the applicability of our techniques in practice.
We leave it as an open problem whether the dependency of ε on ε 0 and n can be improved.
On the Existence of an FPTAS for the Fractional SWM-Problem. We close the survey of our results with a comment on the existence of an FPTAS for the fractional SWM-problem. Consider a packing linear program is an m × n matrix with non-negative entries and c ∈ R n >0 , b ∈ R m >0 are positive vectors. We may assume that each column of A contains a non-zero entry as otherwise the problem is trivially unbounded. For every κ ≥ 1 and weight vector z ∈ R m ≥0 , let O κ (z) denote a κ-approximation oracle that returns a j such that Garg and Könemann [GK07] presented an algorithm that uses the oracle O κ to construct an approximation with a factor arbitrarily close to 1/κ. For κ = 1, their algorithm is an FPTAS. What is the approximation oracle in case of the combinatorial auction problem? In this problem, we have one constraint for each player and one constraint for each item. Let y i ≥ 0 be the weight for agent i and z j ≥ 0 be the weight for item j. Then oracle O 1 (y, z) requires to find the pair In other words, for each k, one needs to find the set T which minimizes (y k + j∈T z j )/v k (T ). If y k is interpreted as a fixed cost incurred by agent k and z j as the cost of item j, then T is the set that minimizes the ratio of cost relative to value. For a simple-minded bidder who is interested in the items in a subset T 0 and no other item, i.e., v k (T ) = v k (T 0 ) if T 0 ⊆ T and v k (T ) = 0, otherwise, T 0 is the minimizer. Another simple case is additive valuations, i.e., v k (T ) = j∈T a k j , where a k j ≥ 0 is the value of item j for agent k. In this situation, 1 v k (T ) y k + j∈T z j ≤ β for a set T and a positive real β if and only if j∈T (βa k j − z j ) ≥ y k and hence the minimal β for which such a set T exists is readily determined by binary search on β.

A Fast Algorithm for Convex Decompositions
Let x * ∈ Q be arbitrary. Carr and Vempala [CV02] showed how to construct a convex combination of points in Q I dominating αx * using a polynomial number of calls to an α-integrality-gap-verifier for Q I . Lavi and Swamy [LS11] modified the construction to get an exact convex decomposition αx * = i∈N λ i x i for the case of packing linear programs. The construction uses the Ellipsoid method. We show an approximate version that replaces the use of the Ellipsoid method by the multiplicative weights update (MWU) method. For any ε > 0, we show how to obtain a convex decomposition of αx * /(1 + ε). Let s be the number of non-zero components of x * . The size of the decomposition and the number of calls to the α-integrality gap verifier are O(sε −2 ln s).
This section is structured as follows. We first review Khandekar's FPTAS for covering linear programs (Subsection 2.1). We then use it and the α-integrality gap verifier to construct, on input x * ∈ Q, a dominating convex combination for αx * /(1 + 4ε) (Subsection 2.2). In Subsection 2.3, we show how to convert a dominating convex combination into an exact convex decomposition. Finally, in Subsection 2.4, we put the pieces together.

Khandekar's Algorithm for Covering Linear Programs
Consider a covering linear program: is an m × n matrix with non-negative entries and c ∈ R n ≥0 and b ∈ R m ≥0 are non-negative vectors. We assume the availability of a κ-approximation oracle for some κ ∈ (0, 1]. For an exact oracle κ = 1, Khandekar [Kha04] gave an algorithm which computes a feasible solutionx to (2) such that c Tx ≤ (1 + 4ε)z * where z * is the value of an optimal solution. The algorithm makes O(mε −2 log m) calls to the oracle, where m is the number of rows in A. There are algorithms predating Khandekar's work, see, for example, [K97,Chapter 4] Theorem 3 (Generalization of Khandekar's algorithm to arbitrary κ ≤ 1). Let ε ∈ (0, 1 2 ] and let z * be the value of an optimum solution to (2). Procedure Covering(O κ ) (see Algorithm 3 in Appendix I) terminates in at most m⌈ε −2 ln m⌉ iterations with a feasible solutionx of (2) of at most m⌈ε −2 ln m⌉ positive components. At termination, it holds that For completeness, we give a proof of Khandekar's result in Appendix I. The proof of Theorem 3 can be modified to give (see Appendix I): Corollary 1. Suppose b = 1, c = 1, and we use the following oracle O ′ instead of O in Algorithm 3: ≥0 , such that 1 T z = 1, the oracle finds a column j of A such that z T A1 j ≥ 1.
Then the algorithm terminates in at most m⌈ε −2 ln m⌉ iterations with a feasible solutionx having at most m⌈ε −2 ln m⌉ positive components, such that 1 Tx ≤ 1 + 4ε.

Finding a Dominating Convex Combination
Recall that we use N to index the elements in Q I . We assume the availability of an α-integralitygap-verifier F for Q I . We will use the results of the preceding section and show how to obtain for any x * ∈ Q and any positive ε a convex composition of points in Q I that covers αx * /(1 + 4ε). Our algorithm requires O(sε −2 ln s) calls to the oracle, where s is size of the support of x * .
Theorem 4. Let ε > 0 be arbitrary. Given a fractional point x * ∈ Q and an α-integrality-gap verifier F for Q I , we can find a convex combinationx of integral points in Q I such that The convex decomposition has size at most s⌈ε −2 ln s⌉, where s is the number of positive entries of x * . The algorithm makes at most s⌈ε −2 ln s⌉ calls to the integrality-gap verifier.
Proof. The task of finding the multipliers λ i is naturally formulated as a covering LP ( [CV02]), namely, Clearly, we can restrict our attention to the j ∈ S + := {j : x * j > 0} and rewrite the constraint for j ∈ S + as i∈N λ i x i j /(α ·x * j ) ≥ 1. For simplicity of notation, we assume S + = [1..s]. We thus have a covering linear program as in (2) with m := s + 1 constraints, n := |N | variables λ i , right-hand side b := 1, cost vector c := 1, and constraint matrix A = (a j,i ) (note that we use j for the row index and i for the column index), where Thus we can apply Corollary 1 of Section 2.1, provided we can efficiently implement the required oracle O ′ . We do so using F .
Oracle O ′ has is given az) such that 1 Tz = 1. Let us conveniently writez = (w, z), where w ∈ R s ≥0 , z ∈ R ≥0 , and j=1 j=s w j + z = 1. Oracle O ′ needs to find a column i such thatz T A1 i ≥ 1. In our casez T A1 i = s j=1 w j x i j /αx * j + z, and we need to find a column i for which this expression is at least one. Since z does not depend on i, we concentrate on the first term. Define otherwise.
Call algorithm F with x * ∈ Q and V := (V 1 , . . .). F returns an integer solution x i ∈ Q I such that and hence, Thus i is the desired column of A. It follows by Corollary 1 that Algorithm 3 finds a feasible solution λ ′ ∈ R |N | ≥0 to the covering LP (4), and a set Q ′ I ⊆ Q I of vectors (returned by F ), such that λ ′ i > 0 only for i ∈ N ′ , where N ′ is the index set returned by oracle O ′ and |N ′ | ≤ s⌈ε −2 ln s⌉. Also Λ := i∈N ′ λ ′ i ≤ (1 + 4ε). Scaling λ ′ i by Λ, we obtain a set of multipliers {λ i = λ ′ i /Λ : i ∈ N ′ }, such that i∈N ′ λ i = 1 and We may assume x i j = 0 for all j / ∈ S + whenever λ i > 0; otherwise simply replace x i by a vector in which all components not in S + are set to zero. By the packing property this is possible.

Algorithm 1 Changing a dominating convex decomposition into an exact decomposition
Require: A packing convex set Q and point x * ∈ Q and a convex combination i∈N λix i of integral points in QI dominating x * . Ensure: A convex decomposition x * = i∈N ′ λix i with x i ∈ QI.
1: while ∆j := i∈N λix i − x * j > 0 for some j do 2: let i be such that λix i j > 0 and ∆j > 0 for some j.

3:
if there is a j such that λix i j > 0 and h∈N λ h x h − λi1j ≥ x * then 4: replace x i by x i − 1j . 5: else 6: Among the indices j with x i j > 0 and ∆j > 0, let k minimize ∆ k /x i k . 7: let y be such that yj = x i j , if ∆j = 0, and yj = 0, if ∆j > 0. 8: change the lefthand side of (5) as follows: replace λi by λi − ∆ k /x i k and increase the coefficient of y by ∆ k /x i k . 9: end if 10: end while

From Dominating Convex Combination to Exact Convex Decomposition
We will show how to turn a dominating convex combination into an exact decomposition. The construction is general and uses only the packing property. Such a construction seems to have been observed in [LS05], but was not made explicit. Kraft, Fadaei, and Bichler [KFB14] describe an alternative construction. Their construction may increase the size of the convex decomposition (= number of non-zero λ i ) by a multiplicative factor s and an additive factor s 2 . In contrast, our construction increases the size only by an additive factor s.
Theorem 5. Let x * ∈ Q be dominated by a convex combination i∈N λ i x i of integral points in Q I , i.e., Then Algorithm 1 achieves equality in (5). It increases the size of the convex combination by at most s, where s is the number of positive components of x * .
Proof. Let S + = {j : x * j > 0}. We may assume x i j = 0 for all j ∈ S + and all i ∈ N with λ i > 0. For j ∈ S + , let ∆ j = i∈N λ i x i j − x * j be the gap in the j-th component. If ∆ j = 0 for all j ∈ S + , we are done. Otherwise, choose j and i ∈ N such that ∆ j > 0 and λ i x i j > 0. Let 1 j be the j-th unit vector. If, for some j with x i j > 0 and ∆ j > 0, replacing x i by x i − 1 j maintains feasibility, i.e., satisfies constraint (5), we perform this replacement. Since x i is an integer vector in Q I , the vector x i − 1 j is nonnegative and, by the packing property, in Q I . The replacement decreases ∆ j by λ i and does not increase the number of nonzero λ i .
Otherwise, ∆ j < λ i for all j with ∆ j > 0 and x i j > 0. Since x i is integral, we also have ∆ j ≤ λ i x i j for all such j. Among the indices j with ∆ j > 0 and x i j > 0, let k minimize ∆ k /x i k . Let y be such that y j = x i j if ∆ j = 0 and y j = 0 if ∆ j > 0. Then y ∈ Q I since Q is a packing polytope. In the convex combination, replace Notice that λ i − ∆ k x i k ≥ 0. Let ∆ ′ j be the new gaps. Then clearly ∆ ′ j = ∆ j , if ∆ j = 0. Consider any j with ∆ j > 0. Then The inequality in the second case holds since ∆ k /x i k ≤ ∆ j /x i j . We have decreased the number of nonzero ∆ j by one at the cost one additional nonzero λ i . Thus the total number of vectors added to the convex decomposition is at most s. ⊓ ⊔

Fast Convex Decomposition
We are now ready to prove Theorem 1.
Proof of Theorem 1. Theorem 4 yields a convex combination of integer points of Q I dominating αx * /(1 + 4ε). The convex decomposition has size at most s⌈ǫ −2 ln s⌉, where s is the number of positive entries of x * . The algorithm makes at most s⌈ǫ −2 ln s⌉ calls to the integrality-gap verifier. Theorem 5 turns this dominating convex combination into an exact combination. It adds up to s additional vectors to the convex combination. ⊓ ⊔

Approximatly Truthful-in-Expectation Mechanisms
The goal of this section is to derive an approximate VCG-mechanism. We do not longer assume that the fractional SWM-problem can be solved exactly, but instead assume that we have an FPTAS for it. We will first design a randomized fractional algorithm (Theorem 6 in Subsection 3.1) and then convert the fractional mechanism into an integral mechanism and prove Theorem 2 in Subsection 3.2.
In order to present Algorithm 2 and prove Theorem 6, we introduce some notation and prove some preliminary Lemmas. Let Note that L i does not depend on the valuation of player i. Let A be an ε-approximation algorithm for the LP relaxation of SWM. Note that A is polynomial time since the running time of an FPTAS is polynomial in 1 ε . We use A(v) to denote the outcome of A on input v; A(v) is a fractional allocation in Q. In the following, we will apply A to different valuations which we denote by Here v i is the reported valuation of player i,v i is his true valuation and v ′ i = 0. We denote the allocation returned by A on input v (resp., v, v ′ ) by x (resp.,x, x ′ ). Note that x,x, x ′ are fractional allocations.
We first bound the maximal change in social welfare induced by a change of the valuation of the i-th player.
Lemma 1. Let ε ≥ 0 and let A be an ε-approximation algorithm which returns allocation x on input vector v. Letx ∈ Q be an arbitrary point, then for every i.

Algorithm 2
The mechanism M of Theorem 6. The vectors u i are defined as in (1) and the quantities L i are defined in (6). The definitions of q 0 , q j , active and inactive player are given in the proof of Theorem 6.
Require: A valuation vector v, a packing convex set Q and an ε-approximation algorithm, where ε is as Theorem 6. Ensure: An allocation x ∈ Q and a payment p ∈ R n satisfying (D1) to (D4).
1: Choose an index j ∈ {0, 1, . . . , n}, where 0 is chosen with probability q0 and j ∈ {1, . . . , n} is chosen with probability qj = (1 − q0)/n. 2: if j = 0 then 3: Use ε-approximation algorithm A to compute an allocation x = (x1, . . . , xn) ∈ Q and compute payments with payment rule (8). For all inactive i, change xi and pi to zero. 4: else 5: For every 1 ≤ i ≤ n, set where the first inequality follows from the fact that A is an ε-approximation algorithm, and the last inequality follows from We use the following payment rule: where Observe the similarity in the definition of p VCG i (v) to the VCG payment rule. In both cases, the payment is defined as the difference of the total value of two allocations to the players different from i. The first allocation ignores the influence of player i (x ′ = A(0, v −i )) and the second allocation takes it into account (x = A(v)). The difference to the VCG rule is that x ′ and x are not true maximizers but are computed by an ε-approximation algorithm.
Let Lemma 2. Let ε ≥ 0 and let A be an ε-approximation algorithm. Let M 0 be the mechanism with allocation function A(v) and the payment rule (8). M 0 is an individually rational mechanism with no positive transfer, such that for all i, Proof. By definition, p i (v) ≥ 0 for all v and all x; so the mechanism has no positive transfer. We next address individual rationality. Assume where the first inequality follows from Lemma 1 with v =v andx = x ′ .
Finally, we prove (9). We have To see (9), we consider two cases: Case 1: p i (v) = 0. Then using (10) where the last inequality follows from β i ≥ 0. Therefore, in both cases we have: Now by using the definition of p VCG i and Lemma 1, we get

⊓ ⊔
In what follows we prove Theorem 6.
Proof of Theorem 6. Define q 0 = (1 − ε0 n ) n ,ε = ε 0 /2, and q j = (1 − q 0 )/n for 1 ≤ j ≤ n. Let η =ε(1 − q 0 ) 2 /n 3 , η ′ = η/q j , and ε = ηε(1 − q 0 )/(8n). Then using 7 q 0 = (1 − ε0 n ) n ≥ 1 − ε 0 and q 0 = (1 − ε0 n ) n ≤ 1 − ε 0 /2, we get ε 5 0 128n 4 =ε . Following [DRVY11], we call player i active if the following two conditions hold: Note that these conditions do not depend on the true valuationv. We denote by T = T (v) the set of active players when the valuation is v = (v 1 , . . . , v n ). Note that L i does not depend on v i . Thus when we refer to conditions (11) and (12) forv, we replace v and x byv andx on the left side and keep the right side unchanged. Non-negativity of payments is immediate from the definition of mechanism M and Lemma 2. Moreover, the utility of a truth-telling bidder i can be negative only if he/she is allocated in step 5, i.e., at most with probability q i . It follows that the mechanism is individually rational with probability at least 1 − n i=1 q i = q 0 = (1 − ε0 n ) n ≥ 1 − ε 0 . Now we address truthfulness. Let us denote the expected utility of player i obtained from the mechanism in Algorithm 2 on input v ∈ V by E[U ′ i (v)]. Assume j = 0 in Algorithm 2. We run ε-approximation algorithm A on v to compute allocation x = (x 1 , . . . , x n ). Then we change x i and p i to zero for all inactive i. Let x be the allocation obtained in this way. The value for player i is v i ( x). When the i-th player is active, this value is equal to v i (x) because v i depends only on the valuation in the i-th group (separability property). Therefore in this case his utility is U i (v). So we have that We first observe Indeed, the inequality is trivially satisfied if i ∈ T (v). On the other hand, if i ∈ T (v), then (11) We now consider four cases: Thus, by Lemma 2, and using assumption (1) thatv i (x) ≤v i (u i ), we have Hence by using (13) and (15), we have Now applying (14) in the above inequality, we get where the last inequality follows from the definition of ε. Note that (since q 0 ≤ 1 andε ≤ 1/2) Case 2: i ∈ T (v). By (14), we have Since, 1 1−ε = 1 +ε(1 +ε +ε 2 + . . .) ≤ 1 + 2ε = 1 + ε 0 .
where the second inequality holds because (12) does not hold forv and q i η ′ /η = 1.
We finally argue about the approximation ratio. Note that for i ∈ T (v), one of the inequalities (11) or (12) does not hold. Also, U i (v) ≥ 0 in this case since p i = 0, and hence

Approximately Truthful-in-Expectation Integral Mechanisms
In this subsection, we derive a randomized mechanism M ′ which returns an integral allocation. Let ε > 0 be arbitrary. First run Algorithm 2 to obtain x and p(v). Then compute a convex decomposition of α 1+4ε x, which is α 1+4ε x = j∈N λ x j x j . Finally with probability λ x j (we use the superscript x to distinguish the convex decompositions of different x) return the allocation x j and charge the i-th player the price p i (v) vi(x j ) vi(x) , if v i (x) > 0, and zero otherwise. We now prove Theorem 2.
Proof of Theorem 2. Let M be a fractional randomized mechanism obtained in Theorem 6. Since M has no positive transfer, M ′ does neither. M is individually rational with probability 1 − ε 0 , therefore for any allocationx, we havev i (x) − p i (v) ≥ 0 with probability 1 − ε 0 . Sō hence M ′ is individually rational with probability 1 − ε 0 . Now we prove truthfulness. Let E[U Taking expectation with respect to x shows that the mechanism is α(1−ε0)(1−ε) 1+4ε -socially efficient.
This completes the proof of Theorem 2. ⊓ ⊔ By using L(t + 1) ⊆ L(t), we have and hence applying inequalities (21) and (22) we get, Let i 0 ∈ L(t 0 ) be arbitrary. Then where the second inequality uses (21) for t = t 0 and the third inequality uses (23) for 0 ≤ t < t 0 .
Taking logs and using p(0) 1 = m, we conclude that