On Black-Box Transformations in Downward-Closed Environments

Black-box transformations have been extensively studied in algorithmic mechanism design as a generic tool for converting algorithms into truthful mechanisms without degrading the approximation guarantees. While such transformations have been designed for a variety of settings, Chawla et al. showed that no fully general black-box transformation exists for single-parameter environments. In this paper, we investigate the potentials and limits of black-box transformations in the prior-free (i.e., non-Bayesian) setting in downward-closed single-parameter environments, a large and important class of environments in mechanism design. On the positive side, we show that such a transformation can preserve a constant fraction of the welfare at every input if the private valuations of the agents take on a constant number of values that are far apart, while on the negative side, we show that this task is not possible for general private valuations.


Introduction
Mechanism design is a science of rule-making. Its goal is to design rules so that individual strategic behavior of the agents leads to desirable global outcomes. Algorithmic mechanism design, one of the initial and most well-studied branches of algorithmic game theory, studies the tradeoff between optimizing the global outcome, respecting the incentive constraints for individual agents, and maintaining the computational tractability of the mechanism [13]. A major line of work in algorithmic mechanism design involves taking a setting where the optimization problem is computationally intractable, and designing computationally tractable mechanisms that yield a good global outcome and such that the agents have a truth-telling incentive. Ideally, the mechanisms would match the best-known approximation guarantees for computationally tractable optimization algorithms in that setting. In other words, we want to obtain truthfulness from agents in as many settings as possible without having to pay for more computation.
In the past two decades, this goal of algorithmic mechanism design has been met in a wide range of prior-free as well as Bayesian settings. For instance, Briest et al. [3] showed how to transform pseudopolynomial algorithms for several problems, including knapsack, constrained shortest path, and scheduling, into monotone fully polynomial time approximation schemes (FPTAS), which lead to efficient and truthful auctions for these problems. Lavi and Swamy [11] constructed a general reduction technique via linear programming that applies to a wide range of problems. The widespread success of designing computationally tractable mechanisms with optimal approximation guarantees has raised the question of whether there exists a generic method for transforming any computationally tractable algorithm into a computationally tractable mechanism without degrading the approximation guarantee. Such a method would not be allowed access to the description of the algorithm but instead would only be able to query the algorithm at specific inputs, and is therefore known as a "black-box transformation".
An important work that demonstrates a limit of the powers of black-box transformations was done by Chawla et al. [5], who showed among other things that no fully general black-box transformation exists for single-parameter environments in the prior-free setting. In particular, for any transformation, there exists an algorithm (along with a feasibility set) such that the transformation degrades the approximation ratio of the algorithm by at least a polynomial factor. The result holds even when the private valuations can take on only two values; Chawla et al. provided a construction with two private valuations l < h satisfying h/l = n 7/10 , where n is the number of agents. Pass and Seth [14] extended this result by allowing the transformation access to the feasibility set while assuming the existence of cryptographic one-way functions.
Even though no fully general black-box transformation exists for singleparameter environments, it is still conceivable that there are transformations that work for certain large subclasses of such environments. One important subclass, which is the main subject of our paper, is that of downward-closed environments, i.e., environments in which any subset of a feasible allocation is also feasible. The construction used by Chawla et al. [5], later built upon by Pass and Seth [14], relies heavily on the non-downward-closedness of the feasibility set. The construction only includes three feasible allocations, and it is crucial that the transformation cannot arbitrarily "round down" the allocations as it would be able to if the feasibility set were downward-closed. Since downwardclosed environments occur in a wide variety of settings in mechanism design, including knapsack auctions and combinatorial auctions, we find the question that we study to be a natural and important one. We consider such settings and assume, crucially, that the black-box transformation is aware that the feasible set is downward-closed. As a result, when the transformation makes a query to the algorithm, it can potentially learn many more feasible allocations than merely the one it obtains. In this paper, we investigate the potentials and limits of black-box transformations when they are endowed with this extra power.

Our results
Throughout the paper, we consider the prior-free (i.e., non-Bayesian) setting. In Section 3, we show the limits of black-box transformations in downwardclosed environments. We prove that such transformations cannot preserve the full welfare at every input, even when the private valuations can take on only two arbitrary values (Theorem 1). Preserving a constant fraction of the welfare pointwise is impossible if the ratio between the two values l < h is sublinear, i.e., h/l ∈ O(n α ) for α ∈ [0, 1), where n is the number of agents (Theorems 2 and 3), while preserving the approximation ratio is also impossible if the values are within a constant factor of each other and the transformation is restricted to querying inputs of Hamming distance o(n) away from its input (Theorem 4).
In Section 4, we show the powers of black-box transformations in downwardclosed environments. We prove that when the private valuations can take on only a constant number of values, each pair of values separated by a ratio of Ω(n), it becomes possible for a transformation to preserve a constant fraction of the welfare pointwise, and therefore the approximation ratio as well (Theorem 5). The same is also true if the private valuations are all within a constant factor of each other (Theorem 8). Combined with the negative results, this gives us a complete picture of constant-fraction welfare-preserving transformations for multiple input values. Not only are these results interesting in their own right, but they also demonstrate the borders of the negative results that we can hope to prove.
The results are summarized in Table 1 for the case where the private valuations can take on two values, but they can be generalized to any constant-size range of private valuations as well.

Related work
Besides the works already mentioned, black-box transformations have been obtained in a variety of other prior-free and Bayesian settings. In the prior-free setting, Goel et al. [7] presented a reduction for symmetric single-parameter problems with a logarithmic loss in approximation, and later Huang et al. [10] improved the reduction to obtain arbitrarily small loss. Dughmi and Roughgarden [6] designed a reduction for the class of multi-parameter problems that admit an FPTAS and can be encoded as a packing problem, while Babaioff et al. [1] considered reductions for single-valued combinatorial auction problems.
Reductions that preserve the approximation guarantees have also been obtained in the single-parameter Bayesian setting by Hartline and Lucier [9], and their work was later extended to multi-parameter settings by Bei and Huang [2], Cai et al. [4], and Hartline et al. [8].

Preliminaries
We will be concerned with single-parameter environments. Such an environment consists of some number n of agents. Each agent i has a private valuation v i ∈ R, its value "per unit of stuff" that it gets. In addition, there is a feasibility set F , which specifies the allocations that can be made to the agents. Each element of F is a vector (x i ) n i=1 , where x i ∈ R denotes the "amount of stuff" given to agent i. For instance, in single-item auctions, F consists of the vectors with x i ∈ {0, 1} and n i=1 x i = 1. A more general and well-studied type of auctions is called knapsack auctions, in which each agent is endowed with a public size w i along with its private valuation v i , and the seller has some public capacity W . The feasibility set of a knapsack auction consists of the vectors with x i ∈ {0, 1} and n i=1 w i x i ≤ W . In this paper, we will assume that the feasibility set F is downward-closed, which means that if we take an allocation and decrease the amount of stuff given to one of the agents, then the resulting allocation is also feasible. Downward-closedness is an assumption that holds in many natural settings, including the aforementioned auctions.
Algorithms An algorithm (or allocation rule) A is a function that takes as input a valuation vector v = (v i ) n i=1 and outputs an allocation x = (x i ) n i=1 . We will consider the social welfare objective-the welfare of A at v is given by v · x = v 1 x 1 + · · · + v n x n , where x ∈ F is the allocation that A returns at v. We denote by OP T F (v) the maximum welfare at valuation vector v over all allocations in F . The (worst-case) approximation ratio of A is given by approx OP TF (v) , where we slightly abuse notation and use A(v) to denote the the allocation returned by A at v as well as the welfare of that allocation at v. Note that by definition, approx F (A) ≤ 1 for all F and A.
Transformations A transformation T is an algorithm that has black-box access to some other algorithm A, i.e., it can make queries to A. In each query, T specifies a valuation vector v and obtains the allocation that A returns at v. We write T (A) for a transformation T with access to the algorithm A. Importantly, we assume that T has the knowledge that the feasibility set F is downwardclosed. For the strongest possible negative results, we assume whenever possible that (i) T has knowledge of F , i.e., it can make a polynomial number of queries to ask whether a particular allocation belongs to F , and (ii) T is adaptive, i.e., it can adjust its next query based on the responses it received for previous queries. For strongest positive results, our transformation T does not make queries about F and is also not adaptive. We will be clear about our assumptions on T for each result.
Mechanisms A mechanism is a procedure that consists of eliciting declared private valuations (b i ) n i=1 from the agents, and then applying an allocation rule and a payment rule on the elicited valuations. The allocation rule determines the allocation (x i ) n i=1 and the payment rule determines the prices (p i ) n i=1 to charge the agents. We are interested in transformations that, when coupled with any algorithm, lead to truthful mechanisms, meaning that it is always in the best interest for each agent i to declare the true valuation v i to the mechanism, no matter what the other agents do. A seminal result by Myerson [12] states that an allocation rule can be supplemented with a payment rule to yield a truthful mechanism exactly when the allocation rule is monotone. Monotonicity of an allocation rule means that if an agent increases its declared valuation while the declared valuations of the remaining agents stay fixed, then the agent is allocated at least as much stuff as before by the allocation rule. Therefore, the transformations that yield truthful mechanisms are exactly the ones that constitute a monotone allocation rule for any algorithm.

Properties of transformations We call a transformation T monotone if T (A)
is a monotone allocation rule for any algorithm A. Furthermore, T is called welfare-preserving if T (A) preserves the welfare of A at every input for any algorithm A, and constant-fraction welfare-preserving if T (A) preserves a constant fraction of the welfare of A at every input for any algorithm A. Similarly, T is approximation-ratio-preserving if T (A) preserves the approximation ratio of A for any algorithm A, and constant-fraction approximation-ratio-preserving if T (A) preserves a constant fraction of the approximation ratio of A for any algorithm A. Note that a (constant-fraction) welfare-preserving transformation is also (constant-fraction) approximation-ratio-preserving.

Negative Results
In this section, we consider the limits of black-box transformation in downwardclosed environments. First, we show that no monotone black-box transformation preserves, up to a constant factor, the welfare of any original algorithm A pointwise. We then show that if a monotone black-box transformation preserves the approximation ratio of any given input algorithm A, then on some input v it must query A on an input that has Hamming distance Ω(n) from v.

Welfare-preserving transformations
We begin by considering the highest possible benchmark for the transformation: preserving the full welfare of any algorithm at every input. Our first theorem shows that this benchmark is impossible to fulfill even when the private valuations can take on only two arbitrary values. Theorem 1. Let l < h be arbitrary values (possibly depending on n). There does not exist a polynomial-time, monotone, welfare-preserving transformation, even when the transformation is allowed to be randomized and adaptive and make a polynomial number of queries to F .
Before we go into the formal proof, we give a high-level intuition. We handle the easier case of deterministic and non-adaptive transformations before moving to general transformations. We will consider a class of algorithms from which one algorithm A is selected randomly. For each algorithm A, our feasibility set will contain two maximal allocations C and D; the only allocations in F are those that are subsets of C or D. The allocation C is only returned at a "special input" B 1 , and the allocation itself as well as the special input depends on the algorithm A we choose from the class. At any other input, the allocation D is returned. Using monotonicity of the transformation, we will show that at an input that is "far away" from B 1 , the transformation still needs to know the allocation C in order to preserve the full welfare. However, because of the randomization, the probability the transformation can discover either the allocation C or the special input B 1 when it is given the faraway input is exponentially low, meaning that the transformation cannot achieve its goal.
Proof. Assume first that the transformation T is deterministic and non-adaptive. Suppose that the input is of length n = 4m. The algorithm A will be chosen randomly. To begin, we define the preliminary algorithm A as follows. In the real algorithm A, we permute uniformly at random the last 3m/2 positions of the inputs as well as the corresponding allocations. Again, this permutation is only for choosing the (deterministic) algorithm A.
Consider any algorithm A that we might choose, and assume without loss of generality that in the special input of this algorithm, the l's are in the last m positions. To preserve the welfare at input B 1 , T must return C = A(B 1 ) itself, since returning any strict subset of C or returning D (or any subset of D) would yield a lower welfare.
Next, consider the input B 2 = . Hence T will succeed within a polynomial number of queries with low probability.
Alternatively, T might try to find the special input B 1 by querying A. However, recall that we randomly permute the last 3m/2 positions of the inputs and their corresponding allocations. In order to find the special input B 1 , T must correctly choose m/2 out of the 3m/2 positions to change to h. Once again, the probability of success for each query is less than 1 poly(n) . Hence T will again succeed within a polynomial number of queries with low probability. Combined with the previous paragraph, this means that T is unlikely to succeed if it is deterministic and non-adaptive. Now assume that T is possibly adaptive. We will make sure that for each "unsuccessful" query to A or F , T learns no new information. This is already the case for queries to A, as for any unsuccessful query, T simply finds out the canonical allocation D. To prevent T from learning new information from unsuccessful queries to F , we insert "fake" allocations into F . In particular, we insert all allocations with m/2 − 1 1's in the first 2m positions and all 1's in the last m positions (before the permutation of indices) into F , as well as subsets of these allocations. As such, a successful query to F that contains at most m/2 − 1 1's in the first 2m positions does not give T any useful information.
Finally, assume that T is allowed to be randomized. Since our algorithm A is also chosen randomly by uniformly permuting the positions of 1's in the allocation as well as permuting the indices, the probability of success of T in guessing the special input or an allocation that returns at least m/2 1's in the first 2m positions cannot increase even if it randomizes its choices.

Constant-fraction welfare-preserving transformations
Even though Theorem 1 shows that it is impossible for a transformation to preserve the full welfare pointwise, it would still be interesting if the transformation can preserve a constant fraction of the welfare pointwise. However, as we show in this subsection, it turns out that this weaker requirement is also impossible to satisfy. Our next two theorems show that preserving a constant fraction pointwise is impossible when the ratio h/l is sublinear, i.e., h/l ∈ O(n α ) for some α ∈ [0, 1). We first consider the case where h/l is constant (Theorem 2), and later generalize to h/l ∈ O(n α ) for some α ∈ [0, 1) (Theorem 3). Together with Theorem 5, which exhibits an example of a constant-fraction welfare-preserving transformation when h/l ∈ Ω(n), we have a complete picture of constant-fraction welfare-preserving transformations when there are two input values.
Theorem 2. Let l < h be such that h/l is constant. There does not exist a polynomial-time, monotone, constant-fraction welfare-preserving transformation, even when the transformation is allowed to be randomized and adaptive and make a polynomial number of queries to F .
We give an outline of the proof, which bears a resemblance to the proof of Theorem 1 but contains differences in the execution. We start with a deterministic and non-adaptive transformation T . Our feasibility set will contain two maximal allocations C and D, as well as subsets of any of these two allocations. The "special allocation" C is only returned at the "special input" B 1 . Both the special allocation and the special input are chosen based on the queries that T makes to A and F at various inputs. At any other input, the allocation D is returned. Using the monotonicity of the transformation, we find another input B m+1 far away from B 1 where we have to return a subset of C that is not a subset of D. By our choice of the special allocation and special input, we ensure that at input B m+1 , the transformation neither makes a query at B 1 nor makes a successful query to F . This implies that T cannot succeed within a polynomial number of queries.
Proof. Assume first that the transformation T is deterministic and non-adaptive. Suppose that the input is of length n = m 6 + m 3 . Note that the sets poly(m) and poly(n) are identical.
Let X denote the set of inputs with m 5 l's in the first m 6 positions followed by m 3 h's, and let Y denote the set of inputs with m 5 − m l's in the first m 6 positions, followed by m 3 h's. We have |X| = m 6 m 5 and |Y | = m 6 m 5 −m . Since |X| > |Y | · poly(n), there exists an input in X that is not in the (polynomially long) query list of T for any input in Y . Assume without loss of generality that B 1 , defined below, is one such input.
Consider the algorithm A as follows: Similarly, we can define inputs B 3 , B 4 , . . . , B m+1 so that B i has i − 1 h's in the middle block and there is still a 1 corresponding to an l in the middle block. For each of these inputs, T must return at least m 2 1's in the middle block. Note also that B m+1 ∈ Y . Now, the special allocation is at B 1 , and by our assumption above, T does not find out by querying A at B 1 when it is presented with B m+1 ∈ Y . The only other possibility for T to discover the special allocation is to query F . There are m 5 m inputs of Y whose first m 6 − m 5 positions are all h's, and these are the only inputs at which T can benefit from a "successful" query to F . When T makes a query at each of these inputs, it must pick an allocation with at least m Finally, we generalize to adaptive and randomized transformations T in a similar way as in Theorem 1.

⊓ ⊔
Using a similar construction, we can generalize the impossibility result to the case where h/l ∈ O(n α ) for any α ∈ [0, 1). Theorem 3. Let l < h be such that h/l ∈ O(n α ) for some α ∈ [0, 1). There does not exist a polynomial-time, monotone, constant-fraction welfare-preserving transformation, even when the transformation is allowed to be randomized and adaptive and make a polynomial number of queries to F . Proof. We extend the example for the case where h/l is constant (Theorem 2). Let b > c > d > e > 1 be constants that we will choose later. Suppose that the three blocks have length m b , m c , and m e , respectively, and that there are m d 1's in the middle block. We construct inputs B 1 , B 2 , . . . , B m+1 as before. In order for the same argument to go through, we need three conditions: 1. For the transformation to necessarily return a subset of C at the special input B 1 , we need m d ≥ m e (m b + m c + m e ) α . This translates roughly to d ≥ e + bα. Since α < 1, it is possible to choose such b > d > e. Hence we can choose b, c, d, e so that all three conditions hold, and our proof is complete.

For queries to
⊓ ⊔ Note that the examples so far cannot be used to show the non-existence of a monotone (constant-fraction) approximation-ratio-preserving transformation. Indeed, consider the transformation that simply returns the canonical allocation D. The points at which this transformation fails to preserve the welfare of the algorithm are points at which the algorithm is optimal, and elsewhere the algorithm is far from optimal, implying that the approximation ratio is preserved.

Approximation-ratio-preserving transformations
In this subsection, we consider a weaker benchmark than preserving full welfare pointwise: preserving the approximation ratio. We show that this benchmark is still impossible to satisfy if we restrict the transformation T to querying inputs at Hamming distance less than some function f (n) ∈ o(n) from its input, and disallow T from querying F . Theorem 4. Let l < h be such that h/l is constant, and let f (n) ∈ o(n). There does not exist a polynomial-time, monotone, approximation-ratio-preserving transformation T . The transformation T is allowed to be randomized and adaptive, but it cannot make queries to F and can only make queries to A on inputs that are of Hamming distance less than f (n) from the original input.
Proof. Suppose that the input is of length n = 2m, and consider the algorithm A as follows: Similarly, we can define inputs B 3 , B 4 , . . . , B m+2f (n)+1 so that B i has i−1 h's in the second half and there is still a 1 corresponding to an l in the second half. A sufficient condition to guarantee a 1 on an l in the second half is that putting 1's on all h's in the second half is not enough to match the approximation ratio l/h. That is, 2f (n)·h mh < l h . Since f (n) ∈ o(n), we can choose n large enough so that this condition is satisfied.
For each of the inputs B 3 , B 4 , . . . , B m+2f (n)+1 , T must return a subset of A(B 1 ). At input B m+2f (n)+1 , however, T cannot discover the allocation A(B 1 ) because of the Hamming distance restriction. Hence T cannot succeed.

⊓ ⊔
If we are only interested in preserving a constant factor of the approximation ratio, then Theorem 8 shows that this is possible in the same setting of h/l constant, and Theorem 5 shows that it is also possible when h/l ∈ Ω(n). It is not clear whether a negative result can be obtained when h/l ∈ O(n α ) for some α ∈ (0, 1).

Positive Results
In this section, we consider the powers of black-box transformations in downwardclosed environments. We show that when values are either high or low, and the ratio between high and low is Ω(n), then there is a monotone transformation that gives a constant approximation to the welfare of any given algorithm pointwise, and therefore also preserves the approximation ratio up to a constant factor. This can be generalized to any constant number of values, and the transformation can be modified so that it also preserves full welfare at a constant fraction of the inputs. While these results are of independent interest, they also serve to demonstrate the limitations of extending the negative results in Section 3. For the strongest possible results, we exhibit transformations that do not query F or operate adaptively.

Two values
We begin by showing that when the private valuations take on two values that are far apart, there exists a transformation that preserves a constant fraction of the welfare at each input. This contrasts with the negative result when the values are close to each other (Theorem 3).
Theorem 5. Let l < h be such that h/l ∈ Ω(n). There exists a polynomial-time, monotone, constant-fraction welfare-preserving transformation.
Proof. First we give a high-level intuition of the transformation. A monotone transformation needs to ensure that for any two adjacent inputs, it does not simultaneously occur that a 0 appears on h and a 1 on l in the differing position. As such, we would like to use the downward-closedness to "zero out" the l's in a given input to avoid the undesirable situation. If the algorithm already returns a 1 on some h for the input, this can be done while still preserving a constant fraction of the welfare. Otherwise, we look at nearby inputs and take an allocation that would return a 1 on some h for our input, if such an allocation exists.
We now formally describe the transformation T . Given an input v, T proceeds as follows: 1. If A(v) already has a 1 on h, "zero out" all the l's, and return that allocation. 2. Else, if some input adjacent to v has an allocation that would yield a 1 on h at v, take that allocation and zero out all the l's, and return that allocation.
(Pick arbitrarily if there are many such allocations.) 3. Else, if some input of Hamming distance 2 away from v has an allocation that would yield a 1 on h at v, take that allocation and zero out all the l's, and return that allocation. (Pick arbitrarily if there are many such allocations.) 4. Else, return A(v).
The transformation takes polynomial time, and it only zeroes out the l's when the allocation already has a 1 on h. Since h/l = Ω(n), a constant fraction of the welfare is preserved pointwise.
It remains to show that the resulting allocation rule is monotone. Suppose for contradiction that for some neighboring inputs v and w, at the position where the two inputs differ, there exists a 0 on h at v, and a 1 on l at w. The allocation at w cannot have changed in Steps 1, 2, or 3 of the transformation, and w has 0 on all the h's. But then v must have started with 0 on all the h's, except possibly at the position where the two inputs differ, because otherwise w would have changed in Step 2. At the differing position, however, v must have started with 0 too, because otherwise it could never become 0. Now, v must have changed in Step 2, because the allocation at w satisfies the criterion in that step. It did not change to the allocation at w, because otherwise the non-monotonicity would not have occurred. Hence it must have changed to some other input with a 1 on h. But then w should have changed to that allocation too in Step 3, a contradiction.
⊓ ⊔ Note that the transformation in Theorem 5 might preserve full welfare at a very small number of inputs. Indeed, if A returns the allocations with all 1's at every input, then T preserves full welfare at only 2 out of the 2 n inputs. Nevertheless, we can improve the transformation so that not only does it preserve a constant fraction of the welfare pointwise, but it also preserves full welfare at a 1/n fraction of the inputs. To this end, we will need to make a slightly stronger assumption that h/l > n. Theorem 6. Let l < h be such that h/l > n. There exists a polynomial-time, monotone, constant-fraction welfare-preserving transformation that preserves the full welfare at a 1/n fraction of the inputs.
Proof. We exhibit such a transformation T , which is a slight modification of the transformation in Theorem 5.
We call an allocation (implicitly along with an input) an h-allocation if it has a 1 on h at the input, and an l-allocation otherwise. For any allocation (again implicitly along with an input), call another allocation a higher h-allocation if it yields strictly more 1's on h than the original allocation at the input.
Given any input v, the transformation T proceeds as follows: is an h-allocation, consider its adjacent inputs. If the allocation at one of these inputs would yield a higher h-allocation at v, take that allocation. The transformation takes polynomial time. One can check in a similar way as in Theorem 5 that the resulting allocation rule is monotonic, and that a constant fraction of the welfare is preserved pointwise. We now show that a 1/n fraction of the inputs obtain weakly better welfare. In particular, for each input that obtains strictly less welfare, we will find a neighbor that obtains weakly better (in fact, strictly better) welfare.
An input obtains strictly less welfare only if it has to zero out an l in Step 7. That means that the input has a 1 on l. In particular, its allocation has never been changed in Steps 1 through 6. On the other hand, a neighbor has a provisional allocation with a 0 on h in that position. Assume, for contradiction, that the neighbor obtains less (or equal) welfare than before. That means that it has never changed to a better allocation during the execution of the transformation. But then one of the two inputs could have gotten strictly more h's by taking the allocation of the other, a contradiction.
Hence, every time an input loses a 1 on l, it can point to a neighbor that got better. Each input that got better can be pointed to at most n − 1 times. Let W be the set of inputs that got worse. We have |W | ≤ (n − 1) · (2 n − |W |), and therefore |W | ≤ n−1 n · 2 n , as desired.

⊓ ⊔
If h/l > 2n, the transformation in Theorem 6 also preserves the expected welfare over the uniform distribution over the 2 n inputs, as we show next.
Theorem 7. Let l < h be such that h/l > 2n. There exists a polynomialtime, monotone, constant-fraction welfare-preserving transformation that preserves full welfare at a 1/n fraction of the inputs and preserves expected welfare over the uniform distribution over the 2 n inputs.
Proof. Consider the transformation in Theorem 6. Every time an input loses a 1 on l, it can point to a neighbor that got better. The welfare of that neighbor has increased by at least h− nl > nl. Since each input that got better can be pointed to at most n − 1 times, the expected welfare over the uniform distribution over the 2 n inputs is preserved.
⊓ ⊔ Finally, we consider the other extreme case where h/l is constant. In this case, simply returning a constant allocation already preserves a constant fraction of the approximation ratio. We focus on the allocation A(ll . . . l), but a similar statement can be obtained for any other constant allocation. The result can also be extended to the case where we have multiple input values, all of which are within a constant factor of each other.
Theorem 8. Let l < h be arbitrary values (possibly depending on n), and let T be a transformation that returns the constant allocation A(ll . . . l) at any input. Then T preserves an l/h fraction of the approximation ratio.
Proof. One can check that T (A)(v) ≥ A(ll . . . l) for any input v. Moreover, we have that OP T (v) ≤ h l · OP T (ll . . . l), since any allocation at v would return at least an l/h fraction of the welfare when allocated to the input ll . . . l. Hence as desired.

⊓ ⊔
Combining this theorem with Theorem 5, we have that a constant fraction of the approximation ratio can be preserved if either h/l is constant or h/l ∈ Ω(n). This means that if we were to obtain a negative result with two values, it would have to be the case that h/l lies strictly between constant and linear.

Multiple values
In this subsection, we show that we can generalize the transformation in Theorem 5 to the case where we have multiple input values, each pair separated by a ratio of Ω(n). Recall that when some two input values are separated by O(n α ) for some α ∈ [0, 1), we have from Theorem 3 that it is impossible to preserve a constant fraction of the welfare pointwise. Hence we have a complete picture of constant-fraction welfare-preserving transformations for multiple input values as well.
Moreover, if a i+1 /a i > n for all i, then the transformation can be modified so that it also preserves full welfare at a 1/(k − 1)n fraction of the inputs.
Proof. We first consider the case where there are three input values h, m, l, and focus only on preserving a constant fraction of the welfare pointwise. It is possible to extend to any constant number of inputs k and also preserve full welfare for a 1/(k − 1)n fraction of the inputs, and we explain that later.
For any allocation (implicitly along with an input), we call it an h-allocation if it has a 1 on h at the input. Otherwise, we call it an m-allocation if it has a 1 on m at the input. Finally, we call it an l-allocation if it is neither an h-allocation nor an m-allocation. For any allocation (again implicitly along with an input), call another allocation a higher allocation if it yields either strictly more 1's on h than the original allocation at the input, or an equal number of 1's on h and strictly more 1's on m.
We exhibit a transformation T that preserves a constant fraction of the welfare pointwise. Given any input v, the transformation T proceeds as follows: 6. If the allocation at v is currently an h-allocation, zero out all the m's and l's. If it is an m-allocation, zero out all the l's. Return the current allocation A(v).
The transformation runs in polynomial time. One can check in a similar way as in Theorem 5 that the resulting allocation rule is monotone. Moreover, since h/m, m/l ∈ Ω(n), a constant fraction of the welfare is preserved pointwise. As mentioned, it is possible to extend the transformation to any constant number of inputs k and also preserve full welfare for a 1/(k − 1)n fraction of the inputs. Suppose that the input values are a 1 < a 2 < · · · < a k . Then the transformation takes O(k 2 ) steps.
a n−1 → a n In each step, the transformation considers allocations at inputs at Hamming distance one higher than the previous step. If the change in the type of allocation (e.g., from an a 2 -allocation to an a 5 -allocation) matches the specified change in that step, the transformation executes the change. The question mark (e.g., ? → a 3 ) denotes any allocation. Finally, the transformation zeroes out all the input values other than the highest one of the allocation. One can check that this transformation preserves a constant fraction of the welfare pointwise. We can extend it in a similar way as in Theorem 6 so that the transformation also preserves full welfare at a 1/(k − 1)n fraction of the inputs.