Fully Polynomial-Time Approximation Schemes for Fair Rent Division

# Fully Polynomial-Time Approximation Schemes for Fair Rent Division

Eshwar Ram Arunachaleswaran   Siddharth Barman   Nidhi Rathi Indian Institute of Science. eshwarram.arunachaleswaran@gmail.comIndian Institute of Science. barman@iisc.ac.inIndian Institute of Science. nidhirathi@iisc.ac.in
###### Abstract

We study the problem of fair rent division that entails splitting the rent and allocating the rooms of an apartment among roommates (agents) in a fair manner. In this setup, a distribution of the rent and an accompanying allocation is said to be fair if it is envy free, i.e., under the imposed rents, no agent has a strictly stronger preference for any other agent’s room. The cardinal preferences of the agents are expressed via functions which specify the utilities of the agents for the rooms for every possible room rent/price. While envy-free solutions are guaranteed to exist under reasonably general utility functions, efficient algorithms for finding them were known only for quasilinear utilities. This work addresses this notable gap and develops approximation algorithms for fair rent division with minimal assumptions on the utility functions.

Specifically, we show that if the agents have continuous, monotone decreasing, and piecewise-linear utilities, then the fair rent-division problem admits a fully polynomial-time approximation scheme (FPTAS). That is, we develop algorithms that find allocations and prices of the rooms such that for each agent the utility of the room assigned to it is within a factor of of the utility of the room most preferred by . Here, is an approximation parameter, and the running time of the algorithms is polynomial in and the input size. In addition, we show that the methods developed in this work provide efficient, truthful mechanisms for special cases of the rent-division problem. Envy-free solutions correspond to equilibria of a two-sided matching market with monetary transfers; hence, this work also provides efficient algorithms for finding approximate equilibria in such markets. We complement the algorithmic results by proving that the fair rent division problem (under continuous, monotone decreasing, and piecewise-linear utilities) lies in the intersection of the complexity classes PPAD and PLS .

## 1 Introduction

Fair division addresses the fundamental problem of allocating goods among agents with equal entitlements, but distinct preferences. Such resource-allocation settings have been studied over multiple decades in economics, mathematics, and computer science; see, e.g., [BT96], [BCE16] and [Mou16]. In this line of work, a classic problem—with direct practical implications111For example, the website Spliddit, http://www.spliddit.org/, has been used over thirty thousand times for fair rent division (as of June 2018) [GMPZ17].—is to allocate rooms (indivisible goods) among agents while also assigning the rent (setting prices) in a fair manner.

The standard notion of fairness in this setting is envy-freeness (introduced in [Fol67] and studied in [Var74] and [Str80]) which requires that, under the imposed rents, each agent prefers the room allocated to it over that of any other agent. The preferences of the agents are expressed via functions (one for every agent-room pair) which specify the utilities of the agents for the rooms at every possible room rent/price. Hence, for the rent division problem, we say that an assignment of the rooms and the rent is envy free (i.e., fair), if the utility that each agent derives from the room allocated to it (under the imposed rents) is at least as high as ’s utility for any other room.

Prior work has established that envy-free rent divisions are guaranteed to exist under general, but well-behaved, utility functions. In particular, Sun and Yang [SY01] have shown that if all the utility functions in a rent-division instance are continuous, monotone decreasing, and bounded, then an envy-free solution will necessarily exist. This result relies on a fixed-point argument–namely, the Knaster, Kuratowski, and Mazurkiewicz (KKM) Lemma [KKM29]. Similar existence guarantees have been established by Svensson [Sve83] and Alkan et al. [ADG91].222A key tool in the work of Alkan et al. [ADG91] is a perturbation lemma (Lemma 1), which is utilized in this work as well.

The special case of quasilinear utilities has also received attention in the rent-division context; see, e.g., [Ara95], [ASÜ04], [GMPZ17], and [PVY18]. In this utility model each agent has a base value for every room , and ’s utility for at price is equal to the base value minus . For quasilinear utilities, the work of Aragones [Ara95] provides a combinatorial proof of existence along with an efficient algorithm for finding envy-free solutions.

It is relevant to note that while the existence result holds under fairly general utilities, efficient algorithms were known only for the quasilinear case. This work addresses this notable gap and develops approximation algorithms for fair rent division with essentially minimal assumptions on the utility functions. In particular, our results hold as long as the utility functions are continuous, monotone decreasing, and piecewise linear. Note that, for discontinuous and unbounded functions the existence of an envy-free solution cannot be guaranteed (see Appendix C for examples). Also, the assumption of piecewise linearity ensures that the underlying utility functions can be explicitly provided as input.

Indeed, the utility functions considered in this work are not confined to be concave (or convex), and can be used to heterogeneously expresses agents’ preferences at different price ranges, e.g., we can model agents who have quasilinear utilities and a fixed budget by considering piecewise-linear functions that experience a sharp drop when the price reaches the budget; Procaccia et al. [PVY18] provide a specialized algorithm to address these budget constraints. By contrast, this setting can be modeled as a special case of the utilities considered in this work.

The rent division problem can be stated abstractly in terms of dividing indivisible goods (the rooms) along with money (the rents) among unit-demand agents (i.e., each agent wishes to acquire at most one item). This perspective is adapted in the work of Svensson [Sve83], Alkan et. al. [ADG91], Sun and Yang [SY01], and Aragones [Ara95], who also consider relevant variants of the rent-division problem, such as characterizing optimal prices and truthful mechanisms. This paper addresses these variants and, in particular, focuses on (i) finding an envy-free solution with nonnegative prices and nonnegative utilities along with (ii) finding an envy-free solution which splits a given total rent.

This work shows that both of these problems admit a fully polynomial-time approximation scheme (FPTAS). Formally, the developed algorithms find allocations of the rooms and rents such that for each agent the utility of the room assigned to it is within a factor of of the utility of the room most preferred by . Here, is an approximation parameter and the running time of the developed algorithms is polynomial in and the input size. Overall, we show that a natural, approximate analogue of envy freeness can be achieved efficiently for the broad class of utilities mentioned above. The following list summarizes our contributions.

Our Results and Techniques Throughout, we study the problem of fair rent division under continuous, monotone decreasing, and piecewise-linear utility functions. We will also conform to the standard assumption that every agent’s utility for each room is nonnegative when the room rent is zero.

• We design an algorithm for finding an approximately envy-free solution in which the rents and the utilities of the agents are nonnegative (Section 3). This approximation guarantee asserts that for each agent the utility of the room assigned to it is within a factor of of the utility of the room most preferred by . The runtime of our approximation algorithm is polynomial in and the input size.

• We also develop an FPTAS for the problem of computing an envy-free solution in which the sum of prices (room rents) is equal to a specified total rent (Section 3). In contrast to the previous result, the solution obtained for this problem might impose negative prices, i.e., require transfers among agents. Note that there exist rent-division instances in which every envy-free solution, which splits the total rent, levies negative rents on some room.

Under this total-rent constraint, nonnegativity of utilities under fair solutions cannot be guaranteed either. To circumvent this issue a natural scaling assumption is adopted in prior work on quasilinear utilities, see, e.g., [BK01]. We show that, even in our setting, if the given rent-division instance satisfies this assumption, then we can find an approximately envy-free solution which not only splits the given total rent, but also yields nonnegative utilities (Section 3).

The two results mentioned above are obtained by first considering structured instances in which the constituent slopes of all the piecewise-linear utilities are integer powers of . We develop an algorithm that finds (exact) envy-free solutions of such instances in time that is polynomial in and the input size (Section 3). We then show that any given rent-division instance can be rounded to obtain a structured instance such that an envy-free solution of is an approximately envy-free solution of (Lemma 8).

• Sun and Yang [SY03] proved a somewhat surprising result that every rent-division instance admits an optimal solution which is simultaneously envy free, efficient, and nonmanipulable. The optimal solution is efficient in the sense that the utility profile it induces weakly Pareto dominates the utility profile of any other envy-free solution with nonnegative rents; the optimal solution itself imposes nonnegative rents. Here, nonmanipulability refers to the property that any algorithm that select the optimal solution as its outcome is guaranteed to be dominant strategy incentive compatible (DSIC). We show that for structured instances optimal prices can be computed efficiently. Therefore, for such instances we obtain a DSIC mechanism for the fair rent-division problem. Our result is based on a novel characterization of optimal solutions, which not only provides an alternate proof of existence of such solutions, but also leads to an efficient algorithm.333The result of Green and Laffont [GL79] rules out universal existence of DSIC mechanisms that are both Pareto efficient and budget balanced (i.e., split a given total rent). Hence, in the DSIC result of Sun and Yang [SY03]—and its algorithmic version obtained in this work—the sum of rents cannot be fixed a priori.

• The developed algorithm also provides an efficient method to find (exact) envy-free solutions when the number of agents is fixed (Section 4.1). Note that in this special case the piecewise-linear utilities can still be intricate. We additionally show that if in a given rent-division instance the number of distinct slopes (across utility functions) is a fixed constant, then an envy-free solution can be computed in polynomial time (Section 4.1).

• We complement the algorithmic results by proving that the total problem of finding an envy-free solution of a rent-division instance (with continuous, monotone decreasing, and piecewise-linear utilities) is contained in the complexity class PPAD (Polynomial Parity Arguments on Directed graphs) as well as PLS (Polynomial Local Search); see Section 3. Though, prior work has established the existence of fair solutions using a fixed-point argument—in particular, the KKM Lemma [SY01]—the containment of the (exact) fair rent division in PPAD is not an immediate consequence of this proof. This follows the fact that the computational version of the KKM lemma would entail discretization of the solution space (as is required in the case of related problems such as Sperner’s Lemma [Pap94] and Envy-Free Cake Cutting [DQS12]) and, hence, we would get an approximate solution of the reduced problem. Therefore, in and of itself, such a reduction would imply that approximating rent division is in PPAD—this result would not rule out the possibility that the exact version is harder. We bypass this issue by establishing a reduction from fair rent division to the problem of computing an exact Nash equilibrium in polymatrix games. Given that finding a Nash equilibrium is such games is known to be PPAD-complete [DFP06], we get the desired containment. This reduction might be of independent interest, since it provides an alternate proof of existence of envy-free solutions using Nash’s theorem (specifically for polymatrix games), rather than a more involved fixed-point argument.

Another conceptually interesting part of the complexity analysis is the containment of fair rent division in the complexity class PLS. This containment relies on a potential argument which is developed in this paper. Overall, these results render fair rent division as one of the few “natural” problems that lie in and for which a polynomial-time algorithm is not known.444Another problem with the same complexity status is Colorful Carathéodory [MMSS17]. Showing that these problems are complete for a semantic subclass of PPAD PLS remains an interesting open question.

As mentioned previously, we develop an exact algorithm for finding envy-free solutions for problem instances in which the slopes of all the piecewise-linear utilities are integer powers of . We also show that general rent-division instances can be rounded to such structured instances while approximately maintaining envy freeness of solutions. This, overall, provides an FPTAS for fair rent division.

Our exact algorithm for finding an envy-free solution (Algorithm 1) begins by employing a homotopy idea. Specifically, we pick a large threshold and for each utility function construct a surrogate function such that and have the same function value for all prices less than . For prices greater than , we set to be quasilinear. Recall that an envy-free solution with a nonnegative price vector can be computed efficiently if the utilities are quasilinear [Ara95]. Therefore, we can find a nonnegative envy-free price vector for the quasilinear ends of s. Since a uniform, additive shift in prices maintains envy freeness under quasilinear utilities, we can add to each component of and ensure that it provides an initial envy-free solution for the utilities s.

The key part of the algorithm is to iteratively reduce the prices while maintaining envy freeness under s. We continue to perform such a price reduction till all the rents are less than . At this point, the solution is envy free with respect to both the constructed utilities s and the given utilities s. Alkan et al. [ADG91] used a perturbation lemma (Lemma 1) to accomplish an arbitrarily small reduction in prices. By contrast, our algorithm performs this update by solving linear programs.555In and of itself, the perturbation lemma does not lead to a finite-time algorithm for finding fair solutions; Alkan [Alk89] provides an instance wherein the perturbations do not converge. Note that this lemma is not directly instantiated in our algorithms, however it is used to prove the correctness of the developed methods.

Our results rely on establishing interesting geometric properties of the set of prices that induce envy-free solutions. Though this set is nonconvex, it consists of a sequence of polytopes which successively intersect; see Figure 1. These intersections necessarily include the price vectors at which the sum of prices is minimized in each polytope. At a high level, our algorithm obtains the price reduction by performing a “walk” over these polytopes. Each step of the walk entails minimizing the sum of prices over the current polytope (to reach an intersection point) and, subsequently, switching to a new polytope. The minimization step corresponds to solving a linear program and the switching step is implemented by solving a maximum-weight perfect matching problem (see Algorithm 1 for details).

Another contribution of this work is to show that there exists a potential which decreases as the walk though the polytopes progresses. This potential argument not only bounds the runtime of the developed algorithm, but also enables us to show that the rent-division problem is contained in PLS.

It is relevant to note that the resulting algorithm is rather simple, even though the analysis is somewhat intricate—the algorithm primarily involves finding maximum-weight perfect matchings and solving linear programs. As mentioned previously, rent-division algorithms have been widely used in practice. A notable example is the popular website Spliddit, the scale of which highlights that efficient methods for fair rent division—like the ones developed in this work—have a potential for direct impact.

Further Related Work The work of Su [Su99] establishes the existence of envy-free solutions in an ordinal version of rent-division problem. In this setup, each agent has a preference (over the rooms) for every possible division of the total rent. This existence result requires that the preferences constitute a closed set and satisfy the assumption that each agent is miserly, i.e., prefers a free room (a room with zero rent) to a non-free room. Note that in this setting the preferences can be nonmonotone and might not admit a succinct, explicit representation.

This ordinal setup is incomparable with the cardinal utility model considered in this work; in particular, the miserly assumption does not hold for arbitrary quasilinear utilities. Furthermore, the ordinal version of the rent-division problem is PPAD-complete.777A reduction along the lines of the one given in Deng et al. [DQS12] establishes this hardness result. By comparison, we show that cardinal version considered in this paper is contained in the complexity class .

Competitive Equilibria of Two-Sided Matching Markets: Fair rent division is mathematically equivalent to a two-sided matching market with monetary transfers. In this market formulation each agent is assumed to be unit demand and each agent’s utility is a function of the indivisible good she receives as well as the amount of money she pays. Quinzii [Qui84] established the existence of competitive equilibria under general (non-quasilinear) utilities in this market framework. Furthermore, Demange and Gale [DG85] showed that equilibria in these markets admit a lattice structure. A constructive proof of existence of such equilibria was established by Alkan [Alk89]; in particular, Alkan’s algorithm [Alk89] finds an equilibrium in finite time, though it does not admit a polynomial running time bound. The quasilinear version of such two-sided matching markets has also been studied in prior work [Gal60; SS71; Dem82].

An envy-free solution corresponds to an equilibria of such a market, since envy freeness implies that each agent is maximizing its utility under the imposed prices. Therefore, this work also provides novel results for efficiently finding approximate equilibria of such two-sided matching markets under a broad class of utility functions.

## 2 Notation and Preliminaries

Problem Instance A rent-division instance is a tuple wherein denotes the set of agents and denotes the set of rooms. The cardinal preference of each agent for every room is specified via a utility function ; specifically, agent ’s utility for room at price (rent) is .

Throughout, we will assume that the utility functions are continuous, monotone decreasing, and piecewise linear. Each function is given as an input via its constituent linear pieces. In particular, is specified using its base value , a set of increasing break points, , and the magnitude of the slopes . Here, the utility in the interval is a linear function with slope . Therefore, if price is contained in, say, the th interval, , then the agent’s utility for the room at is

 va(r,x) \coloneqqva(r,0)−i−1∑j=1λar,j(bj+1−bj) −λar,i(x−bi)

For ease of presentation, we will drop the dependency on and use to denote when the interval is clear from context.

Rent division has been extensively studied for the special case of quasilinear utilities. Here, every agent has a base value for each room , and the utility functions are quasilinear in the prices, . An efficient algorithm for quasilinear utilities was developed in [Ara95]. Our main algorithm solves the quasilinear case as a subroutine; for completeness, we outline a polynomial-time algorithm for fair rent division under quasilinear utilities in Appendix A.

Allocations and Envy-Free Solutions An allocation refers to a bijection where room is assigned to agent . Furthermore, a solution, , to a rent-division instance is an allocation along with a price vector for the rooms. The utility that agent achieves under the solution is . We will primarily consider solutions wherein the rents are nonnegative, for all ; exceptions to this convention will be explicitly mentioned.

Recall that envy freeness requires that each agent prefers its own “share” over that of any other agent. Formally, for a rent division instance , a solution is said to be envy free (EF) iff, under the imposed rents, every agent prefers the room assigned to it over any other room, i.e., for each and every room we have .

A direct characterization of envy-free solutions is obtained by considering a bipartite graph where edge is included in the edge set iff is a maximum utility room for agent , i.e., iff for all . Note that is an EF solution iff is a perfect matching in . We will refer to as the first-choice graph at price vector .

Another useful notion is that of a linear domain, which, for a given price vector , specifies a containment-wise maximal region which contains and wherein the slopes of the utility functions do not change.

###### Definition 1 (Linear Domain).

For a price vector , a linear domain is a maximal region (i.e., for all ) wherein for all agents and rooms the utility function has a constant slope (left derivative).

Note that breakpoints of any utility function lie on the boundary of linear domains, and never in their interior. Since the inequality defining the lower bound is strict, if for a room the price is equal to a break point, say , then we have and . Furthermore, the linear domain of a given price vector can be computed efficiently by finding, for each , the breakpoints (among all the breakpoints of s) that provide the best lower and upper bounds for .

Our algorithms work with a weighted version of the first-choice graph. In particular, for a price vector with first-choice graph and linear domain , we will use to denote a bipartite graph with the same edge set, , as and edge weights for all . Here, is the (fixed) slope magnitude of the utility function in the linear domain .

By definition, only the “first-choice edges” are present in and have weights associated with them. These edge weights (i.e., the logarithm of the slopes) can be negative, since the slopes’ magnitudes are not necessarily greater than one.

Approximate Solutions This paper develops algorithms for efficiently computing solutions that are approximately envy free, i.e., for finding solutions wherein for each agent the utility of the room assigned to it is multiplicatively close to the utility of the room most preferred by .

Our algorithm starts with high room rents and iteratively decreases them till an approximately envy free solution is found. Since the rents are high, agents’ utilities can be negative during the intermediate steps of the algorithm. The following definition includes this case of negative utilities and thereby provides a unified way to state the approximation guarantees.

###### Definition 2 (Approximately Envy-Free Solutions).

For a rent-division instance and parameter , a solution is said to be -approximately envy free (-EF) iff

• For each agent that attains nonnegative utility under the solution (i.e., ) the following inequality holds for every room : .

• For each agent that attains negative utility under the solution (i.e., ) the following inequality holds for every room : .

If the base values of the utility functions are positive, , then our algorithm will necessarily find an approximate solution wherein the agents attain nonnegative utilities. Hence, in this standard case, condition of the above definition will hold for every agent under the computed solution, i.e., the solution found by the algorithm will satisfy the usual -approximation guarantee.

Furthermore, for an -EF solution, , it must be the case that if agent ’s utility for the assigned room is negative, then ’s utility for every room is negative at the price vector .

### 2.1 The Perturbation Lemma of Alkan et al. [Adg91]

The following lemma of Alkan et al. [ADG91] asserts that starting with any fair solution one can always find another envy-free solution with strictly lower prices for all the rooms. In this work we use this lemma for proving the correctness of the developed algorithms although our algorithms do not directly instantiate this result; in fact, in and of itself, the perturbation lemma does not lead to a finite-time algorithm for finding fair solutions; Alkan [Alk89] provides an instance wherein the perturbations do not converge.

In the following lemma the rents under the two solutions can be negative.

###### Lemma 1 (Perturbation Lemma [Adg91]).

Let be an envy-free solution of a rent-division division instance . Then, for any small enough , there exists another envy-free solution of such that, for all rooms , we have .

Next we state a version of this lemma which identifies the allocations (bijections) which are realizable in the perturbed solutions. This variant will be used in the analysis of our algorithms—a proof of Lemma 2.1 is given in Appendix B for completeness.

Recall that denotes the weighted, first-choice graph at price vector .

{restatable}

lemmaLemmaStatementPerturb Let be an envy-free solution of a rent-division instance and be any maximum weight perfect matching in . Then, for any small enough , there exists another envy-free solution of such that, for all rooms , we have .

Here, is any maximum weight perfect matching in .888Given that is EF, admits a perfect matching (in particular, ), hence is well defined. Since the edge weights can be negative, is not necessarily a maximum weight matching in the bipartite graph.

### 2.2 Optimal Prices

For a rent division instance , write to denote the set of nonnegative prices that induce an envy-free solutions, .

The perturbation lemma implies that there are no isolated points in . The work of Sun and Yang [SY03] provides further insight into the geometry of this set by establishing that , in fact, contains an optimal price vector : specifically, Sun and Yang [SY03] show that there exists such that the componentwise inequality holds for all .

This, in particular, implies that the total rent imposed under is the lowest among all envy-free solutions with nonnegative prices. One can also prove that (among all fair solutions with nonnegative prices) the sum of agents’ utilities is maximized at the envy-free solution ; here, is the allocation associated with .

Furthermore, Sun and Yang [SY03] established a notable property of optimal prices in the context of strategic agents: an algorithm that selects as the outcome is guaranteed to be dominant strategy incentive compatible (DSIC).

In Section 7 we show that if all the slopes of a rent division instance are integer powers of , for parameter , then we can efficiently find the optimal price. Hence, for such instances not only do we obtain an algorithm for finding EF solutions, but also an efficient, DSIC mechanism for fair rent division.

## 3 Main Results

This section presents the statements of our main results.

Exact Algorithm for Structured Instances: We develop an exact algorithm for rent-division instances in which the slopes of all the piecewise-linear utilities are integer powers of .

{restatable}

theoremTheoremEfRounded For any given rent-division instance , wherein the utility functions satisfy the powers-of- property, Algorithm 1 computes an envy-free solution in time that is polynomial in and the input size.

Approximation Algorithms: {restatable}theoremTheoremMainResult For any given rent-division instance (in which the utility functions are continuous, monotone decreasing, and piecewise linear) an -EF solution can be computed in time polynomial in and the input size.

As mentioned previously, there exist rent-division instances wherein negative rents and negative utilities cannot be avoided under any fair distribution of a given rent . Specifically, in the following theorem the computed solution might impose negative rents and utilities.

{restatable}

theoremTheoremFixedCost Given a rent-division instance along with a total rent , we can find—in time that is polynomial in and the input size—an allocation and a price vector such that is an -EF solution of and .

The issue of negative utilities is circumvented in prior work (on quasilinear utilities) by adopting the following assumption: , here is the price at which the utility of agent for room reduces to zero and is the total rent. We prove that, even in case of piecewise-linear utilities, under this assumption one can find approximately envy-free solutions with nonnegative utilities.

{restatable}

theoremTheoremIr Let be a rent division instance wherein the inequality holds for all agents and parameter . Then, we can find—in time that is polynomial in and the input size—an allocation and a price vector such that (i) is an -EF solution of , (ii) , and (iii) the utilities of all the agents under are nonnegative.

DSIC Mechanism for Structured Instances: We also design an algorithm for finding optimal solutions of instances in which the slopes of all the utilities are integer powers of . Hence, using the result of Sun and Yang [SY03], we obtain a DSIC mechanism for this setting.

{restatable}

theoremTheoremPostpro Given any rent-division instance , wherein the utility functions satisfy the powers-of- property, Algorithm 2 finds an optimal envy-free solution with runtime polynomial in and the input size.

Complexity of Fair Rent Division: Ef-PiecewiseLinear refers to the total search problem of finding an envy-free solution of any rent-division instance with continuous, monotone decreasing, and piecewise-linear utilities. We show that

{restatable}

theoremTheoremComplexity Ef-PiecewiseLinear is in .

## 4 Exact Algorithm for Structured Instances

This section considers instances wherein the constituent slopes of all the utility functions are integer powers of , for a fixed . Specifically, in such instances, for all agents , rooms , and pieces , we have , for some integer (which can be negative and depends on , , and ). In the next section we will extend the analysis to general instances.

Write to denote piecewise-linear utility functions wherein the slopes satisfy this powers-of-) property, for a fixed . We will show that, given a rent division instance , Algorithm 1 (Alg) finds an envy-free solution in time polynomial in and the bit complexity of the input.

Below we will prove that Alg can, in fact, find an envy-free solution for an arbitrary rent-division instance . It is the runtime analysis of the algorithm that requires the powers-of- property.

Given instance , Alg begins by considering modified utility functions, s, that match s till a large threshold and for prices higher than the modified utility functions are quasilinear. In particular, let be such that , for all agents and rooms . Since the utility functions are monotone decreasing, such an exists and can be computed efficiently.999We can conservatively set

For all agents and rooms , define

 ˆva(r,x):={va(r,x) for x≤Mva(r,M)−(x−M) for x>M (1)

Recall that envy-free solution for quasilinear utilities can be computed efficiently. Therefore, we can find a fair solution for the quasilinear functions . Furthermore, by adding to the (nonnegative) price of each room we can ensure that is not only envy free, but also satisfies for all .

By construction, is EF for . Alg starts with such a solution and iteratively reduces the prices, while maintaining envy freeness with respect to s. The algorithm terminates when it finds an envy-free solution wherein the rent for some room has been reduced to zero. One can show that at this price vector the rents of all the rooms have to be less than (details of this argument appear in the proof of Theorem 3). Since all the components of are less than , at this price vector the utilities under the functions and are equal. Therefore, is EF with respect to s as well. Intuitively, this establishes the correctness of the algorithm. Below we analyze the runtime of Alg and, overall, show that this algorithm efficiently finds an envy-free solution.

The next few lemmas establish useful properties of the intermediate solutions, s, computed by the algorithm.

###### Lemma 2.

Given a rent-division instance , let denote the modified instance obtained in Step 2 of Alg and be the solution computed in the th iteration of the algorithm. Then, is an envy-free solution for .

###### Proof.

We will prove this claim by induction over . Alg starts with a solution which is envy free with respect to the quasilinear functions and satisfies for all . For such high rents the utilities under s are equal to the ones under the quasilinear functions . Hence, for the base case, we have that is EF for .

By the induction hypothesis, solution is EF for . Therefore, is a perfect matching in the first-choice graph . This, in turn, implies that —which is set to be a maximum weight perfect matching in —is well defined.

The linear program LP—which is solved in Alg to obtain —considers all the price vectors (in the current linear domain ) under which is an envy-free allocation. Since this linear program is bounded and feasible,101010The price vector , in particular, is a feasible solution of this linear program. we get that it has an optimal solution, . Overall, these observations imply that is EF for , and the claim follows. ∎

Given a price vector , write to denote the weight of the a matching in the weighted, bipartite graph . Recall that for each edge in this graph, the edge weight is equal to , where is the slope of the utility function in the linear domain containing . Also, we have that the slopes remain unchanged in a linear domain. Hence, if the linear domain of price vector is the same as the linear domain of , then the weight of a matching in is equal to its weight in .

Whenever we will compare weights of matchings the linear domain will be fixed. Hence, for ease of presentation, we will not explicitly denote the dependence of the weights, , on the underlying linear domain.

###### Lemma 3.

Let be a solution computed by Alg in an iteration wherein the linear domain does not change, . Then, the following strict inequality holds .
Here, is the allocation computed by Alg in the th iteration, i.e., is a maximum weight perfect matching in .

###### Proof.

Alg computes by solving the linear program LP which, in particular, includes constraints of the form and . Note that if any one of these constraints is tight for , then either the linear domain changes111111Recall that the definition of a linear domain, , for a price vector mandates a strict inequality between and , i.e., it requires . (i.e., ) or the while-loop terminates. Therefore, must satisfy the following strict inequalities and .

Lemma 2 ensures that is EF and, hence, is a perfect matching in the bipartite graph . Using the fact that is a maximum weight perfect matching in this graph, we get . Next we will prove that this inequality is never tight.

Assume, for contradiction, that , i.e., is also a maximum weight perfect matching in . In this case, the perturbation lemma (Lemma 2.1) implies that, for any small enough , there exists a price vector such that is envy free and for all .

Since we have strict inequalities and , an appropriate leads to a price vector which satisfies and . In other words, is a feasible solution of the linear program LP, whose optimal solution is .121212Here, even if the inequality is tight, for some , remains feasible. The inequality contradicts the optimality of and establishes the stated claim. ∎

The following lemma shows that the room rents do not increase as the algorithm progresses.

###### Lemma 4.

The price vectors, and , computed in consecutive iterations of Alg satisfy the following componentwise inequality: .

###### Proof.

The price vector is a feasible solution of the linear program LP: by definition, is contained in the linear domain and is a maximum weight perfect matching in , i.e., is EF.

We will show that the inequality holds for all price vectors that are feasible with respect to the linear program LP. Hence, the feasibility of will gives us the desired inequality .

Consider a feasible solution, , of the linear program LP. Say, for contradiction, that there exists a room such that . We will show that the price vector, say , obtained by taking the componentwise minimum of and is also a feasible solution. Note that such a would satisfy , which would contradict the fact that is an optimal solution of LP. Hence, it must be the case that for all feasible price vectors .

Write for all . This price vector directly satisfies the box constraints of the linear program: and . To establish the feasibility of it remains to show that maintains the envy freeness of , i.e., it satisfies for all and .

For each room , there are two possible cases either or . If , then we have for all agents . The feasibility of ensures that . Since, , we get the desired inequality . The inequality analogously holds for the case wherein . This, overall, proves that is feasible and the lemma follows. ∎

Using the lemmas mentioned above, we will now prove the main result of this section.

\TheoremEfRounded

*

###### Proof.

Consider a sequence of successive iterations of Alg in which the underlying linear domain remains the same, i.e., . We will first upper bound the length, , of any such sequence.

Write to denote the (fixed) slope of the utility function in the linear domain . Since all the slopes in the given piecewise-linear utilities are integer powers of , we have for an integer . The slopes, s, are fixed throughout the linear domain and, hence, the exponents, s, are fixed as well. Note that can be negative, but its magnitude is upper bounded in terms of the bit complexity of : using and , we obtain , for . Therefore, if is the bit complexity of the input parameters, then .

This magnitude bound implies that . Furthermore, the edge weights, s, in the bipartite graph , for any , satisfy . Therefore, the difference in the weights of any two perfect matchings in the complete bipartite graph —with edge weights set to s—is upper bounded by .

Since the linear domain remains unchanged throughout the sequence , Lemma 3 implies the following strict inequalities ; here is the matching computed by Alg in the th iteration, for . The above mentioned observation gives us

 w(πj+1)−w(πi)≤6βε nlog(1+ε). (2)

Furthermore, for each , the weight is an integer multiple of ; recall that each exponent is an integer. Therefore, using the strict inequality , we get that . This inequality and equation (2) bound the length of the sequence

 |S|=j+1−i ≤6βnε (3)

This bound implies that Alg changes the underlying linear domain after at most successive iterations. We will complete the runtime analysis of Alg by showing that the total number of linear-domain changes in Alg is polynomially bounded.

Let denote the total number of pieces in the piecewise-linear utility function . Write . Consider counters and to keep track of the price changes we adopt the following convention: after the th iteration, with price vector in hand, the counter is set to be the index of the piece of which contains ; in particular, if the price is between the th and th breakpoint of , then at the th iteration . Since the initial price vector satisfies , for all , and is the last breakpoint of all the utility functions s, we get that is initialized to for each and . That is, at the beginning of the algorithm we have .

Lemma 4 ensures that the computed prices are nonincreasing. Hence, the counters s are nonincreasing as well. Furthermore, in Alg, a change in the linear domain is triggered iff, for some , the inequality becomes tight. By the definition of a linear domain we get that there exists an agent such that is equal to a breakpoint of . Therefore, in Alg, whenever the linear domain changes the value of at least one counter, , gets decremented by one. As mentioned above, the counter values do not increase as Alg progresses and initially they satisfy . Also, note that Alg terminates as soon as the price of a room reduces to zero, hence the counter values satisfy during the entire execution of the algorithm. These arguments prove that the total number of domain changes is at most . Using inequality (3) with this bound we get that Alg runs for at most iterations.131313Since is the bit complexity of the input parameters and is the total number of given pieces, the input size is and, hence, an algorithm that runs in time polynomial in , , and is deemed to be efficient. This completes the runtime analysis of the algorithm.

To complete the proof we will show that the solution returned by Alg, say , is EF for the original instance . This solution is EF for (Lemma 2) and the termination condition of the while-loop ensures that for some room . Hence, is componentwise less than : assume, for contradiction, that for a room and let be the agent who is assigned this room, . The following inequalities contradict the envy freeness of for

 ˆvα(π(α),pπ(α)) <ˆvα(π(α),M)(utility ˆvα(π(α),⋅) is monotone decreasing) =vα(π(α),M)(follows from (???))

Therefore, the returned price vector satisfies . Note that, when all the prices are less than , the equality holds for all and (see equation (1)). Overall, we get that is an envy-free solution of as well, and this completes the proof. ∎

### 4.1 Runtime Analysis for Special Cases

Section 3 establishes the time complexity of Alg (Algorithm 1) for rent-division instances in which all the slopes are integer powers of . Specifically, this runtime analysis shows that the number of iterations in Alg that consider the same linear domain is at most the number of perfect matchings with distinct weights in the first-choice graph associated with ; see inequality (3). Write to denote the maximum number of such perfect matchings. The powers-of- property is used, in particular, to show that for structured instances , which in turn shows that any linear domain is considered in iterations; here, is the bit complexity of the input.

For general instances, continues to upper bound the number of iterations which consider the same linear domain. However, without the powers-of- property can be as large as .

Next, we present two special cases of piecewise-linear utilities in which we can prove tighter bounds on and, hence, establish the efficiency of Alg.

Constant Number of Agents: Consider the case in which is a fixed constant. This setting occurs naturally in real-world applications wherein the number of roommates is small. Since is at most , in this case is also a constant. Therefore, when the number of agents is fixed, Alg finds an envy-free solution in polynomial time.

Constant Number of Distinct Slopes: For a rent-division instance, let denote the total number of distinct slope values across all the utility functions. Equivalently, is the total number of distinct logarithmic values of the slopes. Note that the total number of pieces over all the utility functions can be much larger than .

For a fixed linear domain, consider the complete bipartite graph in which the edge weights are equal to the logarithm of the slopes. Since there are no more than distinct edge weights, say , with each perfect matching in the complete bipartite graph we can associate a -tuple , where represents the number of edges in whose weight equal to . Note that the weight of the perfect matching is equal to , i.e., the tuple uniquely determines the weight of . Also, for any matching . In other words, the tuple is a integer partition of . Therefore, the number of tuples is at most . This shows that , the number of perfect matchings with distinct weights, is also upper bounded by . Hence, if is a fixed constant, then Alg finds an envy-free solution in polynomial time.

This case (with ) captures the setting in which the agents have quasilinear utilities and a budget constraint (i.e., an agent cannot pay more than a specified amount as rent). A polynomial-time algorithm for this setting was developed in [PVY18]. Since this budgeted setting can be modeled by piecewise-linear utilities that have two distinct slope values (the slope of the quasilinear part, , and a large negative slope at the budget of every agent), this work also obtains an efficient algorithm for finding fair solutions under quasilinear utilities and budget constraints.

The analysis for the two special cases above also hold for the modified versions of Algorithm 1 that are developed in Section 6 and Section 7.

## 5 Approximation Algorithm for Fair Rent Division

This section presents a fully polynomial-time approximation scheme (FPTAS) for the fair rent-division problem under continuous, monotone decreasing, and piecewise-linear utilities. Given a rent-division instance and an approximation factor , our first step is to construct a “close-by” structured instance in which the slopes of all the utility functions are integer powers of . We will prove that any envy-free solution of this constructed instance is an -EF solution for the original instance. Hence, using the algorithm developed in Section 4 (Alg) we obtain an FPTAS.

Given a problem instance , we construct utility functions by rounding the slopes of the functions piece by piece.

Consider piece of the utility function and let and be the breakpoints corresponding to this piece (i.e., the piece is defined in the interval ). Write to denote the magnitude of the slope of in this piece. We will use and to denote that value of the utility function at breakpoints and , respectively: and . Since the construction is identical for all pieces, we will overload the notation and not explicitly index these parameters by ; each piece of will be denoted by .

The following equalities hold for all

 va(r,x)=Har−λar (x−x1)=Bar+λar (x2−x) (4)

Given a piece and the approximation parameter , we round up to the nearest integer power of : define and note that

 ¯¯¯¯¯λar1+ε<λar≤¯¯¯¯¯λar (5)

To obtain the approximating function , each piece of is substituted by two linear pieces with slopes and , respectively. Note that, by the intermediate value theorem, there always exists an such that .

Using (which can be found by solving the equation above), we define in the interval as follows (see  Figure 2)

 ¯¯¯va(r,x):=⎧⎨⎩Hra−¯¯¯¯¯λar1+ε(x−x1) for x1≤x

The piecewise-linear functions can be found in polynomial time by applying the above mentioned procedure over the pieces of the given utilities .

For all agents and rooms , let be the price at which agent ’s utility for room reduces to zero, i.e., is the solution of . While constructing each , we will treat