# Maximin share allocations on cycles

The problem of fair division of indivisible goods is a fundamental problem of social choice. Recently, the problem was extended to the case when goods form a graph and the goal is to allocate goods to agents so that each agent's bundle forms a connected subgraph. For the maximin share fairness criterion researchers proved that if goods form a tree, allocations offering each agent a bundle of at least her maximin share value always exist. Moreover, they can be found in polynomial time. We consider here the problem of maximin share allocations of goods on a cycle. Despite the simplicity of the graph, the problem turns out to be significantly harder than its tree version. We present cases when maximin share allocations of goods on cycles exist and provide results on allocations guaranteeing each agent a certain portion of her maximin share. We also study algorithms for computing maximin share allocations of goods on cycles.

## Authors

• 3 publications
• 25 publications
• ### Connected Fair Allocation of Indivisible Goods

We study the fair allocation of indivisible goods under the assumption t...
08/15/2019 ∙ by Xiaohui Bei, et al. ∙ 0

• ### Fair-Share Allocations for Agents with Arbitrary Entitlements

We consider the problem of fair allocation of indivisible goods to n age...
03/07/2021 ∙ by Moshe Babaioff, et al. ∙ 0

• ### Fair Allocation of Indivisible Items With Externalities

One of the important yet insufficiently studied subjects in fair allocat...
05/16/2018 ∙ by Mohammad Ghodsi, et al. ∙ 0

• ### Mind the Gap: Cake Cutting With Separation

We study the problem of fairly allocating a divisible resource, also kno...
12/12/2020 ∙ by Edith Elkind, et al. ∙ 0

• ### Decentralised Random Number Generation

Decentralised random number generation algorithms suffer from the Last A...
07/06/2018 ∙ by Peter Robinson, et al. ∙ 0

• ### How to share a cake with a secret agent

In this note we study a problem of fair division in the absence of full ...
10/16/2018 ∙ by Guillaume Chèze, et al. ∙ 0

• ### Graphical Cake Cutting via Maximin Share

We study the recently introduced cake-cutting setting in which the cake ...
05/11/2021 ∙ by Edith Elkind, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1. Introduction

Fair allocation of indivisible goods is a fundamental problem of social choice [5, 3]. It assumes a set of elements, referred to as goods, and a collection of agents each with her own utility function on the sets, or bundles, of goods. The utility functions are commonly assumed to be additive and so it is enough to specify their values on individual goods only. The objective is to assign to agents disjoint subsets of goods in a way that meets some fairness criteria. Among the most commonly studied ones are proportionality and envy-freeness, adapted to the case of indivisible goods from the problem of fair allocation of divisible goods or cake-cutting [5, 11], as well as recently proposed maximin and minimax share [6, 4]. For each of the criteria, it is of interest to identify classes of instances when fair allocations exist, to establish the complexity of deciding the existence of fair allocations, and to design algorithms for computing them.

In this paper, we focus on the maximin share criterion [6]. It is a relaxation of envy-freeness and proportionality, and has a natural interpretation in terms of some allocation protocols. In a few years since it was first proposed it has already received substantial attention. The criterion turns out to be highly non-trivial. First, while it is easy to see that envy-free and proportional allocations do not always exist, it is not at all clear whether the same is true for the less restrictive maximin criterion. We now know it is. But it took a few years before the first examples showing that maximin share allocations are not guaranteed to exist were found [12]. Moreover, they turned to be quite intricate. Further, the complexity of deciding the existence of maximin share allocations has not yet been determined [4]. To get around the difficulty of constructing maximin allocations, researchers proposed to relax the maximin share criterion by requiring that the value of each agent’s share in an allocation be at least equal to some positive fraction of the maximin share. Procaccia and Wang [12] proved that an allocation guaranteeing agents at least 2/3 of their maximin share always exists, and that it can be found in polynomial time if the number of agents is fixed (not part of input). Both the result and the algorithm are based on deep combinatorial insights. Building on that work, Amanatidis, Markakis, Nikzad and Saberi [1] proved that for every constant , , there is a polynomial-time algorithm finding an allocation guaranteeing to each agent at least of their maximin share (with the number of agents a part of the input). Ghodsi, Hajiaghayi, Seddighin, Seddighin and Yami [8] proved that in the results by Procaccia and Wang and by Amanatidis et al., the constant 2/3 can be replaced with 3/4.

We study maximin share allocations of indivisible goods in the setting proposed by Bouveret, Cechlárová, Elkind, Igarashi and Peters [2]. In the original problem, there are no restrictions on sets of goods that can be allocated to agents. This ignores important practical constraints that may make some sets highly undesirable. For instance, goods may be rooms and labs in a building to be allocated to research groups [2], or plots of land to be consolidated [9]. In such cases, legal sets of goods that could be allocated to an agent might be required to form connected subgraphs in some graph describing the neighborhood relation among goods (offices spanning segments of a hall, plots forming contiguous areas of land).

Bouveret et al. [2] studied envy-free, proportional and maximin share allocations for that setting obtaining several interesting complexity and algorithmic results. Our paper extends their study for the maximin share criterion. In a striking positive result, Bouveret et al. [2] proved that maximin share allocations of goods on trees always exist and can be found in polynomial time. In our work we look beyond trees and show that as soon as the underlying graph has a single cycle, the picture becomes much more complicated. Our main contributions are as follows.

1. We show that for goods on a cycle the maximin share value for an agent can be computed in polynomial time. In two cases, when and when agents can be grouped into a fixed number of types (agents are of the same type if they have the same utility function), this allows us to design polynomial time algorithms for computing maximin share allocations of goods (on cycles) to agents or determining that such allocations do not exist.

2. We show that deciding the existence of maximin share allocations of goods on an arbitrary graph is in the class . For complete graphs (the setting equivalent to the original one) this result improves the bound given by Bouveret and Lemaître [4]. We further improve on this upper bound for cycles and more generally, unicyclic graphs by showing that for such graphs the existence of a maximin share allocation is in NP.

3. We obtain approximation results on the existence of allocations of goods on a cycle that guarantee all agents a specified fraction of their maximin share value. While it is easy to show that for any number of agents there are allocations guaranteeing each agent at least their maximin share, improving on the guarantee coefficient of is a non-trivial problem. We show that it can be improved to (). Further improvements are possible if we limit the number of agents or the number of types of agents. In particular, we show that for the three-agent case, there are allocations guaranteeing each agent of their maximin share; for an arbitrary number of agents of up to three types there are allocations guaranteeing each agent of their maximin share; and for any number of agents of types there are allocations guaranteeing each agent of their maximin share. In each case, these allocations can be found in polynomial time. Moreover, the constants 5/6 and 3/4 for the cases of three agents and any number of agents of up to three types, respectively, are best possible, that is, they cannot be replaced with any larger ones.

## 2. Definitions and Basic Observations

A utility function on a set of goods (items) is a function assigning non-negative reals (utilities) to goods in . We extend utility functions to subsets of by assuming additivity.

Following Bouveret et al. [2], we consider the case when goods form nodes of a certain connected graph . We adopt the assumption of the connectedness of the graph for the entire paper and do not mention it explicitly again. In particular, whenever we use the term graph we mean a connected graph. We write and for the sets of nodes and edges of and refer to as the graph of goods. Given a graph of goods, we will often refer to utility functions on (the set) as utility functions on (the graph) .

Let be a set of goods. A -bundle is a subset of that induces in a connected subgraph. A -split is a sequence of pairwise disjoint -bundles such that

 n⋃i=1Pi=V.

We use the term split rather than partition as we allow bundles to be empty. When or are clear from the context we drop them from the notation and speak about bundles and splits (occasionally, -splits and -splits).

Let be a graph of goods, a utility function on , a non-negative real, and a positive integer. We call a split -strong if every bundle in the split has value at least under . The maximin share for , and , written , is defined by setting

 mms(n)(G,u)=max{q:there is a q-strong n-split of G}.

An equivalent definition is given by

 mms(n)(G,u)=maxP1,…,Pnmini=1,…,nu(Pi),

where the maximum is taken over all -splits of . A split for which the maximum is attained is a maximin share split or an mms-split for and or for and an agent with a utility function . We often leave and implicit when they are clearly determined by the context. By the definition, for every bundle in an mms-split for and , . Similarly as above, when and are clear from the context, we leave them out and write for . When considering an agent with a utility function we write for .

Let be a graph of goods. A -allocation is an assignment of pairwise disjoint -bundles of goods to agents so that all goods are assigned. Clearly, -allocations can be represented by -splits, where we understand that the th bundle in the split is the bundle assigned to agent . Let be the utility function of agent , . A -allocation is a maximin share allocation, or an mms-allocation, if for every we have .

To illustrate the concepts introduced above, let us consider the graph in Figure 1. We will call this graph . The graph defines the set of goods and their adjacency structure. The table in the figure shows three utility functions , and on the set of goods. The values of the utility function are also shown by the corresponding goods in the graph (it will facilitate our discussion below).

In our example, the set of goods is a -bundle (or, simply a bundle, as is clear). Indeed, the subgraph of induced by is connected. On the other hand, the set of goods is not a bundle as the corresponding induced graph is not connected. Further, the sequence is a -split (or simply a 3-split). Indeed, all sets in the split are bundles. It is also easy to see that the sequence is not a split as the set is not a bundle.

Let us now consider the utility function . The total utility of all goods under is 18. Further, it is easy to see that 3-splits into bundles of value 6 (under ) do not exist. To this end, we note that and cannot be in the same bundle valued at 6 as their total value is 7. Thus, the bundle containing must be either or . In each case the value of the bundle containing is not 6. Thus, . On the other hand, the sequence is a 3-split with its bundles having values 5, 7 and 6, respectively. Thus, .

Reasoning in a similar way one can show that maximin share values for the two other utility functions are also 5, that is, . Let us now observe that the sequence is a 3-split (indeed, its components are bundles). Moreover, , and . Thus, this 3-split defines an mms-allocation of goods on to three agents with the utility functions , and . Later, we will also see examples when mms-allocations of goods on graphs (specifically, cycles) do not exist.

We now are ready to present a few basic results on the problem of the existence of mms-allocations. Two agents are of the same type if they have the same utility functions. The maximin share allocation problem is easy when all but one agent are of the same type.

###### Proposition 2.1.

Let be a graph of goods. If we have agents and at most one of them is of a different type than the others, then an mms-allocation exists.

###### Proof.

The result is obvious for . Thus, we will assume . Let be the utility function of agents and a utility function of . Let be an mms-split for , and a bundle of most valuable under . Then, . Assign to agent . Next, allocate the remaining parts of to agents in an arbitrary way. Since for each bundle in , , the resulting allocation is an mms-allocation. ∎

In particular, this result applies to the case of two agents.

###### Corollary 2.2.

Mms-allocations of goods on a graph to two agents always exist.

Let be a graph of goods. An agent with a utility function on (a utility function on ) is -proportional if

 mms(n)(G,u)=∑v∈Vu(v)n.

We often omit from the notation if it is clear from the context. A set of agents (a set of utility functions) is proportional if every agent (utility function ) is -proportional.

An agent (a utility function) is -regular if it is -proportional and its maximin share (with respect to ) is 1. A collection of agents (utility functions) is regular if every agent in the collection is -regular. It is clear that for every agent in an -element regular collection of agents, the total value of all goods for that agent is .

Let be a positive real. A bundle is -sufficient for an agent if . An allocation is -sufficient if for every , is -sufficient for . Clearly, a -sufficient allocation is an mms-allocation. The next result shows that when studying the existence of -sufficient allocations (and so, in particular, mms-allocations) one can restrict considerations to the case when all agents are regular. We use it to prove Theorem 2.4 later on in this section but its full power becomes clear in Section 4.

###### Proposition 2.3.

Let be a graph of goods and a positive real such that for every regular collection of agents (for every regular collection of agents of at most -types) a -sufficient allocation exists. Then a -sufficient allocation exists for every collection of arbitrary agents (for every collection of arbitrary agents of at most types).

###### Proof.

Let be the set of agents and the set of their utilities. If for every , , then the assertion holds. Any split of into bundles is a -sufficient allocation.

Thus, let us assume that for at least one agent, say , . For each agent such that , we change her utility function to . We denote the new set of utilities by . It is clear that if is a -sufficient allocation with respect to the utility functions , then it is also a -sufficient allocation with respect to the original utilities . It is then enough to prove that a -sufficient allocation with respect to the functions exists.

For every agent , we denote by any mms-split into bundles with respect to the utility function . For each bundle of valued more than we decrease the value of some elements in that bundle to bring its value down to . In this way, we produce a new utility function, say . Since for every item , , . On the other hand, by the construction, for every bundle , . Thus, each utility function is -proportional and .

Next, for each agent we set and, for every , we define

 vi(x)=kiv′i(x),

Clearly, each utility function , , is -regular. Moreover, it follows directly from the construction that if the original utility functions are of at most types, then the resulting utility functions are of at most types, too.

Let be a -sufficient allocation for (its existence is guaranteed by the assumption). Therefore, for every agent , . Since and , it follows that . Next, we recall that for every , . Consequently, for every bundle , . Since for every , , it follows that

 v′′i(Pi)≥v′i(Pi)≥c⋅mms(n)(v′i)=c⋅mms(n)(v′′i).

Thus, is a -sufficient allocation of goods to agents in with respect to the utility functions and the result follows. ∎

Corollary 2.2 states that for two agents and for any connected graph of goods an mms-allocation exists. On the other hand, Bouveret et al. [2] gave an example of nonexistence of an mms-allocation for a cycle and four agents. In fact, as we show in Figure 2, even for three agents it may be that mms-allocations of goods on a cycle do not exist. In that figure, denote consecutive nodes of a cycle and the numbers in each row represent the utility functions. Observe that the maximin shares for the agents 1 and 2 are . For the agent 3, it is . Moreover, no two consecutive nodes have the total value satisfying any of the agents. Therefore, if an mms-allocation existed, it would have to be a split into three bundles of three consecutive nodes each. It is simple to check that none of the three possible partitions of this type is an mms-allocation.

On the other hand, for three agents and at most 8 goods on a cycle mms-allocations always exist.

###### Theorem 2.4.

For three agents and at most goods on a cycle, mms-allocations always exist.

###### Proof.

Let be a cycle with at most nodes and let be the set of agents. By Proposition 2.3, we assume without loss of generality that the agents are 3-regular. In particular, they are proportional and , for every .

Let us consider mms-splits for agents 1, 2 and 3, each into three bundles. By regularity, all bundles in those splits are non-empty. Thus, each split determines three edges that connect adjacent bundles of the split. Since has 8 edges and there are three splits, there is an edge in that connects adjacent bundles in two different splits, say for agents 1 and 2. It follows that for some bundles and of the mms-splits for agents 1 and 2, respectively, or .

Let us assume without loss of generality that . Clearly, the elements of the set can be added to one of the two other parts of the mms-split for the agent 2 to form a -split of the path , say , with both parts of value at least for the agent .

We now construct an mms-allocation as follows. If the set has value at least 1 for the agent 3, then she receives it. Clearly, the value of for the agent 1 is equal to . Thus, one of the parts has value at least 1 to agent 1. We allocate this part to agent 1. Finally, the agent receives the part that remains.

If does not satisfy the agent , then the agent gets this part. The value of for the agent , is larger than . Thus, we allocate the parts to the agents and in the same way as to the agents and in the previous case. ∎

We conclude this section with a comment on the notation. Formally, whenever we talk about allocations of goods on a subgraph of a graph we consider, we should use restrictions of the utility functions to the set of nodes of the subgraph. Continuing to refer to ’s is simpler and does not introduce ambiguity. Therefore, we adopt this convention in the paper.

## 3. Complexity and Algorithms

We assume familiarity with basic concepts of computational complexity and, in particular, with the classes NP, and . We refer to the book by Papadimitriou [10] for details. We start with general comments on how instances of fair division of indivisible goods on graphs are given. First, we assume any standard representation of graphs. As our primary objective is to understand when problems we consider have polynomial solutions and not most efficient algorithms to solve them, the details of how graphs are represented are not critical. Moreover, many of our results concern particular graphs such as cycles, when explicit representations of nodes and edges are not even needed. Finally, we assume that all utilities and other parameters that may be part of the input are rational, the least restrictive assumption for studies of algorithms and complexity.

We now formally define several problems related to maximin share allocations of indivisible goods on graphs and derive bounds on their complexity.

Mms-Values-G: Given a graph on goods, a utility function , that is, a sequence of non-negative rational numbers, an integer and a rational number , decide whether .

The problem was studied in the original case (with being a complete graph) by Bouveret and Lemaître [4]. Their complexity result and its proof extend to the general case. The hardness argument uses a reduction from the well-known NP-complete problem Partition [7]:

Partition: Given a set of non-negative integers, decide whether there is a set such that .

###### Proposition 3.1.

The problem Mms-Values-G is NP-complete.

###### Proof.

The problem is clearly in NP. Indeed, to solve the problem, we guess an -split and verify that each of its parts induces in a connected subgraph that has value at least (under ). The problem is NP-hard even in the case when is a complete graph, and the utility function is integer valued. We can show this by a reduction from Partition. Indeed, an instance of Partition consisting of a set of non-negative integers yields an instance to Mms-Values-G with the complete graph of goods, , and . It is easy to observe that an instance of Partition is a YES instance if and only if the corresponding instance of Mms-Values-G is a YES instance. Thus, NP-hardness follows. ∎

Another related problem concerns the existence of an allocation meeting given bounds on the values of its individual bundles.

Alloc-G: Given a graph on goods, utility functions (each is a sequence of length consisting of non-negative rational numbers) and rational numbers , decide whether an allocation for exists such that for every , .

###### Proposition 3.2.

The problem Alloc-G is NP-complete.

###### Proof.

The membership in NP is evident. The problem is NP-hard even if is a complete graph, , , and . Indeed, it becomes then the Mms-Values-G problem with being a complete graph, , (), and (). Thus, the proof of hardness for Proposition 3.1 can be applied here, too. ∎

We use these observations to show an upper bound on the complexity of the problem of the existence of an mms-allocation in the graph setting. We formally define the problem as follows.

Mms-Alloc-G: Given a graph of goods and utility functions (each is a sequence of length of non-negative rational numbers), decide whether an mms-allocation for and exists.

###### Theorem 3.3.

The problem Mms-ALLOC-G is in the class .

###### Proof.

The key step in the proof is the observation that we can rescale each utility function so that all its values are integers. To this end, given a utility function , , we compute the product, say , of all denominators of the rational numbers used by as its values. Next, we multiply all values of by to produce a new utility function . By the construction, all values of are indeed integers.

Let us denote by the original input instance to the problem and by the instance obtained by rescaling the utility functions in the way described above. We note that the products and the rescaled utility functions can be computed in time , where is the number of digits in the binary representation of the largest integer appearing as the numerator or the denominator in rational numbers specifying the original utility functions . Since the size, say , of the input instance satisfies , can be computed in polynomial time in .

Finally, we note that is a YES instance of the problem Mms-ALLOC-G if and only if is a YES instance of the problem. In fact, an allocation is an mms-allocation for if and only if is an mms-allocation for .

Let us now consider an auxiliary problem where, given a graph on nodes and a sequence of non-negative integers (that is, a utility function), the goal is to compute . We will design for this problem an algorithm with an NP-oracle. We will then show that our algorithm runs in polynomial time in the size of the representation of , where we consider each call to an oracle to be a single step taking a constant amount of time.

To this end, we observe that . Thus, we can compute by binary search on the range of possible values for . Each step starts with a range, say , that contains . We narrow down this range by making a call to an oracle for the problem Mms-Values-G, which we proved to be NP-complete above. The call to the oracle is made on the instance consisting of , and . Depending on the oracle output, it results in a new smaller range — either or . The process stops when the range is reduced to just one element and that element is returned as .

The number of range-narrowing steps is given by . Clearly,

 log2(⌊(m∑j=1sj)/n⌋+1)≤log2(m∑j=1sj+1)≤m∑j=1log2(sj+1).

Since the number of bits needed to represent a non-negative integer is given by , it follows that the size, say , of the representation of a problem instance satisfies . Thus, the number of range-narrowing steps is bounded by . Consequently, the oracle algorithm we described runs indeed in polynomial time in .

It follows that the problem Mms-Alloc-G can be solved for an instance by a procedure consisting of these three steps:

1. Compute the instance .

2. Compute the values , where are the rescaled utility functions computed in step (1). This is done using the oracle algorithm described above. It can be applied as all utilities in are integer-valued.

3. Decide whether there is an allocation for such that , for every , by invoking once an NP-oracle for the problem Alloc-G.

We recall that can be computed in polynomial time in (the size of the original instance ). Based on that and on our discussion of the auxiliary problem, step (2) of our algorithm also runs in polynomial time in , counting each oracle call as taking a unit amount of time. Finally, the last step takes a single call to an oracle. Thus, the entire algorithm runs in polynomial time in , where we count each oracle call as taking the unit amount of time. Since the oracles used by the algorithm are for NP-complete problems, the problem Mms-Alloc-G is in . ∎

The upper bound established by Theorem 3.3 applies also in the case when is assumed implicitly, for instance, when it is a path, a cycle or a complete graph represented by its set of nodes (but not edges). It is because the number of oracle calls is bounded by the size of the representation of the utility functions only. In the case of complete graphs, Theorem 3.3 yields an improvement on the bound obtained by Bouveret and Lemaître [4]. We do not know if the upper bound of can be improved in general and, in particular, whether it can be improved for complete graphs. On the other hand, we do know that it can be improved for trees. Bouveret et al. [2] proved the following two results.

###### Theorem 3.4 (Bouveret et al.[2]).

There is a polynomial time algorithm that computes and a corresponding mms-split given a tree of goods , a non-negative rational utility function on the nodes (goods) of , and an ingeter .

###### Theorem 3.5 (Bouveret et al.[2]).

For every tree of goods and every set of agents with non-negative rational utility functions on the goods in , an mms-allocation exists. Moreover, there is a polynomial-time algorithm to find it.

The results we presented suggest a question of the relationship between the complexity of the Mms-Alloc-G problem and the properties of the underlying graph, as it becomes more complex than trees. The first step towards understanding how the complexity grows is to analyze the case of cycles and unicyclic graphs.

First, we show that as in the case of trees (cf. [2]), the maximin share values and mms-splits for the case when goods form a cycle (or a unicyclic graph) can be computed in polynomial time.

###### Theorem 3.6.

There is a polynomial time algorithm for computing and a corresponding mms-split, where is a unicyclic graph and is a rational-valued utility function.

###### Proof.

Using the rescaling technique discussed in the proof of Theorem 3.3, we can reduce in polynomial time the general problem to the problem when all utilities are integers. To this end, we compute the product, say , of all denominators of the rational numbers that are values of goods under (if all values are integers, we assume the denominator is 1; this applies, in particular, to the case when all utilities are 0). We then define a new utility function by multiplying the values of by . Once the maximin share value for the rescaled utility function is computed, it is then used as the numerator of the maximin share for and is used as the denominator. Thus, to complete the proof it suffices to describe a method of computing and an mms-split under the assumption that all values of are integers.

Let be the unique cycle of . Every -split has a bundle that contains or is a split of the graph for some edge . Thus,

 mms(n)(U,u)=max(maxe∈Cmms(n)(U−e,u),mmsC),

where stands for

 maxP1,…,Pnmini=1,…,nu(Pi),

with the maximum taken over all splits that have a bundle containing . To compute , we proceed as follows. We construct a tree by contracting in to a single “supernode,” say . Thus, the nodes of are all nodes of and the supernode . We define a utility function on the nodes of by setting

 u′(x)={u(x)if x is a node of U−C (not the % supernode)∑y∈Cu(y)if x=c (is a super node).

Clearly, . We note that and can be computed in polynomial time. Moreover, and all graphs , are trees. We now apply the algorithm by Bouveret et al. [2] (cf. Theorem 3.4) to compute and , for all edges , as well as the corresponding mms-splits. This takes polynomial time. We then select the largest value among them and return it together with its mms-split (in the case, the largest value is , in the bundle containing the superode, we replace it with the nodes of ). ∎

It is now a matter of routine to show that the Mms-Alloc-G problem for cycles and, more generally, for unicyclic graphs is in NP.

###### Corollary 3.7.

The problem Mms-Alloc-G for unicyclic graphs is in NP.

###### Proof.

Let be a unicyclic graph and rational-valued utility functions defined on the nodes of . The following non-deterministic polynomial-time algorithm decides the problem Mms-Alloc-G: (1) guess an allocation , (2) compute the values , , and (3) verify that , . By Theorem 3.6, the step (2) can be accomplished in polynomial time. Thus, the entire algorithm runs in polynomial time. ∎

We do not have an argument for NP-hardness of the problem Mms-Alloc-G. Thus, we do not know whether the bound obtained in Corollary 3.7 is tight in general. We do know, however, that in some special cases it can be improved. We will now discuss these results.

Our first group of results is concerned with the case when the number of goods is small with respect to the number of agents, specifically, when . Our results rely on the following simple observation.

###### Proposition 3.8.

Let be a cycle, a utility function on , and an integer. For every node of , .

###### Proof.

Let be an mms-split of for and . Let be the bundle in containing , and let and be the two bundles in inducing in segments neighboring the one induced by , respectively preceding it and succeeding it when traversing clockwise ( if ). We move all goods in that precede to and those that succeed to . In this way each bundle still spans a connected segment in . Next, we remove the “new” (at this point, consists of only). The result is a split of into bundles, in which every bundle has value at least . Thus, . ∎

We now are ready to show that, when there are goods on a cycle and agents, and , then mms-allocations are guaranteed to exist. Moreover, we also show that this result is sharp — having exactly goods allows for situations when mms-allocations do not exist.

###### Theorem 3.9.

If , then an mms-allocation of goods on a cycle to agents exists and it can be computed in polynomial time.

###### Proof.

Let us consider agents with utility functions . Let be an mms-split for the agent . Clearly, for every bundle , . Since , at least one bundle in consists of only one element, say . It follows that . Since is a path (and so, a tree), Theorem 3.5 implies that there is an allocation giving each agent , , a bundle valued at least . By Proposition 3.8, each such bundle is valued at least . Thus, this allocation extended by the bundle , allocated to the agent , forms an mms-allocation of the goods on to agents.

For an algorithm, we (1) compute the maximin share ; (2) select an item such that (as argued above, such an exists); (3) construct an mms-allocation of goods on the path to agents (possible as is a tree); and (4) extend the allocation constructed in (3) by giving to .

By our argument above, the allocation constructed in step (4) is an mms-allocation. Steps (1) and (3) can be accomplished in polynomial time by Theorems 3.6 and 3.5, respectively. The same obviously holds for steps (2) and (4). Thus, the algorithm we described runs in polynomial time. ∎

This result is sharp. If and then an mms-allocation of goods on a cycle to agents may not exist as shown by the example in Figure 3.

Indeed, all maximin share values are . Thus, every bundle in any mms-allocation would have to contain at least two elements. Since , every bundle would have to consist of exactly two elements. There are only two splits of a cycle with nodes into bundles of two consecutive goods. None of them is an mms-allocation. The assumption that is essential. We have seen earlier that if then mms-allocations exist for every number of goods. Thus, they exist for . If , mms-allocations of goods on a cycle exist for every (cf. Theorem 2.4). In particular, they exist if .

As our example shows, if , there are cases when mms-allocations do not exist. However, whether an mms-allocation exists in the case when can be decided in polynomial time and, if so, an mms-allocation can be computed efficiently.

###### Corollary 3.10.

There is a polynomial time algorithm deciding the existence of an mms-allocation of goods on a cycle to agents, and computing one, if one exists.

###### Proof.

Let be the cycle and the rational-valued utility functions of the agents . We first compute the values , (cf. Theorem 3.6). If for some item and agent , , then reasoning as in the proof of Theorem 3.9 one can show that an mms-allocation for exists, and that it can be found in polynomial time. Otherwise, if there is an mms-allocation of goods on to agents, every bundle in this allocation consists of two consecutive goods. There are only two candidates for such allocations and one can check whether any of them is an mms-allocation in polynomial time (as the values are known). ∎

The next result of this section concerns the case of agents of types, where is fixed and is not a part of the input. Before we present our result and prove it, we discuss how inputs and outputs are represented.

As we already noted earlier, instances to an mms-allocation problem on a cycle are specified by a non-negative integer representing the number of goods, and -element sequences of non-negative rational numbers, each sequence representing a utility function. We note that implicitly defines the goods as , as well as the cycle as having these goods appear on it in this order. Further, we adopt a natural convention that for every , the th element in every utility sequence provides the utility value for the good . This representation consists of rational numbers (one of them, , an integer).222We note that we do not include the number of agents, , in the input; if we need it, we can compute it by counting in the input the sequences representing the utility functions.

In the case when agents can be grouped into types, where is fixed and not part of input, the case we are now considering, input instances can be represented more concisely by a non-negative integer , sequences of non-negative rational numbers ( utility functions) and non-negative integers , where each represents the number of agents of type (that is, having as their utility function). Thus, an instance consists of rational numbers represented by pairs of integers, and integers. We will use to denote the length of the binary representation of the largest of the integers appearing in this representation, and to denote the total size of the binary representations of the integers in the instance. In particular, we have that .

We observe that if , then the maximin share for each agent is 0 and, consequently, every allocation of goods to agents is an mms-allocation. Since is fixed, computing takes time and, consequently, also . Thus, this case can be recognized in time and then handled directly. Namely, we return a sequence of 0’s as the maximin shares for agents of types and, if an mms-allocation is required, we allocate all goods to agent 1 and empty bundles of goods to all other agents. We do not generate any explicit representation for this allocation. It is implicitly identified by the all-0’s output of the maximin shares. This is to avoid having to output explicitly an -element sequence of bundles, as , the length of this sequence, may be exponential in the size of input. It follows that the key case is then the case .

###### Theorem 3.11.

For every integer , there is a polynomial time algorithm deciding existence of an mms-allocation of goods on a cycle to agents of types (and computing one, if one exists).

###### Proof.

Let us consider an instance to the problem given by an integer (the number of goods), sequences , each consisting of non-negative rational numbers ( utility functions), and non-negative integers (the numbers of agents of type , respectively). We start by computing , which can be accomplished in time, as is fixed (we recall that we write for the size of the input instance). The case has been discussed above. Thus, in what follows we assume that . An important consequence of this assumption is that for every , .

To decide whether there is an mms-allocation and, if so, to compute it, we compute the values , . Since is fixed, Theorem 3.6 implies that all these values can be computed in time bounded by a polynomial in , where represents the largest size of the representation of an input utility function and, consequently, also by a polynomial in .

We now observe that an allocation of goods on to agents of types given by is an mms-allocation on if and only if for some edge of , is an allocation of goods on the path to these agents such that for every agent of type , the bundle allocated to that agent satisfies .

Thus, to prove the assertion, it is enough to show that the following problem has a polynomial-time solution: Given a path of goods , appearing in this order on , rational-valued utility functions , non-negative integers such that , and non-negative integers , find an allocation of goods on to agents such that for every agent of type , the bundle assigned to that agent satisfies .

To describe our method, we define to be the set of all sequences such that for every , . Clearly, the number of sequences in is bounded by . If denotes a sequence and , where , then we write for the sequence which, we note, also belongs to .

For a sequence , we define to be the smallest such that there is an allocation of goods to agents, exactly of them of type , , so that each agent of type obtains a bundle worth at least . If such an allocation does not exist, is set to .

Next, for every and every , we define to be the minimum such that . We set if such a does not exist. Clearly, all values can be computed in time .

Let . We will show that can be efficiently computed. Clearly, (there are no agents to get any bundles and so, even the empty path suffices). Thus, let us consider and let us assume that . Let us define . It is easy to see that

 (1) T(H)=min{k(T(H−r),r):r∈I}.

Assuming that all values , for , are known, can be computed in time . It follows that with the initial value of , considering sequences in any order consistent with non-decreasing sums of their elements and using the formula (1) to compute , one can compute in polynomial time, in fact, in time (we recall that all values can be computed in time ; also, the number of entries in is and each entry can be computed in time).

If , then there is no split of such that for every agent of type , its bundle satisfies . Otherwise, and a split solving the problem exists. Moreover, it can be computed in the standard way for dynamic programming algorithms. To this end, each time the formula (1) is applied we have to record an index that minimizes the expression ). This information allows us to construct the split in polynomial time in .

As all algorithmic tasks we presented can be accomplished in time bounded by a polynomial in S, the assertion follows. ∎

We close this section with yet another corollary to Theorem 3.6. It concerns a possibility of regularizing utility functions on unicyclic graphs in polynomial time by converting a method used in the proof of Proposition 2.3 into an algorithm. Let us call a collection trivial if for every , . We will call all other collections non-trivial.

###### Corollary 3.12.

There is a polynomial time algorithm that, given a unicyclic graph of goods, and a non-trivial collection of rational-valued utility functions , , on , produces a rational-valued regular collection of utility functions on such that for every , if a split is a -sufficient allocation with respect to ’s then it is a -sufficient allocation with respect to ’s. If the original utility functions are of at most types, then the resulting utility functions are of at most types.

###### Proof.

The algorithm follows the method we used in the proof of Proposition 2.3. It consists of the following key steps.

1. Rescale the utilities as described in the proof of Theorem 3.3 to produce an equivalent collection of integer-valued utilities (by equivalent we mean determining the same splits as mms-allocations).

2. Compute the maximin shares , .

3. Select one utility function such that . For each agent such that , replace with ; denote the new utility functions , .

4. For a good and a utility function , use the binary search method, similar to that used in the proof of Theorem 3.3, to find the smallest such that ; replace with ; repeat for all goods as long as it is possible to decrease a value of some utility function on some good.333Here, stands for the utility function obtained from by setting its value on to and keeping all other values as they are in .

5. Rescale the computed utility functions so that the values of each of them sum up to . Call the resulting functions .

The correctness of the method, both for the main statement and under the restriction to utility functions of at most types, follows from the argument used to prove Proposition 2.3. For the running time, we note that step (1) runs in polynomial time (we argued this in the proof of Theorem 3.3). Step (2) runs in polynomial time (Theorem 3.6). Step (3) runs in time . Next, we note that the argument we used in the proof of Theorem 3.3

to estimate the running time of the “range narrowing” binary search and the fact that the maximin shares can be computed in polynomial time (Theorem

3.6) together imply that step (4) runs in polynomial time. Step (5) consists of additions and multiplications involving utility values produced in step (4) and the integer . Thus, it also runs in polynomial time in the size of the original instance. ∎

## 4. Approximate Maximin Share Allocations On a Cycle

We start with a simple observation that -sufficient allocations always exist and, moreover, can be found in polynomial time.

###### Proposition 4.1.

There is a polynomial time algorithm which, for any number of agents and any number of goods on a cycle, constructs a -sufficient allocation.

###### Proof.

We remove any edge from the cycle and get a path, say . The maximin share for each agent on is at least half of the original maximin share for . Indeed, let us consider an arbitrary agent and her mms-split of . By removing , no more than one part of this split may break into two pieces. The value for the agent of one of these pieces is at least . We adjoin the other piece, if it is present, to its neighboring part in the mms-split of . In this way, we obtain a split of . Clearly, in this split of every piece is worth to at least , so the claim follows.

Thus, a -sufficient allocation can be found by (1) removing any edge from the cycle, (2) applying to the resulting path the algorithm by Bouveret et al. [2] that constructs in polynomial time an mms-allocation for trees (cf. Theorem 3.5). ∎

To find a better guarantee than turns out to be non-trivial. We will show that it can be improved to