# High-Multiplicity Fair Allocation Using Parametric Integer Linear Programming

Using insights from parametric integer linear programming, we significantly improve on our previous work [Proc. ACM EC 2019] on high-multiplicity fair allocation. Therein, answering an open question from previous work, we proved that the problem of finding envy-free Pareto-efficient allocations of indivisible items is fixed-parameter tractable with respect to the combined parameter "number of agents" plus "number of item types." Our central improvement, compared to this result, is to break the condition that the corresponding utility and multiplicity values have to be encoded in unary required there. Concretely, we show that, while preserving fixed-parameter tractability, these values can be encoded in binary, thus greatly expanding the range of feasible values.

04/12/2019

### Parallel parametric linear programming solving, and application to polyhedral computations

Parametric linear programming is central in polyhedral computations and ...
11/12/2018

### Pareto-Optimal Allocation of Indivisible Goods with Connectivity Constraints

We study the problem of allocating indivisible items to agents with addi...
05/19/2020

### Integer Linear Programming for the Tutor Allocation Problem: A Practical Case in a British University

In the Tutor Allocation Problem, the objective is to assign a set of tut...
02/06/2022

### (Almost) Envy-Free, Proportional and Efficient Allocations of an Indivisible Mixed Manna

We study the problem of finding fair and efficient allocations of a set ...
09/18/2021

### Envy-Free and Pareto-Optimal Allocations for Asymmetric Agents

We study the problem of allocating m indivisible items to n agents with ...
04/27/2022

### Fair and Efficient Allocation with Quotas

In many settings, such as the rationing of medical care and supplies, un...
09/19/2019

### Parametrized Complexity of Manipulating Sequential Allocation

The sequential allocation protocol is a simple and popular mechanism to ...

## 1 Introduction

Fairly allocating (indivisible) items  is a key issue in a world of limited resources. For instance, this is reflected by popular tools such as the Adjusted Winner Procedure, the web platform spliddit.org , or application contexts such as food-banks . In this work, we significantly strengthen our previous work  in this direction by extending the application domain of an algorithmic result for “high-multiplicity fair allocation” based on mathematical programming tools. To this end, note that the focus of our work is on provably fair allocations.

To understand important facets of our research contribution, let us become more precise on the studied problem. We consider a set of item types, each coming with the number of actual items of this type, and a set of agents who report their utilities over each item type. An allocation of items is an assignment of disjoint sets of the items, called bundles, to the agents. One of the most prominent fairness concepts is envy-freeness. It considers an allocation as fair if there is no agent that would prefer a bundle of any other agent over her own one. However, it is trivial to achieve envy-freeness by giving every agent an empty bundle. To circumvent this issue, several “efficiency” measures of allocations have been proposed. A very important one, Pareto-efficiency, requires that for an efficient allocation there exists no other allocation that is preferred by at least one agent while, at the same time, does not make any agent worse off. Putting all this together, we end up with so-called “envy-free Pareto-efficient allocations,” which are the focus of our studies.

Finding envy-free Pareto-efficient allocations, however, is a computationally very hard problem. For instance, the corresponding decision problem is -complete for general utilities  and even for (positive) additive utilities —indeed, the latter is the model we study in our work. Notably, the scenario we study is also an important part of the web platform spliddit.org. Formally, the key problem of the paper is the following.

In previous work, Bliem et al.  left open111Technically, the open question was formulated for the parameter , where  denotes the number of different values in the utility functions. This parameter can easily be seen to be equivalent to our parameter  in terms of fixed-parameter tractability. Note that Bliem et al.  used the variable name  for the number of items and showed fixed-parameter tractability for this parameter. whether EEF–Allocation is fixed-parameter tractable with respect to the (combined) parameter . This was answered partially positively (with the restriction of unary encoded item multiplicities and utilities) in our recent work . Now, we further improve on this by relaxing the constraint of unary encoded item multiplicities and utilities thereby allowing binary encodings. This greatly expands the range of values we can deal with efficiently in the practically relevant case of small numbers of agents () and items types (). To this end, we make use of insights from parametric integer linear programming.

### 1.1 Related Work

We give a brief overview on the most relevant related work splitting in into two parts organized thematically.

#### Efficient and Envy-free Allocations of Indivisible Resources.

Bouveret and Lang  were the first studying the computational complexity of computing Pareto-efficient and envy-free allocations of indivisible items in a systematic way. Their findings include -completeness for so-called monotonic dichotomous preferences as well as NP-hardness and polynomial-time solvable for several special cases. Most relevant to our setting with additive utility-based preferences, they showed that even if there are just two agents or if every agent assigns either utility value  or  to each item, the problem of finding a Pareto-efficient and envy-free allocation remains NP-hard. Moreover, de Keijzer et al.  showed that -completeness even holds for positive additive preferences. Bliem et al.  analyzed the parameterized complexity, showing that the problem becomes tractable for the parameter “number of items” and various special settings but remains intractable for the parameter “number of agents.”

Multiple approaches have been developed to relax fairness concepts in order to circumvent computational intractability as well as possible non-existence of Pareto-efficient and envy-free allocations. For instance, Lipton et al.  considered the concept of envy-freeness up to one good (EF1). Herein, every agent compares its bundle with the bundles of all other agents and she is envious if any other bundle minus the most valuable item in there is better than her own bundle. Further studied concepts include envy-freeness up to any good (EFX) [14, 25], minimum envy , group envy-freeness, group Pareto-efficiency , or graph envy-freeness [1, 7, 12]; Amanatidis et al.  provide a comparison of approximate or relaxed fairness notions.

Barman et al.  developed an algorithm that computes an allocation that is Pareto-efficient and EF1 with pseudo-polynomial running time (being polynomial in the number of agents, the number of items, and the maximum utility). Caragiannis et al.  showed how to compute an allocation that maximizes Nash welfare and thus yields Pareto-efficiency and EF1. While a round-robin allocation of items can be used to obtain a complete EF1 allocation in polynomial time when all items have positive utilities, Aziz et al.  have argued that this procedure fails when items may have negative utilities. Leaving the complexity of computing Pareto-efficient and EF1 allocation (when negative utilities are allowed) open, they showed that a complete EF1 allocation can be found in polynomial time.

#### Parametric ILP applications.

Eisenbrand and Shmonin [16, Theorem 4.2] gave an algorithm that, if the number of variables is fixed, solves the given instance of Parametric ILP (PILP) in polynomial time. To the best of our knowledge, Crampton et al. [15, Corollary 2.2] were the first to give an “interpretation” of the result of Eisenbrand and Shmonin  in terms of parameterized complexity analysis. More specifically, they showed membership in the complexity class FPT, that is, they showed a running time  for an instance  of PILP provided that the coefficients of the matrix  are encoded in unary. Using this result Crampton et al.  initiated the parameterized study of the so-called resiliency problems  (such as the Resiliency Closest String problem).

Knop et al.  used the interpretation of Crampton et al.  to solve a decade-long-standing open question of FPT-membership of a variant of the Bribery problem in the field of elections manipulation. Recently, Bredereck et al.  also used the interpretation of Crampton et al.  in the context of fair allocation. More specifically, they showed [11, Corollary 5] that finding a fair and efficient allocation is fixed-parameter tractable for few agents and few item types. The result holds for numerous different concepts of fairness and efficiency. Yet, their result holds only when the maximum utility value an agent assigns to an item type and item multiplicities are encoded in unary. As we shall shortly see, we are improving upon this result by allowing item multiplicities to be encoded in binary.

### 1.2 Our Contribution

In Section 2, we present an interpretation of Theorem 4.2 of Eisenbrand and Shmonin  (which is a bit more detailed than the one provided by Crampton et al. ). More specifically, we observe that it is possible to derive a certificate of infeasibility of a given PILP sentence. This inspired us to work with a complementary problem, since when doing so we derive a (membership) certificate for the original problem. To this end, in Section 3, we model nonexistence of a solution to the EEF–Allocation problem as an instance of PILP. That is, the sentence we describe expresses that “every envy-free allocation is dominated.” It is worth pointing out that if such a sentence is not valid, then the certificate (right-hand side) is a Pareto-efficient allocation, since it is not possible to dominate it. The combination of the two yields the following strengthening of Corollary 5 in our previous work  for the EEF–Allocation problem. Notably, our previous model was based on the big-M method, used essentially for the negation present in the model (to describe that a certain collection of improving steps cannot be applied to the given allocation), which we avoid here. The main contribution of this paper is to prove the following.

###### Theorem 1.1

Let  be an instance of the EEF–Allocation problem with . Then, there is an algorithm that decides  in time, for some computable function .

We remark that our technique also applies to other variants of EEF–Allocation where we replace envy-freeness or Pareto-efficiency by related concepts. We refer to the conclusion (Section 4) for a discussion about further applications.

## 2 Preliminaries

For a positive integer , by  we denote the set

. We use boldface letters for vectors (e.g.

) and for a vector in dimension we denote with  its -th coordinate for . For two vectors  and  in dimension, respectively, and , vector  is an -dimensional vector . A polyhedron is an intersection of half-spaces, that is, a set . A partially open polyhedron is an intersection of half-spaces and open half-spaces, that is, a set .

### 2.1 Allocations, Envy-Freeness, and Pareto-Efficiency

Consider  agents , a set  of  item types, and multiplicities  for each . An allocation  is an integral -dimensional vector , i.e., for each agent the number of items she gets of every item type. For each agent , let  be the agent’s utility function. We assume the preferences of the agents to be additive, that is, the utility value for a set of items is the sum of the items utility values. Thus, we define the satisfaction of agent  from allocation  as ; for brevity, we delicately abuse the notation and denote it by . We formally describe envy-freeness and Pareto-efficiency as follows.

###### Definition 1

Let  be a set of  agents,  be a set of  item types with multiplicities  for each item type , and  be an allocation of the items to the agents in .

An allocation  is envy-free if there is no pair  of agents such that .

An allocation  is Pareto-dominated if there exists another allocation  such that for every agent  it holds that  and for at least one agent the inequality is strict. An allocation is Pareto-efficient if it is not Pareto-dominated.

### 2.2 Parameterized Complexity

A parameterized problem’s input consists of an instance  and a parameter value ; the task is to decide whether is a yes-instance. We say that a parameterized problem is fixed-parameter tractable with respect to  (belongs to the class FPT) if there is an algorithm deciding  in  time, where  is the size of the input and is an arbitrary computable function of parameter . The following proposition will come handy later.

###### Proposition 1 ([18, Lemma 3.10])

For every two computable functions and with , there exists a computable function such that for every and we have .

### 2.3 Parametric Integer Programming in Fixed Dimension

For a rational polyhedron , the integer projection of , denoted by , is a collection of all vectors for which there exists an integral vector such that . Thus, formally

 Q/Zp:={\boldmathb∈Qm:(\boldmathb,\boldmathz)∈Q for some \boldmath% z∈Zp}.

Parametric Integer Programming (PILP) is the following problem. Given a matrix and a rational polyhedron , decide if for all vectors in the integer projection of , the system of inequalities has an integral solution. In other words, one has to decide the validity of the sentence

 ∀\boldmathb∈Q/Zp ∃% \boldmathx∈Zn:A\boldmathx≤\boldmathb. (PILP)

The PILP problem is complete for the class  [27, 29]. However, extending the (to the best of our knowledge) pioneering works of Kannan [19, 20] on efficient algorithms for PILP, Eisenbrand and Shmonin [16, Theorem 4.1 and Theorem 4.2] gave a polynomial-time algorithm for PILP for the fixed number of variables and dimension . An analysis of their algorithm leads to the following Proposition 2; we discuss the details afterwards.

###### Proposition 2

There is an algorithm deciding the sentence (PILP) in

 f(m,n,p)⋅ϕh(n)⋅poly(L)

time, where is the size (encoding length) of any column in , is the encoding length of the sentence and (the description of) the polyhedron , and and are computable functions. Moreover, if the sentence (PILP) is not valid, then a certificate  is provided (i.e., has no integral solution with such a ).

Proposition 2 essentially coincides with a known result [16, Theorem 4.2] but for the sake of completeness we discuss its proof here. First, we make sure (using Fourier-Motzkin) that for all the system has a fractional solution; if not, then such a  is reported. In order to do so, one has to solve many mixed ILPs in dimension  using Lenstra’s celebrated result  in time. Second, we partition the polyhedron  into  partially open polyhedrons  with the constant  due to Eisenbrand and Shmonin [16, Theorem 4.1], that is,

 t=O((m2nϕn−1)n¯ω(n))=f′′(m,n)⋅ϕh(n),

where , is the constant from the flatness theorem (the current best value is  ), and . Due to Eisenbrand and Shmonin [16, Theorem 4.1] each , where . It also gives  transformations  for  and . Now, for any there is an integral point in the polyhedron  if and only if for some . The negation of this condition is then verified using a mixed ILP (for each ) with  integral variables. Again, if the sentence (PILP) is not valid, then one of the above mixed ILPs is feasible; thus, providing the certificate . It follows that the above sketched algorithm runs in  time.

## 3 Finding EEF–Allocations via PILP

In this section we show how to use Proposition 2 to solve the EEF–Allocation problem for the (combined) parameter the number of agents and item types efficiently. From now on, we refer to the number of agents as  and to the number of item types as .

As already mentioned, we show the FPT-membership of EEF–Allocation for the parameter by constructing a (PILP) sentence deciding whether every envy-free allocation of the given collection of items is dominated by some other allocation. The high-level idea is as follows. For the constructed (PILP) sentence, the polyhedron  describes all envy-free allocations. In fact, the polyhedron also contains additional, technical parts needed later when we want to have if the allocation dominates the allocation for which we have . In the proof we show how to design a proper polyhedron . We begin the description from the latter point, as it will give us the intuition how the polyhedron  should look like. Recall that an allocation  consists of entries , for each agent  and item type , with the meaning “we give items of item type  to agent .”

#### Dominating an Allocation.

Let  be an allocation such that . We want to design a matrix  so that if and only if  is an allocation that dominates .

 ∑a∈Axai ≤mi ∀i∈I (1) xai ≥0 ∀a∈A,∀i∈I (2)

It is not hard to see that  satisfies (1) and (2) if and only if  is a valid allocation. Thus, it remains to check that  dominates . One can check this with the following system of inequalities (i.e., here we allow ourselves to use the vector  which we later replace with ).

 ∑i∈Iua(i)⋅xai ≥∑i∈Iua(i)⋅zai ∀a∈A (3) ∑a∈A∑i∈Iua(i)⋅xai ≥1+∑a∈A∑i∈Iua(i)⋅zai (4)

Again, we observe that  dominates  if and only if it satisfies (3) and (4). Note that (3) ensure that the total utility of an agent  in the allocation  is at least as good as in the allocation . Furthermore, given that condition (4) ensures that there is at least one agent  for whom it holds that .

#### The polyhedron Q.

Given the conditions (1)–(4) we want to design the polyhedron . Note that we have and, since we have , we get . We split the vector  according to the group of inequalities above (i.e.,  is the vector of right-hand sides for the conditions (1) and so forth). Observe that we need

 \boldmathb1=\boldmathmand\boldmathb2=\boldmath0, (5)

where is the vector of item multiplicities. Clearly, if we now use the above-defined  and  substituting the right-hand sides of, respectively, conditions (1) and (2), the meaning of conditions (1) and (2) remains the same (i.e., they still encode the fact that  is an allocation).

What remains to find out is the vector  and the value of . To achieve this, we first ensure that  is an envy-free allocation and then derive  and  from this analysis. The following conditions ensure that  is an envy-free allocation.

 ∑a∈Azai ≤mi ∀i∈I (6) zai ≥0 ∀a∈A,∀i∈I (7) ∑i∈Iua(i)⋅zai ≥∑i∈Iua(i)⋅za′i ∀a,a′∈A (8)

Observe that (6) and (7) ensure that  encodes an allocation (in the same way as (1) and (2) for ). The condition (8) then ensures that  is envy-free, since the left-hand side is the total satisfaction of agent  and the right-hand side is the total value of the bundle of  viewed via the utility function of agent  (i.e., the satisfaction of  if she got the bundle of ). It remains to bind  to .

 ∑i∈Iua(i)⋅zai =ba3 ∀a∈A (9) ∑a∈A∑i∈Iua(i)⋅zai =b4 (10)

Note that the left-hand side of (9) is exactly the right-hand side of (3) and the same holds for (10) and (4). Consequently, we can replace the right-hand sides of (3) and (4) with the right-hand sides of (9) and (10) while keeping their meaning unchanged. The next lemma follows from the above discussion.

###### Lemma 1

Let  be a polyhedron defined by the conditions (5)–(10). Then, if and only if

• is an envy-free allocation of the items described by ,

• is the vector of right-hand sides of the conditions (1)–(4).

#### Using Proposition 2.

In order to finish the proof of Theorem 1.1 we want to apply Proposition 2 to the parametric ILP we constructed for a given instance  of the EEF–Allocation problem. Note that in the presented model described by (1)–(10), the dimension of  is , where  is the number of agents in  and

is the number of item types. It remains to estimate the parameter

(the maximum encoding length of a column in , the matrix of left-hand sides in (1)–(4)). The columns of the matrix  are vectors of length ; thus, there are many delimiter symbols in their encoding. Recall that each such column corresponds to an agent  and an item . There are  ones (one from condition (1) and one from (2)). Finally, there are  numbers both equal to . Now, since we assumed , we get by Proposition 1. Now, applying Proposition 2 we either get that for every envy-free allocation there exists one that dominates it or the sentence does not hold. In the later case, we know that this means there is a Pareto-efficient envy-free allocation. This finishes the proof of Theorem 1.1.

## 4 Conclusion

We described a somewhat new usage of Parametric ILPs in fixed dimension in the design of parameterized algorithms, enabling to significantly improve a previous fixed-parameter tractability result. To the best of our knowledge, we are the first to model (solve) the negation of a given instance to obtain a solution to the original one. We hope that this approach might lead to new results in parameterized algorithms. Naturally, we would like to see many more applications of PILP in algorithm design.

Remarkably, our approach can be used with numerous other problem variants that aim at finding efficient fair allocations. Indeed, it turns out that our technique can be applied to the -Efficient -Allocation problem , which is a more general variant of the EEF–Allocation where Pareto-efficiency is replaced by some efficiency notion  and envy-freeness is replaced by some fairness notion . More precisely, we can show fixed-parameter tractability for EEF–Allocation parameterized by the number  of agents and the number  of item types for various efficiency and fairness notions. Besides relaxed notions of Pareto-efficiency (e.g., where one only cares about being dominated by similar allocations) or relaxed envy-freeness such as EF1 [6, 14, 24] or EFX [14, 25], this includes also generalizations of these concepts such as group Pareto-efficiency  or graph envy-freeness  or somewhat related fairness concepts such as MaxiMinShare [13, 26].

Summarizing, with our technique we can show that -Efficient -Allocation is fixed-parameter tractable for even if item multiplicities and utilities are binary encoded when

• [topsep=0pt]

• is a combination of (graph/group) Pareto-efficiency, and

• is a combination of (graph/group) EF, (graph) EF1, (graph) EFX, MaxiMin, or MaxiMinShare.

We refer to our previous work  on how to model these notions within the ILP framework.

## References

•  Abebe, R., Kleinberg, J., Parkes, D.C.: Fair division via social comparison. In: Proceedings of the 16th Conference on Autonomous Agents and MultiAgent Systems (AAMAS ’17). pp. 281–289 (2017)
• 

Aleksandrov, M., Walsh, T.: Group envy freeness and group pareto efficiency in fair division with indivisible items. In: Proceedings of the 41st German Conference on Artificial Intelligence (KI ’18). pp. 57–72. Springer (2018)

•  Amanatidis, G., Birmpas, G., Markakis, V.: Comparing approximate relaxations of envy-freeness. In: Proceedings of the 27th International Joint Conference on Artificial Intelligence (IJCAI ’18). pp. 42–48. AAAI Press (2018)
•  Aziz, H., Caragiannis, I., Igarashi, A.: Fair allocation of combinations of indivisible goods and chores. CoRR abs/1807.10684 (2018)
•  Banaszczyk, W., Litvak, A.E., Pajor, A., Szarek, S.J.: The flatness theorem for nonsymmetric convex bodies via the local theory of Banach spaces. Mathematics of Operations Research 24(3), 728–750 (1999)
•  Barman, S., Krishnamurthy, S.K., Vaish, R.: Finding fair and efficient allocations. In: Proceedings of the 19th ACM Conference on Economics and Computation (EC ’18). pp. 557–574. ACM (2018)
•  Bei, X., Qiao, Y., Zhang, S.: Networked fairness in cake cutting. In: Proceedings of the 26th International Joint Conference on Artificial Intelligence (IJCAI ’17). pp. 3632–3638. AAAI Press (2017)
•  Bliem, B., Bredereck, R., Niedermeier, R.: Complexity of efficient and envy-free resource allocation: Few agents, resources, or utility levels. In: Proceedings of the 25th International Joint Conference on Artificial Intelligence (IJCAI ’16). pp. 102–108. AAAI Press (2016)
•  Bouveret, S., Chevaleyre, Y., Maudet, N.: Fair allocation of indivisible goods. In: Brandt, F., Conitzer, V., Endriss, U., Lang, J., Procaccia, A.D. (eds.) Handbook of Computational Social Choice, chap. 12. Cambridge University Press (2016)
•  Bouveret, S., Lang, J.: Efficiency and envy-freeness in fair division of indivisible goods: Logical representation and complexity. Journal of Artificial Intelligence Research 32(1), 525–564 (2008)
•  Bredereck, R., Kaczmarczyk, A., Knop, D., Niedermeier, R.: High-multiplicity fair allocation: Lenstra empowered by -fold integer programming. In: Proceedings of the 2019 ACM Conference on Economics and Computation (EC ’19). pp. 505–523. ACM (2019)
•  Bredereck, R., Kaczmarczyk, A., Niedermeier, R.: Envy-free allocations respecting social networks. In: Proceedings of the 17th International Conference on Autonomous Agents and Multiagent Systems (AAMAS ’18). pp. 283–291. IFAAMAS (2018)
•  Budish, E.: The combinatorial assignment problem: Approximate competitive equilibrium from equal incomes. Journal of Political Economy 119(6), 1061–1103 (2011)
•  Caragiannis, I., Kurokawa, D., Moulin, H., Procaccia, A.D., Shah, N., Wang, J.: The unreasonable fairness of maximum nash welfare. In: Proceedings of the 17th ACM Conference on Economics and Computation (EC ’16). pp. 305–322. ACM (2016)
•  Crampton, J., Gutin, G.Z., Koutecký, M., Watrigant, R.: Parameterized resiliency problems. Theoretical Computer Science 795, 478–491 (2019)
•  Eisenbrand, F., Shmonin, G.: Parametric integer programming in fixed dimension. Mathematics of Operations Research 33(4), 839–850 (2008)
•  Goldman, J.R., Procaccia, A.D.: Spliddit: Unleashing fair division algorithms. SIGecom Exchanges 13(2), 41–46 (2014)
•  Jones, M., Lokshtanov, D., Ramanujan, M.S., Saurabh, S., Suchý, O.: Parameterized complexity of directed Steiner tree on sparse graphs. SIAM J. Discrete Math. 31(2), 1294–1327 (2017)
•  Kannan, R.: Test sets for integer programs, sentences. In: Cook, W.J., Seymour, P.D. (eds.) Proceedings of a DIMACS Workshop on Polyhedral Combinatorics. DIMACS Series in Discrete Mathematics and Theoretical Computer Science, vol. 1, pp. 39–48. DIMACS/AMS (1990)
•  Kannan, R.: Lattice translates of a polytope and the Frobenius problem. Combinatorica 12(2), 161–177 (1992)
•  de Keijzer, B., Bouveret, S., Klos, T., Zhang, Y.: On the complexity of efficiency and envy-freeness in fair division of indivisible goods with additive preferences. In: Proceedings of the 1st International Conference on Algorithmic Decision Theory (ADT ’09). pp. 98–110. Springer (2009)
•  Knop, D., Koutecký, M., Mnich, M.: A unifying framework for manipulation problems. In: Proceedings of the 17th International Conference on Autonomous Agents and Multiagent Systems (AAMAS ’18). pp. 256–264. IFAAMAS (2018)
•  Lenstra, Jr., H.W.: Integer programming with a fixed number of variables. Mathematics of Operations Research 8(4), 538–548 (1983)
•  Lipton, R.J., Markakis, E., Mossel, E., Saberi, A.: On approximately fair allocations of indivisible goods. In: Proceedings of the 5th ACM Conference on Electronic Commerce (EC ’04). pp. 125–131. ACM (2004)
•  Plaut, B., Roughgarden, T.: Almost envy-freeness with general valuations. In: Proceedings of the 29th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA ’18). pp. 2584–2603. SIAM (2018)
•  Procaccia, A.D., Wang, J.: Fair enough: Guaranteeing approximate maximin shares. In: Proceedings of the 15th ACM Conference on Economics and Computation (EC ’14). pp. 675–692. ACM (2014)
•  Stockmeyer, L.J.: The polynomial-time hierarchy. Theoretical Computer Science 3(1), 1–22 (1976)
•  Walsh, T.: Challenges in resource and cost allocation. In: Proceedings of the 29th AAAI Conference on Artificial Intelligence (AAAI ’15). pp. 4073–4077. AAAI Press (2015)
•  Wrathall, C.: Complete sets and the polynomial-time hierarchy. Theoretical Computer Science 3(1), 23–33 (1976)
{"ft_lang_label":"__label__en","ft_lang_prob":0.8715601,"math_prob":0.8808788,"size":25566,"snap":"2022-40-2023-06","text_gpt3_token_len":6143,"char_repetition_ratio":0.13954307,"word_repetition_ratio":0.030539947,"special_character_ratio":0.24297896,"punctuation_ratio":0.15794748,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9797502,"pos_list":[0,1,2,3,4,5,6,7,8,9,10],"im_url_duplicate_count":[null,null,null,null,null,null,null,null,null,null,null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2022-10-06T06:46:15Z\",\"WARC-Record-ID\":\"<urn:uuid:0634e57c-814f-4cee-80d6-7f6545abfc0c>\",\"Content-Length\":\"541590\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:0bdf390d-087a-4587-8c13-b9c15b5ea6a7>\",\"WARC-Concurrent-To\":\"<urn:uuid:12bd6b70-fdb5-466e-a0d4-8d9c8d460628>\",\"WARC-IP-Address\":\"44.241.74.67\",\"WARC-Target-URI\":\"https://deepai.org/publication/high-multiplicity-fair-allocation-using-parametric-integer-linear-programming\",\"WARC-Payload-Digest\":\"sha1:AAYQHNXKVP3CQIURQZAOV7WCHLRDKBCV\",\"WARC-Block-Digest\":\"sha1:VGOBKURKH6KNDEKY6RIR3JH2GLTCFEAE\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2022/CC-MAIN-2022-40/CC-MAIN-2022-40_segments_1664030337731.82_warc_CC-MAIN-20221006061224-20221006091224-00117.warc.gz\"}"}