New Convex Programming Technique for Nash Social Welfare and Scheduling
Abstract
We propose a new convex programming relaxation for the weighted Nash social welfare (NSW) problem that achieves a matching -approximation via the rounding algorithm of Feng and Li. Unlike the exponential-size configuration LP used in prior work, our formulation can be converted into a compact linear program of polynomial size, incurring only an additive loss of in the objective. This allows the program to be solved directly using standard LP solvers, without the ellipsoid method or dual separation oracles.
In the unweighted case, we show that our convex program is equivalent to the restricted-spending Fisher market convex program of Cole and Gkatzelis, yielding a constructive proof that its integrality gap is exactly . With a minor modification, our analysis also gives a simple proof of the EF1 gap for the identical agent setting. Finally, we show that our convex programming technique extends to two unrelated machine scheduling problems, recovering the best-known approximation ratios with simpler analyses.
Keywords and phrases:
Nash Social Welfare, Convex Programming, Approximation Algorithms, SchedulingCategory:
Track A: Algorithms, Complexity and GamesCopyright and License:
2012 ACM Subject Classification:
Theory of computation Approximation algorithms analysis ; Theory of computation Mathematical optimizationFunding:
The authors are supported in part by State Key Laboratory for Novel Software Technology, and New Cornerstone Science Foundation.Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele PuppisSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
We study the problem of allocating a set of indivisible items to a set of agents so as to maximize the weighted Nash social welfare (NSW) of the allocation. Each agent is associated with a weight , with . Each item has a value for agent . The goal is to find an allocation of items to agents that maximizes the weighted Nash Social Welfare, defined as the weighted geometric mean of agents’ valuations:
where denotes the value of the bundle allocated to , according to ’s valuation. When for every agent , we call the problem the unweighted NSW problem.
Allocating indivisible resources among agents with heterogeneous preferences is a central problem at the intersection of theoretical computer science, game theory, and economics [4, 7, 8, 30, 32, 33, 36]. Among the many objective functions that have been proposed to capture both efficiency and fairness, the Nash Social Welfare objective stands out for providing a smooth trade-off between utilitarian and egalitarian goals, with applications in bargaining theory [10, 26, 35], water allocation [13, 21], and climate agreements [37].
The unweighted NSW problem was already proven to be NP-hard by Nguyen, Nguyen, Roos and Rothe [31], and APX-hard by Lee [27]. Recently, Garg, Hoefer and Mehlhorn [17] improved the hardness of approximation to .
On the algorithmic side, Cole and Gkatzelis [12] introduced a convex program whose optimum solution captures a Fisher market equilibrium with restricted spending on individual items. They designed an efficient rounding algorithm for their convex program with an approximation ratio of -approximation. The approximation ratio was subsequently improved by Cole, Devanur, Gkatzelis, Jain, Mai, Vazirani and Yazdanbod [11] to . Independently, Anari, Gharan, Saberi and Singh [1] developed an -approximation for the problem using a convex program relaxation based on real stable polynomials.
The current best-known approximation factor for the problem is due to Barman, Krishnamurthy and Vaish [5]. They showed that for an unweighted NSW instance with identical agents, any EF1 (envy-free up to one item) allocation is -approximate, and then converted the ratio into the approximation ratio for the unweighted NSW problem (where agents are not necessarily identical). We refer to this worst-case approximation factor of EF1 allocations as the EF1 gap.
For the more general weighted NSW problem, Brown, Laddha, Pittu and Singh [9] presented a approximation algorithm, which is a super-constant when the weight vector is far from uniform. It was an open problem to design a constant approximation for weighted NSW. This was solved by Feng and Li [15, 16], who gave an -approximation for the problem, matching the best approximation ratio for the unweighted version of the problem. Their approach is based on a natural configuration LP with logarithm of weighted Nash social welfare as the objective, and the Shmoys-Tardos rounding algorithm for the unrelated machine makespan minimization problem [34].
1.1 Our Results
Our main contribution is a new convex program for the weighted Nash social welfare (NSW) problem, which also achieves an -approximation using the rounding algorithm of Feng and Li [16]. In contrast to the exponential-size configuration LP of [16], our convex program can be converted into a compact linear program of polynomial size, incurring only an additive loss of in the objective value. So, it can be solved directly with the loss using standard LP solvers, without resorting to the ellipsoid method and a dual separation oracle.
Theorem 1.1.
More interestingly, we show that in the unweighted case, our program is equivalent to the convex program CP(f-SR) introduced by Cole and Gkatzelis [11] that captures the Fisher market equilibrium with restricted spending. The program is defined later in Section 2.3. This yields a constructive proof that the integrality gap of this convex program is at most . Combined with the lower bound by [11], this shows that the integrality gap of CP(f-SR) is exactly .
Theorem 1.2.
With a slight modification of our analysis, we obtain a simple proof of the EF1 gap for the unweighted NSW problem with identical agents, which was proved by Barman, Krishnamurthy and Vaish [5]. Our proof avoids the sequence of adjustment steps.
Finally, we demonstrate that our convex programming technique naturally extends to two unrelated machine scheduling problems: one with the objective of minimizing the norm of machine loads, and another with the objective of minimizing weighted completion time when all jobs have the same Smith ratio. The known results [22, 24] for both problems use configuration LPs and the rounding algorithm of [34]. Similarly, we show that our simple convex programs are sufficient to recover the same approximation ratios as proved in [22, 24]. In particular, for the approximation ratio for the weighted completion time problem in [24], we obtain a simpler analysis.
1.2 Overview of Our Techniques
As in [16], we take the logarithm of the weighted Nash social welfare as the objective of our convex program relaxation. Specifically, we design a concave function for each agent , and aim to maximize , where denotes the fractional allocation of items to agent .
The strongest choice for is the concave closure of the discrete function mapping to . This corresponds to the configuration LP introduced by Feng and Li [16], where is defined as the maximum of over all convex combination decompositions of , where is the indicator vector for .
On the opposite side, if all items are assumed to be infinitely divisible, allowing configuration to contain portions of items, then is maximized when all configurations have the same value. In this case, the function simplifies to , which preserves the original formula but extends its domain to .
Our approach lies between these two extremes. We only treat the largest 1 fractional item of maximum value in as indivisible, while all remaining items are treated as divisible. Under this assumption, the optimal decomposition of items into configurations is given as follows: each configuration contains exactly one indivisible item, and the divisible items are allocated via a water-filling procedure. Then is defined as the average logarithm of the value of these configurations. We show that our is concave by expressing it as the minimum of linear functions. This is sufficient to recover the approximation factor using the rounding algorithm of [16], as in the worst instance, only the largest 1 fractional item is indivisible.
To show the equivalence of our convex program and that of [11] via market equilibrium, we establish a correspondence between whether items that are covered by water in the water filling procedure defining ’s, and items whose market prices are at most 1. Thanks to the uniform weight vector, this classification of items is the same for all agents. This uniformity is why the convex program of [11] applies only to the unweighted case.
In both the analysis of our rounding algorithm and our simplified proof of the EF1 gap, we define a liquidization operation that converts an item into arbitrarily small items with the same total value, this operation preserves total values but allows us to treat the liquidized items as divisible in the analysis. In the EF1-gap proof, we focus on the agent receiving the smallest value, say . We then liquidize items of total value exactly for every agent, leaving only a portion of the largest item unliquidized. This transformation can only increase the gap. In the optimal solution, the liquidized items are allocated using the water-filling procedure. The remaining task of analyzing the gap between our solution and the optimal one is straightforward.
1.3 Other Related Work
A more general function family that has been studied for the NSW problem is submodular functions. In contrast to the additive valuation function setting, each agent is associated with a monotone submodular valuation function , and the goal remains to find an allocation that maximizes . As in the additive case, we have the unweighted submodular NSW problem, where all agents have weights , and the weighted submodular NSW problem, where the weight vector can be any vector in satisfying .
In the unweighted case, the current best-known inapproximability for submodular NSW is , proved by Garg, Kulkarni and Kulkarni [19], even when the number of agents is a constant.
Algorithmically, the first -approximation for unweighted submodular NSW was obtained by Li and Vondrák [29] via convex programming, with an approximation ratio of . Subsequently, Garg, Husic, Li, Végh and Vondrák [18] introduced an elegant local-search method that improved the approximation ratio to for the unweighted case. The same framework also yields an -approximation for the weighted case [18], where .
Whether one can obtain an -approximation remained open. This was resolved by Feng, Hu, Li and Zhang [14], who developed a -approximation based on the configuration LP from [16], giving the first constant-factor approximation for the weighted case. Very recently, Bei, Feng, Hu, Li and Zhang [6] significantly advanced this line of work by presenting a -approximation, simultaneously improving the best-known ratios for both weighted and unweighted submodular NSW. They solve the same configuration LP via a stronger separation oracle that loses an factor only on small items, and then round the solution using a new bipartite multigraph construction to achieve the improved constant.
Throughout, we shall simply refer to the NSW problems with additive valuations as unweighted/weighted NSW problems, as they are our focuses of the paper.
For the unrelated machine scheduling problem with the objective of minimizing the norm of machine loads (), Im and Li [22] obtained an approximation ratio of -approximation algorithm, using a time-index LP relaxation and the Shmoys-Tardos rounding algorithm [34]. This framework improves upon some earlier results [2, 3, 25]. In particular, their approximation ratio for is .
The unrelated machine weighted completion time problem has been extensively studied in the literature. Following a sequence of work [20, 22, 23], Li [28] gave the current best approximation ratio of for the problem. The case we are interested is when all jobs have the same Smith ratios across all machines, for which Kalaitzis, Svensson and Tarnawski [24] gave a -approximation. This is also based on the Shmoys-Tardos rounding algorithm, along with the configuration LP relaxation for the problem.
Organizations
The rest of the paper is organized as follows. In Section 2, we introduce the problem definitions, notation and other preliminaries for NSW problem and the related scheduling problems. In Section 3, we present our main convex program, and show the equivalence of CP(2) and CP(f-SR) in unweighted case, proving Theorem 1.2. In Section 4, we analyze the rounding algorithm of CP(2) and prove Theorem 1.1. In Section 5, we provide a simple proof of the EF1 gap. Finally Section 6, we apply our convex programming technique to two scheduling problems.
2 Preliminaries
2.1 Problem Definitions
For the weighted additive Nash Social Welfare (NSW) problem, it is convenient for us to avoid agent-item pairs with value. So in our definition of the problem, we are given a set of agents, each with a weight subject to , a set of items, a set of edges, along with a value for every . We assume every or is incident to at least one edge in . Let for every and for every . Our goal is to find an allocation such that for every , so as to maximize , where we use for every and . In the unweighted Nash Social Welfare problem, we have for every .
We shall consider the following general unrelated machine scheduling problem. There is a set of machines, a set of jobs, a size for every and . We are given an increasing convex function with . Our goal is to find an allocation so as to minimize , where and for every . We call the problem the unrelated machine scheduling problem with objective.111We remark the notation change from NSW problems to scheduling problems. In both settings we need to allocate some objects to some players. denotes the objects (items) in NSW problems, and players (machines) in scheduling problems. We always have . is the number of players () in NSW problems, and number of objects () in scheduling problems. When for , the objective becomes the norm, after taking the -th root of the objective.
In the unrelated machine scheduling with weighted completion time objective and uniform Smith ratios, we are given and as in the previous problem. Our goal is to find an allocation so as to minimize
When a job is allocated to , it has processing time and weight . Namely, the Smith ratio of any job on any machine is always . On every machine , the weighted completion time of scheduling on is . As all jobs have the same Smith ratio, any permutation of jobs is optimum. The objective is closely related to the norm of machine loads.
2.2 EF1 Allocation and EF1-Gap for Unweighted Additive NSW with Identical Agents
Suppose we are given an unweighted NSW instance with identical agents , and indivisible items . As the valuation functions are identical, we simply use to denote the value of item for any agent .
Definition 2.1.
An allocation of items to agents is said to be envy-free up to 1 item (EF1) if for every two agents , we have .
So in an EF1 allocation , for any pair of agents, does not envy once we remove the largest item in the bundle of agent . [5] proved the following theorem:
Theorem 2.2 ([5]).
Consider an unweighted NSW instance with identical agents, defined by and . Let be an EF1 allocation, and be the optimum NSW value of the instance. Then, we have
The factor is called the EF1 gap of for the NSW problem. At a high level, the proof in [5] compares an arbitrary EF1 allocation to an optimal partially-fractional allocation via a sequence of swap operations, derives a lower bound for the EF1 allocation and an upper bound on the optimal NSW, and then optimizes these bounds to obtain the guarantee. However, the argument relies on several structural lemmas and nontrivial inequalities, which makes the proof rather complicated.
2.3 Convex Program CP(f-SR) of [11] for Unweighted NSW
[11] introduced a market equilibria based convex program for the unweighted additive Nash social welfare problem. The convex program, denoted as CP(f-SR), is defined as follows:
| (f-SR) |
We note that [12] uses the NSW value as the objective, while we instead use its logarithm, for the ease of comparison with our convex program. Consider an allocation for the instance. Then, we define if and otherwise. . This gives us a valid solution to CP(f-SR). The logarithm of the NSW of is
which is exactly the objective of CP(f-SR).
[12] proved the following lemma:
Lemma 2.3.
With a scaling of the valuation functions , there exists a price vector such that the following conditions hold for the optimum solution to CP(f-SR):
-
for every .
-
for every .
-
If for some , then .
The lemma says that one can define prices for items so that the value of an item to any agent is at most its price. So the bang-per-buck (BaB) for any pair is at most . Moreover, in the solution , will only be allocated items with BaB exactly 1. When agent gets a value from item , he pays to . Every agent spends , and the money spent on any item is . This achieves a market equilibrium with “restricted spending”.
2.4 Rounding Algorithm of [16]
We revisit the rounding algorithm of [16], which is the same as that of [34] for the unrelated machine makespan minimization problem. This is the same rounding algorithm used in both [22] and [24].
We shall describe the rounding algorithm in the context of weighted Nash Social Welfare. We are given a fractional allocation of items to agents: we have for every . We further have for every since otherwise the value of the solution will be . (This property does not hold for scheduling problems, and it is not required by the rounding algorithm.) Throughout, for the given , we shall use to denote the fractional allocation for agent .
For each agent , we sort items in by non-increasing and partition the fractional items into groups using this order, each containing fractional item except for the last one. Here each is a fractional bundle over with , and for each , denotes the fraction of item contained in . More formally, we define a total order over that sorts the items in non-increasing order of with ties broken arbitrarily. Thus, implies . Then are vectors in satisfying the following properties:
-
.
-
for every .
-
For any two integers with and two items with , it can not happen that and .
Notice that under the above 3 conditions, the choice of is unique.
This yields a collection of groups and a fractional matching between the groups and items : every group is matched to an item with fraction (or if is not in the domain of ). So each group is matched to an extent of , and each item is matched to an extent of . By the way we construct the groups, a group which is not the last group for an agent is matched to an extent of .
In the randomized rounding algorithm, we arbitrarily partition the fractional matching into a convex combination of (partial-)matchings between and and randomly pick a matching from the combination, according to their masses. Each integral matching allocates each item to one group, hence induces an integral allocation of items to agents: an item is allocated to the agent if it is matched to a group in . Marginal probabilities are maintained by the rounding algorithm: the probability that an item is allocated to an agent is precisely for any .
The algorithm can be derandomized by using a polynomial-sized decomposition and outputting the best matching from the decomposition. However, as is typical, it is more convenient to analyze the randomized version of the rounding algorithm.
2.5 Creating Unweighted NSW Instance with Identical Agents and EF1 Allocation for a Fixed Agent
Let be the random allocation given by the algorithm. In the analysis of the randomized rounding algorithm, we shall focus on a fixed agent most of the time. We create an unweighted NSW instance with identical agents, which are all copies of the agent , and an EF1 allocation for .
Let be a sufficiently large integer such that for every is an integer multiple of , so is for every . We create copies of the agent , and index them as . We create copies of item for every . The allocation is defined according to the output distribution of the rounding algorithm: for every , there are precisely agents in who gets a copy of , in the allocation . It was shown in [16] that is an EF1-allocation.
The procedure of creating and also applies to the rounding algorithm for scheduling problems.
3 The Convex Program
In this section, we describe our convex program which yields an -approximation for weighted NSW. We prove that it is equivalent to CP(f-SR) in the unweighted case, showing that the integrality gap of CP(f-SR) is precisely .
For every , and satisfying , we define to be any real satisfying
If , the choice of is unique, which can be determined by the following procedure. Let be the vector that maximizes subject to . In other words, consists of the largest one fractional item in . We construct a histogram for , where every item is represented by a rectangle of width and height . Let denote the total value of remaining fractional items. Treating this value as units of water, we pour the water into the histogram from bottom to top. Then is the resulting water level. See Figure 1 for illustration of the definition. When , no water is poured, and can be any real number in .
With defined, we define as follows:
| (1) |
So, is the average height of the histogram in Figure 1 on a logarithmic scale. Notice that when , we have , which is independent of the choice of .
We give an alternative description of which will prove the concavity of the function. For every with and , we define
Notice that for a fixed , the function is linear in .
Lemma 3.1.
For any , satisfying , we have
Proof.
We calculate for any for any :
So, the derivative is continuous on . Moreover, when and when . So, the function is minimized when . Moreover, when , we have as .
As is a linear function of for any fixed , we have
Corollary 3.2.
is concave over its domain.
Our convex program can simply be written as follows:
| (2) |
3.1 Solving CP(2) via Discretization
Unlike [11], we could not show the rationality of the optimum solution of the convex program. So, it is not clear if the convex program can be solved in polynomial time, and more specifically, if the optimum solution can be represented using rational numbers. Nevertheless, the standard discretization technique allows us to solve the CP approximately within an additive error of for any constant . For every , we let and , so that we always have . (In case , we can choose .) Then, let . We shall use
as an approximation of .
Lemma 3.3.
for every with .
Proof.
holds trivially and so we only need to prove the second inequality. Let be the smallest number in with . Then, we have . From the proof of Lemma 3.1, we know . So, we have . The lemma follows from that and .
Therefore, we can consider the new convex program where the objective is to maximize . The new convex program can be reformulated explicitly as a polynomial-sized linear program: we change our objective function to , and add linear constraints for every and to the program.
3.2 Equivalence of CP(2) and CP(f-SR) in Unweighted Case
In this section, we prove Theorem 1.2 by showing the equivalence of CP(2) and CP(f-SR) for unweighted NSW.
Proof of Theorem 1.2.
First, we show the value of CP(2) is at most that of CP(f-SR). Given a valid solution to CP(2), we convert it to a valid solution to CP(f-SR), with value at least that of to CP(2).
By scaling the valuation functions, we assume for every . We construct a solution to CP(f-SR) as follows:
For every , we have . For every , we have , by the definition of and that . Therefore, the solution to CP(f-SR) is valid.
We now compute the value of to CP(f-SR). Observe that for every , and . By the concavity of the logarithm function , we obtain , which is equivalent to
So, we have
by the definition of and that . Therefore,
Now we prove that the value of CP(f-SR) is at most that of CP(2). Let be the optimum solution to CP(f-SR). We scale the valuation functions as stated in Lemma 2.3, and let be the price vector from the lemma. We construct a solution to CP(2) whose value is at least that of . The definition of is simple:
For every , we have . For every , we have . So, is a valid solution to CP(2).
Focus on any agent . We have
The first equality follows from the third property in Lemma 2.3, and the second equality follows from the first property. Hence, we have . (The choice is unique for if , and it is valid if .) So,
The first equality is by the definition of and that , the second one is by that if and , then and , and the third one is by that and that implies .
So,
4 Analysis of Rounding Algorithm for CP(2): Proof of Theorem 1.1
After solving CP(2) up to an additive error of , we obtain the fractional solution . We then use the rounding algorithm described in Section 2.4 to output an integral allocation of items to agents. In this section, we show that the approximation ratio of the algorithm is , matching the ratio given by [16]. This proves Theorem 1.1. As in [16], it is more convenient to consider the randomized version of the rounding algorithm.
Till the end of this section, we focus on a fixed agent . Then, we create an unweighted NSW instance with copies of agents (indexed by ), and an EF1 allocation for , as described in Section 2.5.
We shall use to denote the set of items in , and to denote the largest items in , according to the valuation function and breaking ties using the total order specified in Section 2.5. So, allocates precisely one item in to any agent in .
Creating and via Liquidization of Items
We define a liquidization operation over and as follows. Given an item , liquidizing item means splitting into many sufficiently-small items whose total value is , and we call them liquid items. Once an item is liquidized, we update the allocation accordingly. The original items in that were not liquidized are called solid items.
We liquidize all items in in the instance , and let be the new instance. Let be the allocation after liquidization. The set of solid items becomes ; and allocates precisely one solid item to an agent in . Every agent gets the same value in as he gets in ; so the NSW value of is the same as that of . Moreover, is an EF1 allocation for . The liquidization operation can only make the instance easier, and so the optimum NSW value of is at least that of . See Figure 2(a) and 2(b) for an illustration of the liquidization process.
Comparing and Optimum Value of
We now analyze the optimum NSW value of . One can prove that in the optimum solution, every agent gets precisely one solid item: if some agent gets at least solid items, then some agent gets none. We can move one solid item from to and some liquid items from to without decreasing the NSW value.
If , then there are no liquid items; clearly is the optimum allocation. We assume and thus . The optimum solution to the new instance can be obtained by allocating the value of liquid items using the water-filling procedure. Recall that is the unique real such that , which is equivalent to . See Figure 2(c) for an illustration of the optimum solution of and .
So, the logarithm of the optimum NSW value of is precisely
The second equality used that every has . By Theorem 2.2, the logarithm of the NSW of is at least . Therefore, .
Wrapping up the Analysis
We now consider all agents . By linearity of expectation, we have
By the convexity of exponential function, this implies
Recall that is the value of to (2). This leads to a -approximation for the weighted NSW problem.
5 A Simple Proof of the EF1-Gap (Theorem 2.2)
In this section, we give a simple proof of Theorem 2.2. Recall that we are given an unweighted additive NSW instance with identical agents, defined by and , and an EF1 allocation . Let for every be the value allocated to . Let and assume (otherwise ). Let for every .
As in Section 4, we shall liquidize some of the items in the NSW instance. The operations we apply here are slightly different. See Figure 2(d) for the procedure. Focus on each agent . Let be the largest item allocated to in the EF1 allocation. We liquidize all items in . For the item , we first break into two items: one with value and the other with value , and then we liquidize the item of value . So the total value of liquid items allocated to is precisely . This operation is valid as , implied by that is EF1. We remark that liquidizing a portion of the item is crucial for our simplified proof.
After the liquidization operations, remains EF1, and the value allocated to any agent does not change. Moreover, the instance becomes easier, and so can only increase. Therefore, it is sufficient to focus on the current instance. As before, the non-liquid items are called solid items. In the allocation , every agent gets a solid item of value (unless ), and liquid items with total value . So the NSW value of is
As before, we can prove that every agent gets at most one solid item in the optimum solution. Therefore, the optimum allocation is obtained using the water-filling method as before. Let be the unique real such that . We have
See Figure 2(e) for an illustration of the optimum solution.
Comparing and the Value of
Let and . Let and . So , which is equivalent to .
We take logarithm of and the value of , and consider the difference scaled by :
As , and for every , by concavity of logarithm, we have
Therefore,
The second inequality used that for obtains its maximum value at . This proves that
So, . This finishes the proof of Theorem 2.2.
6 Application to Scheduling Problems
In this section, we show that the convex program techniques can be applied to two unrelated machine scheduling problems.
6.1 Scheduling to Minimize
In this section, we consider the unrelated machine scheduling problem with objective , as defined in Section 2.1. Here is an increasing convex function with . It contains the problems of minimizing norm as special cases.
We need to assume the first and second-order derivatives exist and are continuous. By the monotonicity and convexity of , we have for every .
As before, we fix a machine , and an allocation . If , we define to be the unique real such that
If , we define , which also satisfies the above equality.
Then, we define
For every and we define
Lemma 6.1.
For any , , we have
Proof.
Throughout the proof, we fix . We calculate . We assume and for any :
So is continuous over . As for every , by our definition of , we have when and when . So, the function is maximized when . Also, when , we have as .
Corollary 6.2.
is a convex function over its domain.
A similar compact convex program as follows:
| (3) |
We briefly talk about how to approximately solve the convex program in Appendix A. Once we solved the problem, we use the rounding algorithm as described in Section 2.4. To analyze the approximation ratio, we focus on a fixed machine . We construct a scheduling instance with copies of machine , which are indexed by , as described in Section 2.5. Let be the set of jobs in , where each job has processing time . Also created is a EF1 allocation of jobs to machines.222Although in the scheduling problem, we need to minimize loads allocated to machines, envy-freeness is still defined by interpreting jobs as goods.
As in Section 4, we liquidize all jobs in except for the largest job allocated to each . Let be the resulting scheduling instance with identical machines, and be new allocation. remains EF1, and its cost is the same as that of . The optimum cost of is at least that of , which is precisely . We prove the following theorem:
Theorem 6.3.
Consider the identical machine scheduling problem with objective
Assume
If is an EF1 allocation for the scheduling instance with identical machines, then it is -approximate.
Proof.
The notation used in the proof is independent of that used elsewhere. We shall use to denote the set of identical machines, to denote the set of jobs, and to denote the size of a job . We let .
We use similar notations and perform the same liquidization operations as in Section 5. for every machine . , and . After the liquidization operations, each machine gets a solid job of size , and liquid jobs of total size . remains EF1, and its cost does not change. Moreover, the instance only becomes easier and thus the optimum cost only decreases. So, it suffices to focus on the instance obtained after the liquidization operations. The cost of is .
We can assume ; otherwise is optimum and the theorem holds trivially. Let be the unique real such that . We have .
Similarly, we let and . Let and . So , which is equivalent to .
By convexity of , and that for every , we have
Let . Focus on a machine . We have . By the definition of and setting , , we have
Setting and , we have
Therefore
When the objective is the norm of machine loads, we obtain an -approximation algorithm, where
which is the same as the approximation ratio given by [22].
6.2 Weighted Completion Time Minimization with Uniform Smith Ratios
In this section, we consider the unrelated machine weighted completion time minimization problem when jobs have uniform Smith ratios, as defined in Section 2.1. Recall that the cost of an allocation is
So the problem is closely related to the problem of minimizing the norm of machine loads, with the main difference being that we also incur a cost of on machine . The constant does not change the problem. Also, we do not take a square root on the objective in the problem, and this will square the approximation ratio.
We define as in Section 6.1. Treating the function as , we define
Then, the convex program becomes
| (4) |
Once we solve the convex program to obtain a fractional allocation , we use the rounding algorithm of [34] (described in Section 2.4) to obtain an integral allocation of jobs to machines. In the analysis, we fix a machine , and create a scheduling instance with copies of , and an EF1 allocation of . Now all the machines are identical, the term in the objective becomes a fixed term which is independent of the allocation. However, it will affect the approximation ratio and thus can not be removed from the objective.
As before, for every machine , we liquidize every job in except the largest one. After the operation, remains EF1. One minor point is that the liquidization operations will reduce the fixed term in both the cost of , and in the optimum cost. However, reducing the fixed term can only make the approximation ratio worse and thus this is not an issue. Using the same analysis as before, it remains to prove the following theorem:
Theorem 6.4.
Consider a scheduling instance with identical machines. Then any EF1 allocation is -approximate, where .
Proof.
Again, we use and to denote the scheduling instance as in the proof of Theorem 6.3. The notations in the proof are independent of that used elsewhere. We perform the same liquidization operations. Again, the operations can only decrease the fixed term and make the approximation ratio of worse.
Following the same notations as in the proof of Theorem 6.3, we have that the cost of is
We assume . Let be the unique real such that . We have
Similarly, we let and . Let and . So , which is equivalent to .
Then, we consider
For , we have
Since the function is convex, and for every , we have
Therefore,
Now, we let and . Notice that , which implies . Then, we have
| (5) |
We calculate the maximum of the right side of (5) subject to . The quantity is a linear function of for fixed . Therefore, the maximum is achieved when or .
When , the right side of (5) becomes
Therefore, the right side of (5) is at most , which implies . This finishes the proof of the theorem.
References
- [1] Nima Anari, Shayan Oveis Gharan, Amin Saberi, and Mohit Singh. Nash Social Welfare, Matrix Permanent, and Stable Polynomials. In 8th Innovations in Theoretical Computer Science Conference (ITCS 2017), volume 67, pages 36:1–36:12, 2017. doi:10.4230/LIPIcs.ITCS.2017.36.
- [2] Baruch Awerbuch, Yossi Azar, Edward F. Grove, Ming-Yang Kao, P. Krishnan, and Jeffrey Scott Vitter. Load balancing in the L/sub p/norm. In 36th Annual Symposium on Foundations of Computer Science (FOCS 1995), pages 383–391, 1995.
- [3] Yossi Azar and Amir Epstein. Convex Programming for Scheduling Unrelated Parallel Machines. In Proceedings of the 37th Annual ACM Symposium on Theory of Computing (STOC 2005), pages 331–337, 2005. doi:10.1145/1060590.1060639.
- [4] Julius B. Barbanel. The geometry of efficient fair division. Cambridge University Press, 2005.
- [5] Siddharth Barman, Sanath Kumar Krishnamurthy, and Rohit Vaish. Finding Fair and Efficient Allocations. In Proceedings of the 2018 ACM Conference on Economics and Computation (EC 2018), pages 557–574, 2018. doi:10.1145/3219166.3219176.
- [6] Xiaohui Bei, Yuda Feng, Yang Hu, Shi Li, and Ruilong Zhang. Nash Social Welfare with Submodular Valuations: Approximation Algorithms and Integrality Gaps. In Proceedings of the 58th Annual ACM Symposium on Theory of Computing (STOC 2026), 2026.
- [7] Steven J. Brams and Alan D. Taylor. Fair division - from cake-cutting to dispute resolution. Cambridge University Press, 1996.
- [8] Felix Brandt, Vincent Conitzer, Ulle Endriss, Jérôme Lang, and Ariel D. Procaccia, editors. Handbook of Computational Social Choice. Cambridge University Press, 2016.
- [9] Adam Brown, Aditi Laddha, Madhusudhan Reddy Pittu, and Mohit Singh. Approximation Algorithms for the Weighted Nash Social Welfare via Convex and Non-Convex Programs. In Proceedings of the 2024 ACM-SIAM Symposium on Discrete Algorithms (SODA 2024), pages 1307–1327, 2024. doi:10.1137/1.9781611977912.52.
- [10] Suchan Chae and Hervé Moulin. Bargaining Among Groups: An Axiomatic Viewpoint. International Journal of Game Theory, 39(1):71–88, 2010. doi:10.1007/s00182-009-0157-6.
- [11] Richard Cole, Nikhil R. Devanur, Vasilis Gkatzelis, Kamal Jain, Tung Mai, Vijay V. Vazirani, and Sadra Yazdanbod. Convex Program Duality, Fisher Markets, and Nash Social Welfare. In Proceedings of the 2017 ACM Conference on Economics and Computation (EC 2017), pages 459–460, 2017. doi:10.1145/3033274.3085109.
- [12] Richard Cole and Vasilis Gkatzelis. Approximating the Nash Social Welfare with Indivisible Items. SIAM J. Comput., 47(3):1211–1236, 2018. doi:10.1137/15M1053682.
- [13] Dagmawi Mulugeta Degefu, Weijun He, Liang Yuan, An Min, and Qi Zhang. Bankruptcy to surplus: Sharing transboundary river basin’s water under scarcity. Water Resources Management, 32:2735–2751, 2018.
- [14] Yuda Feng, Yang Hu, Shi Li, and Ruilong Zhang. Constant Approximation for Weighted Nash Social Welfare with Submodular Valuations. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing (STOC 2025), pages 1395–1405, 2025. doi:10.1145/3717823.3718203.
- [15] Yuda Feng and Shi Li. A Note on Approximating Weighted Nash Social Welfare with Additive Valuations. In 51st International Colloquium on Automata, Languages, and Programming (ICALP 2024), volume 297, pages 63:1–63:9, 2024. doi:10.4230/LIPIcs.ICALP.2024.63.
- [16] Yuda Feng and Shi Li. A Note on Approximating Weighted Nash Social Welfare with Additive Valuations. TheoretiCS, Volume 4, August 2025. doi:10.46298/theoretics.25.17.
- [17] Jugal Garg, Martin Hoefer, and Kurt Mehlhorn. Satiation in Fisher Markets and Approximation of Nash Social Welfare. Math. Oper. Res., 49(2):1109–1139, 2024. doi:10.1287/MOOR.2019.0129.
- [18] Jugal Garg, Edin Husic, Wenzheng Li, László A. Végh, and Jan Vondrák. Approximating Nash Social Welfare by Matching and Local Search. In Proceedings of the 55th Annual ACM Symposium on Theory of Computing (STOC 2023), pages 1298–1310, 2023. doi:10.1145/3564246.3585255.
- [19] Jugal Garg, Pooja Kulkarni, and Rucha Kulkarni. Approximating Nash Social Welfare under Submodular Valuations through (Un)Matchings. ACM Trans. Algorithms, 19(4):36:1–36:25 (SODA’20), 2023.
- [20] David G. Harris. Dependent rounding with strong negative-correlation, and scheduling on unrelated machines to minimize completion time. In Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2024), pages 2275–2304, 2024. doi:10.1137/1.9781611977912.81.
- [21] Harold Houba, Gerard van der Laan, and Yuyu Zeng. Asymmetric Nash Solutions in the River Sharing Problem. 2013, 2013.
- [22] Sungjin Im and Shi Li. Improved Approximations for Unrelated Machine Scheduling. In Proceedings of the 2023 ACM-SIAM Symposium on Discrete Algorithms (SODA 2023), pages 2917–2946, 2023. doi:10.1137/1.9781611977554.CH111.
- [23] Sungjin Im and Maryam Shadloo. Weighted completion time minimization for unrelated machines via iterative fair contention resolution. In Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms (SODA 2020), pages 2790–2809, 2020. doi:10.1137/1.9781611975994.170.
- [24] Christos Kalaitzis, Ola Svensson, and Jakub Tarnawski. Unrelated Machine Scheduling of Jobs with Uniform Smith Ratios. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2017), pages 2654–2669, 2017. doi:10.1137/1.9781611974782.175.
- [25] VS Kumar, Madhav V Marathe, Srinivasan Parthasarathy, and Aravind Srinivasan. A unified approach to scheduling on unrelated parallel machines. Journal of the ACM (JACM), 56(5):28, 2009.
- [26] Annick Laruelle and Federico Valenciano. Bargaining in Committees as An Extension of Nash’s Bargaining Theory. Journal of Economic Theory, 132(1):291–305, 2007. doi:10.1016/j.jet.2005.05.004.
- [27] Euiwoong Lee. APX-hardness of maximizing Nash social welfare with indivisible items. Inf. Process. Lett., 122:17–20, 2017. doi:10.1016/J.IPL.2017.01.012.
- [28] Shi Li. Approximating Unrelated Machine Weighted Completion Time Using Iterative Rounding and Computer Assisted Proofs. In Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2025), pages 553–571, 2025. doi:10.1137/1.9781611978322.17.
- [29] Wenzheng Li and Jan Vondrák. Estimating the Nash Social Welfare for coverage and other submodular valuations. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA 2021), pages 1119–1130, 2021. doi:10.1137/1.9781611976465.69.
- [30] Hervé Moulin. Fair division and collective welfare. MIT Press, 2003.
- [31] Nhan-Tam Nguyen, Trung Thanh Nguyen, Magnus Roos, and Jörg Rothe. Computational complexity and approximability of social welfare optimization in multiagent resource allocation. Auton. Agents Multi Agent Syst., 28(2):256–289, 2014. doi:10.1007/S10458-013-9224-2.
- [32] Jack M. Robertson and William A. Webb. Cake-cutting algorithms - be fair if you can. A K Peters, 1998.
- [33] Jörg Rothe, editor. Economics and Computation, An Introduction to Algorithmic Game Theory, Computational Social Choice, and Fair Division. Springer texts in business and economics. Springer, 2016.
- [34] David B Shmoys and Éva Tardos. An approximation algorithm for the generalized assignment problem. Mathematical programming, 62(1-3):461–474, 1993. doi:10.1007/BF01585178.
- [35] William Thomson. Replication Invariance of Bargaining Solutions. Int. J. Game Theory, 15(1):59–63, March 1986. doi:10.1007/BF01769276.
- [36] H. Peyton Young. Equity - in theory and practice. Princeton University Press, 1995.
- [37] S. Yu, E. C. van Ierland, H. P. Weikard, and X. Zhu. Nash Bargaining Solutions for International Climate Agreements under Different Sets of Bargaining Weights. International Environmental Agreements: Politics, Law and Economics, 17(5):709–729, 2017. doi:10.1007/s10784-017-9351-3.
Appendix A Solving Convex Programs CP(3) Approximately
Convex program can be solved within an additive error of for any given under some mild requirements. For our convex program CP(3), we can convert it to a linear program using the discretization technique. Due to the existence of the function , it is convenient for us to impose approximation on job sizes.
For every , we let and , then we have . Let and we use as an approximation of . Then, we can use functions ’s to replace ’s in CP(3), and the new convex program can be explicitly formulated as a polynomial-size linear program.
We define in the same way as we define , except that we use the processing times for all . The main lemma we prove is
Lemma A.1.
for every .
Proof.
holds trivially. So we only need to prove the first inequality. For notational convenience, we use to denote . Let be the largest number in with . Then, we have .
We explain the inequality. By monotonicity and convexity of ,
Also, as . Finally, as and .
For functions with moderate growth (including the case where for a constant ), the lemma suffices to solve CP(3) up to arbitrary precision.
