Abstract 1 Introduction 2 Preliminaries 3 The Convex Program 4 Analysis of Rounding Algorithm for CP(2): Proof of Theorem 1.1 5 A Simple Proof of the 𝒆𝟏/𝒆 EF1-Gap (Theorem 2.2) 6 Application to Scheduling Problems References Appendix A Solving Convex Programs CP(3) Approximately

New Convex Programming Technique for Nash Social Welfare and Scheduling

Yuda Feng ORCID School of Computer Science, Nanjing University, China    Weijiang Hu ORCID School of Computer Science, Nanjing University, China    Shi Li ORCID School of Computer Science, Nanjing University, China
Abstract

We propose a new convex programming relaxation for the weighted Nash social welfare (NSW) problem that achieves a matching (e1/e1.445)-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 ln(1+ϵ) 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 e1/e. With a minor modification, our analysis also gives a simple proof of the e1/e 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, Scheduling
Category:
Track A: Algorithms, Complexity and Games
Copyright and License:
[Uncaptioned image] © Yuda Feng, Weijiang Hu, and Shi Li; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Approximation algorithms analysis
; Theory of computation Mathematical optimization
Related Version:
Preprint: https://arxiv.org/abs/2604.24120
Funding:
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 Puppis

1 Introduction

We study the problem of allocating a set M of m indivisible items to a set N of n agents so as to maximize the weighted Nash social welfare (NSW) of the allocation. Each agent iN is associated with a weight wi>0, with iNwi=1. Each item jM has a value vij0 for agent iN. The goal is to find an allocation ρ:MN of items to agents that maximizes the weighted Nash Social Welfare, defined as the weighted geometric mean of agents’ valuations:

iNvi(ρ1(i))wi,

where vi(ρ1(i))=jρ1(i)vij denotes the value of the bundle allocated to i, according to i’s valuation. When wi=1/n for every agent iN, 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 8/71.069.

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 (2e1/e+ϵ2.889+ϵ)-approximation. The approximation ratio was subsequently improved by Cole, Devanur, Gkatzelis, Jain, Mai, Vazirani and Yazdanbod [11] to 2. Independently, Anari, Gharan, Saberi and Singh [1] developed an e-approximation for the problem using a convex program relaxation based on real stable polynomials.

The current best-known approximation factor for the problem is e1/e 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 (e1/e1.445)-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 5exp(2DKL(w||1n))=5exp(2logn+2iNwilogwi) 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 (e1/e+ϵ)-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 e1/e-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 ln(1+ϵ) 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.

The convex program CP(2), where fi’s are defined as in (1), has an integrality gap of at most e1/e. Moreover, there is an efficient rounding algorithm that, given a solution x to CP(2), outputs an allocation with weighted NSW value at least e1/e times the value of x.

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 e1/e. Combined with the e1/e lower bound by [11], this shows that the integrality gap of CP(f-SR) is exactly e1/e.

Theorem 1.2.

For the unweighted Nash social welfare problem, the value of CP(2) is the same as that of CP(f-SR).

Corollary 1.3.

The integrality gap of both CP(2) and CP(f-SR) is precisely e1/e.

With a slight modification of our analysis, we obtain a simple proof of the e1/e 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 Lq 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 1+22 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 fi:[0,1]M0 for each agent iN, and aim to maximize iNwifi(xi), where xi[0,1]M denotes the fractional allocation of items to agent i.

The strongest choice for fi is the concave closure of the discrete function mapping xi{0,1}M to lnjvijxij. This corresponds to the configuration LP introduced by Feng and Li [16], where fi(xi) is defined as the maximum of SMαSlnvi(S) over all convex combination decompositions SMαSχS of xi, where χS{0,1}M is the indicator vector for S.

On the opposite side, if all items are assumed to be infinitely divisible, allowing configuration to contain portions of items, then fi(xi) is maximized when all configurations have the same value. In this case, the function simplifies to fi(xi)=lnjvijxij, which preserves the original formula but extends its domain to [0,1]M.

Our approach lies between these two extremes. We only treat the largest 1 fractional item of maximum value vij in xi 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 fi is defined as the average logarithm of the value of these configurations. We show that our fi is concave by expressing it as the minimum of linear functions. This is sufficient to recover the e1/e 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 fi’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 iN is associated with a monotone submodular valuation function vi:2M0, and the goal remains to find an allocation ρ:MN that maximizes iNvi(ρ1(i))wi. As in the additive case, we have the unweighted submodular NSW problem, where all agents have weights 1/n, and the weighted submodular NSW problem, where the weight vector w can be any vector in [0,1]N satisfying iNwi=1.

In the unweighted case, the current best-known inapproximability for submodular NSW is e/(e1)1.582, proved by Garg, Kulkarni and Kulkarni [19], even when the number of agents is a constant.

Algorithmically, the first O(1)-approximation for unweighted submodular NSW was obtained by Li and Vondrák [29] via convex programming, with an approximation ratio of e3/(e1)2. Subsequently, Garg, Husic, Li, Végh and Vondrák [18] introduced an elegant local-search method that improved the approximation ratio to 4 for the unweighted case. The same framework also yields an O(nwmax)-approximation for the weighted case [18], where wmax=maxiNwi.

Whether one can obtain an O(1)-approximation remained open. This was resolved by Feng, Hu, Li and Zhang [14], who developed a 233-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 3.56-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 e/(e1) 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 Lq norm of machine loads (q1), Im and Li [22] obtained an approximation ratio of Oq(1)-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 q=2 is 4/31.155.

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 1.36+ϵ 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 1+22-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 e1/e 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 ij with 0 value. So in our definition of the problem, we are given a set N of n agents, each iN with a weight wi(0,1] subject to iNwi=1, a set M of m items, a set EN×M of edges, along with a value vij>0 for every ijE. We assume every iN or jM is incident to at least one edge in E. Let Mi:={jM:ijE} for every iN and Nj={iN:ijE} for every jM. Our goal is to find an allocation ρ:MN such that ρ(j)jE for every jM, so as to maximize iNvi(ρ1(i))wi, where we use vi(M):=jMvij for every iN and MMi. In the unweighted Nash Social Welfare problem, we have wi=1n for every iN.

We shall consider the following general unrelated machine scheduling problem. There is a set M of m machines, a set J of n jobs, a size pij>0 for every iM and jJ. We are given an increasing convex function θ:00 with θ(0)=0. Our goal is to find an allocation ρ:JM so as to minimize iMθ(loadi), where loadi:=qi(ρ1(i)) and qi(J):=jJpij for every JJ. We call the problem the unrelated machine scheduling problem with iMθ(loadi) objective.111We remark the notation change from NSW problems to scheduling problems. In both settings we need to allocate some objects to some players. M denotes the objects (items) in NSW problems, and players (machines) in scheduling problems. We always have m=|M|. n is the number of players (n=|N|) in NSW problems, and number of objects (n=|J|) in scheduling problems. When θ(x)=xq for q1, the objective becomes the Lq norm, after taking the q-th root of the objective.

In the unrelated machine scheduling with weighted completion time objective and uniform Smith ratios, we are given M,m,J,n and (pij>0)iM,jJ as in the previous problem. Our goal is to find an allocation ρ:JM so as to minimize

12iM(pi(ρ1(i))2+jρ1(i)pij2).

When a job j is allocated to i=ρ(j), it has processing time pij and weight pij. Namely, the Smith ratio of any job on any machine is always 1. On every machine iM, the weighted completion time of scheduling ρ1(i) on i is 12(pi(ρ1(i))2+jρ1(i)pij2). As all jobs have the same Smith ratio, any permutation of jobs is optimum. The objective is closely related to the L2 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 n identical agents N, and m indivisible items M. As the valuation functions are identical, we simply use vj to denote the value of item j for any agent iN.

Definition 2.1.

An allocation σ:MN of items to agents is said to be envy-free up to 1 item (EF1) if for every two agents i,iN, we have v(σ1(i))v(σ1(i))max{vj:jσ1(i)}.

So in an EF1 allocation σ, for any pair i,i of agents, i does not envy i once we remove the largest item in the bundle of agent i. [5] proved the following theorem:

Theorem 2.2 ([5]).

Consider an unweighted NSW instance with identical agents, defined by n,N,m,M and v. Let σ be an EF1 allocation, and opt be the optimum NSW value of the instance. Then, we have

(iNvi(σ1(i)))1/ne1/eopt.

The e1/e 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 e1/e 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:

max1n(ijEbijlnvijjMqjlnqj) (f-SR)
iNjbij=qj,jM;jMibij=1,iN;bij0,ijE;qj1,jM.

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 ρ:MN for the instance. Then, we define bij=vijvi(ρ1(i)) if i=ρ(j) and bij=0 otherwise. qj=bρ(j)j. This gives us a valid solution to CP(f-SR). The logarithm of the NSW of ρ is

1niNlnv(ρ1(i)) =1niNjMibijlnvijqj=1n(ijEbijlnvijijEbijlnqj)
=1n(ijEbijlnvijjMlnqj),

which is exactly the objective of CP(f-SR).

[12] proved the following lemma:

Lemma 2.3.

With a scaling of the valuation functions vi,iN, there exists a price vector p>0M such that the following conditions hold for the optimum solution (b,q) to CP(f-SR):

  • qj=min{pj,1} for every jM.

  • vijpj for every ijE.

  • If vij<pj for some ijE, then bij=0.

The lemma says that one can define prices pj for items so that the value of an item j to any agent is at most its price. So the bang-per-buck (BaB) for any ij pair is at most 1. Moreover, in the solution (b,q), i will only be allocated items with BaB exactly 1. When agent i gets a value bij from item j, he pays $bij to j. Every agent i spends $1, and the money spent on any item j is $qj:=min{$pj,$1}. 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 x[0,1]E of items to agents: we have iNjxij=1 for every jM. We further have jMixij1 for every iN since otherwise the value of the solution x will be 0. (This property does not hold for scheduling problems, and it is not required by the rounding algorithm.) Throughout, for the given x, we shall use xi:=(xij)jMi to denote the fractional allocation for agent i.

For each agent iN, we sort items in Mi by non-increasing vij and partition the fractional items xi into qi:=jMixij groups Gi={zi,1,zi,2,,zi,qi[0,1]Mi} using this order, each containing 1 fractional item except for the last one. Here each zi,t is a fractional bundle over Mi with |zi,t|11, and for each jMi, zji,t denotes the fraction of item j contained in zji,t. More formally, we define a total order i over Mi that sorts the items in non-increasing order of vij with ties broken arbitrarily. Thus, jij implies vijvij. Then zi,1,zi,2,,zi,qi are vectors in [0,1]Mi satisfying the following properties:

  • t=1qizi,t=xi.

  • |zi,t|1=1 for every t=1,2,,qi1.

  • For any two integers t,t with 1t<tqi and two items j,jMi with jij, it can not happen that zji,t>0 and zji,t>0.

Notice that under the above 3 conditions, the choice of (zi,1,zi,2,,zi,qi) is unique.

This yields a collection G=iGi of groups and a fractional matching between the groups G and items M: every group zG is matched to an item j with fraction zj (or 0 if j is not in the domain of z). So each group z is matched to an extent of |z|1, and each item is matched to an extent of 1. By the way we construct the groups, a group which is not the last group for an agent i is matched to an extent of 1.

In the randomized rounding algorithm, we arbitrarily partition the fractional matching into a convex combination of (partial-)matchings between G and M 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 jM is allocated to the agent i if it is matched to a group in Gi. Marginal probabilities are maintained by the rounding algorithm: the probability that an item j is allocated to an agent i is precisely xij for any ijE.

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 i most of the time. We create an unweighted NSW instance with identical agents, which are all copies of the agent i, and an EF1 allocation σ for .

Let Δ be a sufficiently large integer such that Pr[ρ1(i)=S] for every S is an integer multiple of 1/Δ, so is xij for every jMi. We create Δ copies of the agent i, and index them as [Δ]. We create Δxij copies of item j for every jMi. The allocation σ is defined according to the output distribution of the rounding algorithm: for every SMi, there are precisely ΔPr[ρ1(i)=S] agents in [Δ] who gets a copy of S, 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 e1/e-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 e1/e.

For every iN, and xi[0,1]Mi satisfying |xi|11, we define hi(xi) to be any real h>0 satisfying

jMimin{vij,h}xij=h.

If |xi|1>1, the choice of hi(xi) is unique, which can be determined by the following procedure. Let xi[0,1]Mi be the vector that maximizes jMivijxij subject to xixi,|xi|=1. In other words, xi consists of the largest one fractional item in xi. We construct a histogram for xi, where every item jMi is represented by a rectangle of width xij and height vij. Let V:=jMi(xijxij)vij denote the total value of remaining fractional items. Treating this value as V units of water, we pour the water into the histogram from bottom to top. Then hi(xi) is the resulting water level. See Figure 1 for illustration of the definition. When |xi|1=1, no water is poured, and hi(xi) can be any real number in (0,min{vij:jMi,xij>0}].

Figure 1: Definition of hi(xi) and fi(xi) when |xi|1>1. The dark gray part denotes the 1 fractional largest items in xi. The light gray part denotes the V units of water. fi(xi) is the average height of the histogram on a logarithmic scale.

With hi(xi) defined, we define fi(xi) as follows:

fi(xi):=jMi:vij>hi(xi)xijlnvijhi(xi)+lnhi(xi). (1)

So, fi(xi) is the average height of the histogram in Figure 1 on a logarithmic scale. Notice that when |xi|=1, we have fi(xi)=jMixijlnvij, which is independent of the choice of hi(xi).

We give an alternative description of fi(xi) which will prove the concavity of the function. For every iN,xi[0,1]Mi with |xi|1 and h>0, we define

gi(xi,h):=jMi:vij>hxijlnvijh+lnh+1hjMimin{vij,h}xij1.

Notice that for a fixed h, the function gi is linear in xi.

Lemma 3.1.

For any iN, xi[0,1]Mi satisfying |xi|11, we have

fi(xi)=minh>0gi(xi,h)=gi(xi,hi(xi)).
Proof.

We calculate gih for any hvij for any jMi:

gih =jMi:vij>h(xijh)+1hjMi:vij<hvijxijh2=1h1h2jMixijmin{vij,h}
=1h2(hjMixijmin{vij,h}).

So, the derivative is continuous on h>0. Moreover, gih0 when h<hi(xi) and gih0 when h>hi(xi). So, the function is minimized when h=hi(xi). Moreover, when h=hi(xi), we have gi(xi,h)=fi(xi) as jMimin{vij,hi(xi)}xij=hi(xi).

As gi(xi,h) is a linear function of xi for any fixed h>0, we have

Corollary 3.2.

fi is concave over its domain.

Our convex program can simply be written as follows:

maxiNwifi(xi) (2)
jMixij1,iN;iNjxij=1,jM;xij0,ijE.

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 ln(1+ϵ) for any constant ϵ>0. For every iN, we let i:=min{vij:jMi} and ri:=jMivij, so that we always have hi(xi)[i,ri]. (In case |xi|=1, we can choose hi(xi)=min{vij:jMi,xij>0}.) Then, let Hi={ri(1+ϵ)ti:t0}. We shall use

f¯i(xi):=minhHigi(xi,h)

as an approximation of fi(xi).

Lemma 3.3.

fi(xi)f¯i(xi)<fi(xi)+ln(1+ϵ) for every xi[0,1]Mi with |xi|11.

Proof.

fi(xi)f¯i(xi) holds trivially and so we only need to prove the second inequality. Let h¯ be the smallest number in Hi with h¯hi(xi). Then, we have hi(xi)h¯<(1+ϵ)hi(xi). From the proof of Lemma 3.1, we know gih1h. So, we have gi(xi,h¯)gi(xi,hi(xi))hi(xi)h¯1h𝖽h=lnh¯hi(xi)<ln(1+ϵ). The lemma follows from that f¯i(xi)gi(xi,h¯) and fi(xi)=gi(xi,hi(xi)).

Therefore, we can consider the new convex program where the objective is to maximize iNwif¯i(xi). The new convex program can be reformulated explicitly as a polynomial-sized linear program: we change our objective function to iNwif¯i, and add linear constraints f¯igi(xi,h) for every iN and hHi 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 x[0,1]E to CP(2), we convert it to a valid solution to CP(f-SR), with value at least that of x to CP(2).

By scaling the valuation functions, we assume hi(xi)=1 for every iN. We construct a solution to CP(f-SR) as follows:

bij:=xijmin{vij,1},ijE,andqj:=iNjbij,jM.

For every jM, we have qjiNjxij=1. For every iN, we have jMibij=jMixijmin{vij,1}=1, by the definition of hi(xi) and that hi(xi)=1. Therefore, the solution (b,q) to CP(f-SR) is valid.

We now compute the value of (b,q) to CP(f-SR). Observe that for every jM, iNjbijqj=1 and iNjbijqj1min{vij,1}=iNjxijqj=1qj. By the concavity of the logarithm function ln(), we obtain iNjbijqjln1min{vij,1}ln1qj, which is equivalent to

iNjbijlnmin{vij,1}qjlnqj.

So, we have

ijEbijlnvij =ijEbijlnmin{vij,1}+ijE:vij>1bijlnvij
jMqjlnqj+ijE:vij>1xijlnvij=jMqjlnqj+iNfi(xi),

by the definition of fi(xi) and that hi(xi)=1. Therefore,

1n(ijEbijlnvijjMqjlnqj)1niNfi(xi).

Now we prove that the value of CP(f-SR) is at most that of CP(2). Let (q,b) be the optimum solution to CP(f-SR). We scale the valuation functions as stated in Lemma 2.3, and let p>0M be the price vector from the lemma. We construct a solution x[0,1]E to CP(2) whose value is at least that of (q,b). The definition of x is simple:

xij:=bijqj,ijE.

For every jM, we have iNjxij=iNjbijqj=1. For every iN, we have jMixij=jMibijqjjMibij=1. So, x is a valid solution to CP(2).

Focus on any agent iN. We have

jMimin{vij,1}xij=jMimin{pj,1}xij=jMiqjxij=jMibij=1.

The first equality follows from the third property in Lemma 2.3, and the second equality follows from the first property. Hence, we have hi(xi)=1. (The choice is unique for if |xi|1>1, and it is valid if |xi|1=1.) So,

fi(xi)=jMi:vij>1xijlnvij=jMi:pj>1bijlnvij=jMibijlnvijqj.

The first equality is by the definition of fi(xi) and that hi(xi)=1, the second one is by that if xij>0 and vij>1, then vij=pj>1 and qj=1, and the third one is by that qj=min{pj,1} and that bij>0 implies vij=pj.

So,

1niNfi(xi)=1nijEbijlnvijqj=1n(ijEbijlnvijjMqjlnqj).

4 Analysis of Rounding Algorithm for CP(2): Proof of Theorem 1.1

After solving CP(2) up to an additive error of ln(1+ϵ), we obtain the fractional solution x[0,1]E. 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 e1/e, 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 iN. Then, we create an unweighted NSW instance with Δ copies of agents i (indexed by [Δ]), and an EF1 allocation σ for , as described in Section 2.5.

We shall use M to denote the set of items in , and M′′M to denote the Δ largest items in M, according to the valuation function vi and breaking ties using the total order i specified in Section 2.5. So, σ allocates precisely one item in M′′ to any agent in [Δ].

Figure 2: Liquidization Operations in Analysis of Rounding Algorithm in Section 4 and Proof of the EF1-Gap (Theorem 2.2) in Section 5. Each rectangle represents a solid item, with height indicating its value. Gray solid polygons represent liquid items. Each column represents an agent, and the rectangles and the gray area in the column correspond the solid and liquid items allocated to the agent. All agents are identical. Figure (a) denotes the instance and the EF1-allocation σ created in Section 4. Figure (b) denotes the instance obtained from after liquidization operations and the allocation σ. Figure (c) shows the optimum solution for . Figure (d) denotes the liquidized instance for when we try to prove σ is e1/e-approximate in Section 5. Figure (e) denotes the optimum solution for the instance. ϕi’s, ψ,h,N1 and N2 are depicted in Figures (d) and (e).

Creating 𝓘 and 𝝈 via Liquidization of Items

We define a liquidization operation over and σ as follows. Given an item j, liquidizing item j means splitting j into many sufficiently-small items whose total value is vj, 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 MM′′ in the instance , and let be the new instance. Let σ be the allocation σ after liquidization. The set of solid items becomes M′′; and σ allocates precisely one solid item to an agent in [Δ]. Every agent i[Δ] 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 i gets at least 2 solid items, then some agent i′′ gets none. We can move one solid item from i to i′′ and some liquid items from i′′ to i without decreasing the NSW value.

If M=M′′, then there are no liquid items; clearly σ is the optimum allocation. We assume M′′M and thus vi(MM′′)>0. The optimum solution to the new instance can be obtained by allocating the vi(MM′′) value of liquid items using the water-filling procedure. Recall that hi(xi) is the unique real h such that jMizji,1min{vij,h}+jMi(xijzji,1)vij=h, which is equivalent to 1ΔjM′′min{vij,h}+1Δvi(MM′′)=h. See Figure 2(c) for an illustration of the optimum solution of and hi(xi).

So, the logarithm of the optimum NSW value of is precisely

1ΔjM′′lnmax{vij,hi(xi)}
=jM′′:vij>hi(xi)1Δlnvijhi(xi)+lnhi(xi)
=jM:vij>hi(xi)1Δlnvijhi(xi)+lnhi(xi)
=jMi:vij>hi(xi)xijlnvijhi(xi)+lnhi(xi)=fi(xi).

The second equality used that every jMM′′ has vijhi(xi). By Theorem 2.2, the logarithm of the NSW of σ is at least fi(xi)1e. Therefore, 𝔼[lnvi(ρ1(i))]fi(xi)1e.

Wrapping up the Analysis

We now consider all agents iN. By linearity of expectation, we have

𝔼[iNwilnvi(ρ1(i))]iNwifi(xi)1e.

By the convexity of exponential function, this implies

𝔼[iNvi(ρ1(i))wi]e1/eexp(iNwifi(xi)).

Recall that iNwifi(xi) is the value of x to (2). This leads to a e1/e(1+ϵ)-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 N,n,M,m and v, and an EF1 allocation σ. Let Vi:=v(σ1(i)) for every iN be the value allocated to i. Let ψ:=miniNVi and assume ψ>0 (otherwise opt=0). Let ϕi=Viψ0 for every iN.

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 iN. Let j be the largest item allocated to i in the EF1 allocation. We liquidize all items in σ1(i)j. For the item j, we first break j into two items: one with value ϕi and the other with value vjϕi, and then we liquidize the item of value vjϕi. So the total value of liquid items allocated to i is precisely vjϕi+(Vivj)=ψ. This operation is valid as Vivjψ, implied by that σ is EF1. We remark that liquidizing a portion of the item j 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 opt 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 i gets a solid item of value ϕi (unless ϕi=0), and liquid items with total value ψ. So the NSW value of σ is

(iN(ϕi+ψ))1/n.

As before, we can prove that every agent i gets at most one solid item in the optimum solution. Therefore, the optimum allocation is obtained using the water-filling method as before. Let h>0 be the unique real such that 1niNmin{ϕi,h}+ψ=h. We have

opt=(iNmax{ϕi,h})1/n.

See Figure 2(e) for an illustration of the optimum solution.

Comparing 𝐨𝐩𝐭 and the Value of 𝝈

Let N1={iN:ϕi>h} and N2:=NN1={iN:ϕih}. Let n1=|N1| and n2=|N2|=nn1. So h=1niNmin{ϕi,h}+ψ=1n(iN1h+iN2ϕi)+ψ, which is equivalent to n2h=nψ+iN2ϕi.

We take logarithm of opt and the value of σ, and consider the difference scaled by n:

iNlnmax{ϕi,h}iNln(ϕi+ψ)
=iN1lnϕiϕi+ψ+iN2lnhϕi+ψiN2lnhϕi+ψ.

As iN2ϕi=n2hnψ, and ϕi[0,h] for every iN2, by concavity of logarithm, we have

iN2ln(ϕi+ψ) n2hnψhln(h+ψ)+nψhlnψ
(n2nψh)lnh+nψhlnψ=n2lnhnψhlnhψ.

Therefore,

iN2lnhϕi+ψnψhlnhψne.

The second inequality used that 1xlnx for x1 obtains its maximum value 1e at x=e. This proves that

iNlnmax{ϕi,h}iNln(ϕi+ψ)ne.

So, (iNmax{ϕi,h})1/ne1/e(iN(ϕi+ψ))1/n. 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 𝒊𝑴𝜽(load𝒊)

In this section, we consider the unrelated machine scheduling problem with objective iMθ(loadi), as defined in Section 2.1. Here θ:00 is an increasing convex function with θ(0)=0. It contains the problems of minimizing Lq norm as special cases.

We need to assume the first and second-order derivatives θ,θ′′:00 exist and are continuous. By the monotonicity and convexity of θ, we have θ(t),θ′′(t)0 for every t>0.

As before, we fix a machine iM, and an allocation xi[0,1]J. If |xi|1>1, we define hi(xi) to be the unique real h>0 such that

jJmin{pij,h}xij=h.

If |xi|11, we define hi(xi)=0, which also satisfies the above equality.

Then, we define

fi(xi):=jJ:pij>hi(xi)xij(θ(pij)θ(hi(xi)))+θ(hi(xi)).

For every xi[0,1]J and h0 we define

gi(xi,h):=jJ:pij>hxij(θ(pij)θ(h))+θ(h)+θ(h)(jJmin{pij,h}xijh).
Lemma 6.1.

For any iN, xi[0,1]J, we have

fi(xi)=maxh>0gi(xi,h)=gi(xi,hi(xi)).
Proof.

Throughout the proof, we fix xi. We calculate gih. We assume h>0 and hpij for any jJ:

gih =jJ:pij>hxijθ(h)+θ(h)
+θ′′(h)(jJmin{pij,h}xijh)+θ(h)(jJ:pij>hxij1)
=θ′′(h)(jJmin{pij,h}xijh).

So gih is continuous over (0,). As θ′′(h)0 for every h>0, by our definition of hi(xi), we have gih0 when h<hi(xi) and gih|h0 when h>hi(xi). So, the function is maximized when h=hi(xi). Also, when h=hi(xi), we have gi(xi,h)=fi(xi) as jJmin{pij,hi(xi)}xij=hi(xi).

Corollary 6.2.

fi is a convex function over its domain.

A similar compact convex program as follows:

miniMfi(xi) (3)
iMxij=1,jJ;xij0,iM,jJ.

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 iM. We construct a scheduling instance with Δ copies of machine i, which are indexed by [Δ], as described in Section 2.5. Let J be the set of n:=|J| jobs in , where each job jJ has processing time pj:=pij. Also created is a EF1 allocation σ:J[Δ] 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 i[Δ]. 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 fi(xi). We prove the following theorem:

Theorem 6.3.

Consider the identical machine scheduling problem with objective

iMθ(loadi).

Assume

α:=supt(0,1),d0rd/(1t)tθ(r+d)+(1t)θ(d)tθ(r)+(1t)θ(d1t)<.

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 M to denote the set of identical machines, J to denote the set of jobs, and pj>0 to denote the size of a job jJ. We let m=|M|.

We use similar notations and perform the same liquidization operations as in Section 5. Pi:=p(σ1(i)) for every machine iM. ψ:=miniMPi, and ϕi:=Piψ. After the liquidization operations, each machine i gets a solid job of size ϕi, 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 iMθ(ϕi+ψ).

We can assume ψ>0; otherwise σ is optimum and the theorem holds trivially. Let h be the unique real such that 1miMmin{ϕi,h}+ψ=h. We have opt=iMθ(max{ϕi,h}).

Similarly, we let M1={iM:ϕi>h} and M2=MM1={iM:ϕih}. Let m1=|M1| and m2=|M2|=mm1. So h=1niMmin{ϕi,h}+ψ=1m(iM1h+iM2ϕi)+ψ, which is equivalent to m2h=mψ+iM2ϕi.

By convexity of θ, and that ϕi[0,h] for every iM2, we have

iM2θ(ϕi+ψ) m2hmψhθ(h+ψ)+mψhθ(ψ)
=(m2mψh)θ(h+ψ)+mψhθ(ψ).

Let t=1ψh. Focus on a machine iM1. We have ϕi>h=ψ/(1t). By the definition of α and setting d=ψ, r=ϕi, we have

tθ(ϕi+ψ)+(1t)θ(ψ)α(tθ(ϕi)+(1t)θ(h)).

Setting d=ψ and r=h, we have

tθ(h+ψ)+(1t)θ(ψ)α(tθ(h)+(1t)θ(h))=αθ(h).

Therefore

iMθ(ϕi+ψ) =iM1θ(ϕi+ψ)+iM2θ(ϕi+ψ)
iM1θ(ϕi+ψ)+(m2mψh)θ(h+ψ)+mψhθ(ψ)
=iM1θ(ϕi+ψ)+(mtm1)θ(h+ψ)+m(1t)θ(ψ)
=iM11t(tθ(ϕi+ψ)+(1t)θ(ψ))
+(mm1t)(tθ(h+ψ)+(1t)θ(ψ))
iM1αt(tθ(ϕi)+(1t)θ(h))+α(mm1t)θ(h)
=αiM1θ(ϕi)+α(m1(1t)t+mm1t)θ(h)
=αiM1θ(ϕi)+αm2θ(h)
=α(iM1θ(ϕi)+iM2θ(h))
=αiMθ(max{ϕi,h}).

When the objective is the Lk norm of machine loads, we obtain an α1/k-approximation algorithm, where

α =supt(0,1);d0;rd1tt(r+d)k+(1t)dktrk+(1t)(d1t)k
=supt(0,1);y(0,1]t(1+y(1t))k+(1t)(y(1t))kt+(1t)yk,by setting y=d(1t)r

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 ρ:JM is

12iM(jρ1(i)pij2+(jρ1(i)pij)2).

So the problem is closely related to the problem of minimizing the L2 norm of machine loads, with the main difference being that we also incur a cost of jρ1(i)pij2 on machine i. The constant 12 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 hi(xi) as in Section 6.1. Treating the function θ as θ(t)=t2, we define

fi(xi):=jJ:pij>hi(xi)xij(pij2hi(xi)2)+hi(xi)2.

Then, the convex program becomes

min12iM(fi(xi)+jJxijpij2) (4)
iMxij=1,jJ;xij0,iM,jJ.

Once we solve the convex program to obtain a fractional allocation x[0,1]M×J, we use the rounding algorithm of [34] (described in Section 2.4) to obtain an integral allocation ρ:JM of jobs to machines. In the analysis, we fix a machine iM, and create a scheduling instance with Δ copies of i, and an EF1 allocation σ of . Now all the machines are identical, the term 12i[Δ],jρ1(j)pij2 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 i[Δ], we liquidize every job in σ1(i) 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 α=2+12.

Proof.

Again, we use M,m,J,n and (pj)jJ 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

cost(σ):=12iM((ϕi+ψ)2+ϕi2).

We assume ψ>0. Let h be the unique real such that 1miMmin{ϕi,h}+ψ=h. We have

opt=12iM(max{ϕi,h}2+ϕi2).

Similarly, we let M1={iM:ϕi>h} and M2=MM1={iM:ϕih}. Let m1=|M1| and m2=|M2|=mm1. So h=1niMmin{ϕi,h}+ψ=1m(iM1h+iM2ϕi)+ψ, which is equivalent to m2h=mψ+iM2ϕi.

Then, we consider

2(cost(σ)αopt) =iM((ϕi+ψ)2+ϕi2)αiM12ϕi2αiM2(h2+ϕi2)
=iM1((ϕi+ψ)2(2α1)ϕi2)
+iM2((ϕi+ψ)2(α1)ϕi2)αm2h2.

For iM1, we have

(ϕi+ψ)2(2α1)ϕi2 =2(α1)ϕi2+2ψϕi+ψ2
ψ2+(2ψ)242(α1)=2α12(α1)ψ2.

Since the function (x+ψ)2(α1)x2 is convex, iM2ϕi=m2hmψ and ϕi[0,h] for every iM2, we have

iM2((ϕi+ψ)2(α1)ϕi2)
(m2mψh)((h+ψ)2(α1)h2)+mψhψ2.

Therefore,

2(cost(σ)αopt) 2α12(α1)m1ψ2
+(m2mψh)((h+ψ)2(α1)h2)+mψhψ2αm2h2.

Now, we let a=ψh[0,1] and b=m1m[0,1]. Notice that m2hmψ, which implies a=ψhm2m=1b. Then, we have

2(cost(σ)αopt)mh2 2α12(α1)a2b+(1ba)((1+a)2(α1))+a3α(1b). (5)

We calculate the maximum of the right side of (5) subject to a0,b0,a+b1. The quantity is a linear function of b for fixed a. Therefore, the maximum is achieved when b=0 or b=1a.

When b=0, the right side of (5) becomes

(1a)((1+a)2(α1))+a3α=(2a2)(2a)α=a2+αa(2(α1))
2(α1)+α24=3+2216(21)=1914216<0.

When b=1a, the right side of (5) becomes

2α12(α1)a2(1a)+a3αa=12(α1)a3+2α12(α1)a2αa
=a2(α1)(a2+(2α1)a2α(α1))

Then,

a2+(2α1)a2α(α1) 2α(α1)+(2α1)24=α2+α+14=0,

as α=2+12 is a root of the equation α2α14=0.

Therefore, the right side of (5) is at most 0, which implies cost(σ)αopt0. 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 ϵ>0 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 iN, we let i:=min{pij:jJ} and ri:=jJpij, then we have hi(xi)={0}[i,ri]. Let Hi={0}{i(1+ϵ)tri:t0} and we use f¯i(xi):=maxhHig(xi,h) as an approximation of fi(xi). Then, we can use functions f¯i’s to replace fi’s in CP(3), and the new convex program can be explicitly formulated as a polynomial-size linear program.

We define fi(xi;11+ϵ) in the same way as we define fi(xi), except that we use the processing times pij1+ϵ for all jJ. The main lemma we prove is

Lemma A.1.

fi(xi;11+ϵ)f¯i(xi)fi(xi) for every xi[0,1]J.

Proof.

f¯i(xi)fi(xi) holds trivially. So we only need to prove the first inequality. For notational convenience, we use hi to denote hi(xi). Let h¯ be the largest number in Hi with h¯hi. Then, we have hi1+ϵ<h¯hi.

fi(xi;11+ϵ) =jJ:pij>hixij(θ(pij1+ϵ)θ(hi1+ϵ))+θ(hi1+ϵ)
jJ:pij>hxij(θ(pij)θ(h¯))+θ(h¯)+θ(h¯)(jJmin{pij,h¯}xijh¯)
=gi(xi,h¯)f¯i(xi).

We explain the inequality. By monotonicity and convexity of θ,

θ(pij1+ϵ)θ(hi1+ϵ)θ(pij)θ(hi)θ(pij)θ(h¯).

Also, θ(hi1+ϵ)θ(h¯) as hi1+ϵ<h¯. Finally, θ(h¯)(jJmin{pij,h¯}xijh¯)0 as θ(h¯)0 and h¯hi.

For functions θ with moderate growth (including the case where θ(x)=xk for a constant k), the lemma suffices to solve CP(3) up to arbitrary precision.