1 Introduction
Dividing resources among agents in a fair manner is among the most fundamental problems in multiagent systems [16]. Cake cutting [6, 8, 7, 15], and rent division [14, 32, 24] are prominent examples of problems that lie in this category. At their core, each of these problems has a desired solution whose existence is usually proved via a theorem from algebraic topology such as Brouwer’s fixed point theorem, Sperner’s lemma, or Kakutani’s fixed point theorem.
In this paper, we focus on a fairdivision problem called consensushalving: an object represented by is to be divided into two halves and , so that agents agree that and have the same value. Provided the agents have bounded and continuous valuations over , this can always be achieved using at most cuts, and this fact can be proved via the BorsukUlam theorem from algebraic topology [45]. The necklace splitting and hamsandwich problems are two other examples of fairdivision problems for which the existence of a solution can be proved via the BorsukUlam theorem [4, 5, 38].
Recent work has further refined the complexity status of approximate consensus halving, in which we seek a division of the object so that every agent agrees that the values of and differ by at most . Since the problem always has a solution, it lies in , which is the class of function problems in that always have a solution. More recent work has shown that the problem is complete [28], even for that is inversepolynomial in [27]. The problem of deciding whether there exists an approximate solution with cuts when is complete [26]. These results are particularly notable, because they identify consensus halving as one of the first natural complete problems.
While previous work has focused on approximate solutions to the problem, in this paper we study the complexity of solving the problem exactly. For problems in the complexity class , which is a subclass of both and , prior work has found that there is a sharp contrast between exact and approximate solutions. For example, the Brouwer fixed point theorem is the theorem from algebraic topology that underpins . Finding an approximate Brouwer fixed point is complete [38], but finding an exact Brouwer fixed point is complete for (and the defining problem of) a complexity class called [25].
It is believed that is significantly harder than . While , there is significant doubt about whether . The reason for this is that there are Brouwer instances for which all solutions are irrational. This is not particularly relevant when we seek an approximate solution, but is a major difficulty when we seek an exact solution. For example, the squarerootsum problem asks us to decide for integers , , …, , , whether . This deceptively simple problem is not known to lie in , and can be reduced to the problem of finding an exact Brouwer fixed point [25], which provides evidence that may be significantly harder than .
Our contribution
In this paper, we study the complexity of solving the consensus halving problem exactly. In our formulation of the problem, the valuation function of the agents is presented as an arbitrary arithmetic circuit, and the task is to cut such that all agents agree that and have exactly the same valuation. We study two problems. The Consensus Halving problem asks us to find an exact solution for agents using at most cuts, while the Consensus Halving problem asks us to decide whether there exists an exact solution for agents using at most cuts, where .
Our results for Consensus Halving are intertwined with a new complexity class that we call . This class consists of all problems that can be reduced in polynomial time to the problem of finding a solution of the BorsukUlam problem. We show that Consensus Halving lies in , and is hard. The hardness for implies that the exact variant of consensus halving is significantly harder than the approximate variant: while the approximate problem is complete, the exact variant is unlikely to be in .
We show that Consensus Halving is complete. The complexity class consists of all decision problems that can be formulated in the existential theory of the reals. It is known that [17], and it is generally believed that is distinct from the other two classes. So our result again shows that the exact version of the problem seems to be much harder than the approximate version, which is complete [26].
Just as can be thought of as the exact analogue of , we believe that is the exact analogue of , and we provide some evidence to justify this. It has been shown that [25], which is the version of the class in which arithmetic circuits are restricted to produce piecewise linear functions ( allows circuits to compute piecewise polynomials). We likewise define , which consists of all problems that can be reduced to a solution of a BorsukUlam problem using a piecewise linear function, and we show that = .
The containment can be proved using similar techniques to the proof that . However, the proof that utilises our containment result for consensus halving. In particular, when the input to the consensus halving problem is a piecewise linear function, our containment result shows that the problem actually lies in . The hardness results for consensus halving show that piecewiselinearconsensus halving is hard, which completes the containment [28, 27].
Finally, we show that, for the case where each agent has a (nonpiecewise) polynomial valuation, an approximate solution to the problem can be found using cuts, which then yields a QPTAS for the problem.
Related work
Although for a long period there were a few results about , recently there has been a flourish of completeness results. The first completeness result was given by [31] who showed completeness of the Sperner problem for a nonorientable 3dimensional space. In [29] this result was strengthened for a nonorientable and locally 2dimensional space. In [3], 2dimensional Tucker was shown to be complete; this result was used in [28, 27] to prove completeness for approximate consensus halving. In [22] completeness was proven for a special version of Tucker and for problems of the form “given a discrete fixed point in a nonorientable space, find another one”. Finally, in [23] it was shown that octahedral Tucker is complete. In [36], a subclass of that consists of 2dimensional fixedpoint problems was studied, and it was proven that .
A large number of problems are now known to be complete: geometric intersection problems [34, 40], graphdrawing problems [1, 9, 18, 41], matrix factorization problems [43, 44], the Art Gallery problem [2], and deciding the existence of constrained (symmetric) Nash equilibria in (symmetric) normal form games with at least three players [10, 11, 12, 13, 30].
2 Preliminaries
2.1 Arithmetic circuits
An arithmetic circuit is a representation of a continuous function . The circuit is defined by a pair , where is a set of nodes and is a set of gates. There are nodes in that are designated to be input nodes, and nodes in that are designated to be output nodes. When a value is presented at the input nodes, the circuit computes values for all other nodes , which we will denote as . The values of for the output nodes determine the value of .
Every node in , other than the input nodes, is required to be the output of exactly one gate in . Each gate enforces an arithmetic constraint on its output node, based on the values of some other node in the circuit. Cycles are not allowed in these constraints. We allow the operations , which correspond to the gates shown in Table 1. Note that every gate computes a continuous function over its inputs, and thus any function that is represented by an arithmetic circuit of this form is also continuous.
Gate  Constraint 

, where  
, where  
We study two types of circuits in this paper. General arithmetic circuits are allowed to use any of the gates that we have defined above. Linear arithmetic circuits allow only the operations , and the operation (multiplication of two variables) is disallowed. Observe that a linear arithmetic circuit computes a piecewise linear function.
2.2 The Consensus Halving problem
In the consensus halving problem there is an object that is represented by the line segment, and there are agents. We wish to divide into two (not necessarily contiguous) pieces such that every agent agrees that the two pieces have equal value. Simmons and Su [45] have shown that, provided the agents have bounded and continuous valuations over , then we can find a solution to this problem using at most cuts.
In this paper we consider instances of the consensus halving problem where the valuations of the agents are presented as arithmetic circuits. Each agent has a valuation function , but it is technically more convenient if they give us a representation of the integral of this function. So for each agent , we are given an arithmetic circuit computing where for all we have . Then, the value of any particular segment of to agent can be computed as .
A solution to the consensus halving problem is given by a cut of the object
, which is defined by a vector of
cutpoints , and a vector of signs . The cutpoints split into up to pieces. Note that they may in fact split into fewer than pieces in the case where two cutpoints overlap. We define to be the th piece of , meaning that , for all in the range , and .The sign vector determines which half of the piece belongs to. We define and to be the two halves. For each agent , we denote the value to agent as , and we define analogously. The cut is a solution to the consensus halving problem if for all agents .
We define two computational problems. Simmons and Su [45] have proved that there always exists a solution using at most cuts, and our first problem is to find that solution.
[title = Consensus Halving]
Input: For every agent , an arithmetic circuit computing
the integral of agent ’s valuation function.
Task: Find an cut for such that , for every agent .
For a solution to the problem may or may not exist. So we define the
following decision variant of the problem.
[title = Consensus Halving]
Input: For every agent , an arithmetic circuit computing
the integral of agent ’s valuation function.
Task: Decide whether there exists a cut for such that , for every agent .
For either of these two problems, if all of the inputs are represented by linear arithmetic circuits, then we refer to the problem as Linear Consensus Halving. We note that the known hardness results [26, 28] for consensus halving fall into this class. Specifically, those results produce valuations that are piecewise constant, and so the integral of these functions is piecewise linear, and these functions can be written down as linear arithmetic circuits [37].
3 The Class
The BorsukUlam theorem states that every continuous function from the surface of an dimensional sphere to the dimensional Euclidean space maps at least one pair of antipodal points to the same point.
Theorem 3.1 (BorsukUlam)
Let be a continuous function, where is a dimensional sphere. Then, there exists an such that .
This theorem actually works for any domain that is antipodepreserving homeomorphism of , where by “antipodepreserving” we mean that for every we have that . In this paper, we choose to be the sphere in dimensions with respect to norm: .
We define the BorsukUlam problem as follows.
[title= BorsukUlam ]
Input: A continuous function presented as
an arithmetic circuit.
Task: Find an such that
and .
Note that we cannot constrain an arithmetic circuit to only take inputs from the
domain , so we instead put the constraint that onto the
solution.
The complexity class is defined as follows.
Definition 1 ()
The complexity class consists of all search problems that can be reduced to BorsukUlam in polynomial time.
3.1
When the input to a BorsukUlam instance is a linear arithmetic circuit, then we call the problem Linear BorsukUlam, and we define the class as follows.
Definition 2 ()
The complexity class consists of all search problems that can be reduced to Linear BorsukUlam in polynomial time.
We will show that . The proof that is similar to the proof that Etessami and Yannakakis used to show that [25], while the fact that will follow from our results on consensus halving in Section 4.
To prove we will reduce to the approximate BorsukUlam problem. It is well known that the BorsukUlam theorem can be proved via Tucker’s lemma, and Papadimitriou noted that this implies that finding an approximate solution to a BorsukUlam problem lies in [38]. This is indeed correct, but the proof provided in [38] is for a slightly different problem^{1}^{1}1The problem used in [38]
presents the function as a polynomialtime Turing machine rather than an arithmetic circuit, and the Lipschitzness of the function is guaranteed by constraining the values that it can take.
. Since our results will depend on this fact, we provide our own definition and selfcontained proof here. We define the approximate BorsukUlam problem as follows.[title= ] Input: A continuous function presented as an arithmetic circuit, along with two constants .
Task: Find one of the following.

A point such that and .

Two points such that .
The first type of solution is an approximate solution to the BorsukUlam problem, while the second type of solution consists of any two points that witness that the function is not Lipschitz continuous in the norm. The second type of solution is necessary, because an arithmetic circuit is capable, through repeated squaring, of computing doublyexponentially large numbers, and the reduction to Tucker may not be able to find an approximate solution for such circuits. We now reprove the result of Papadimitriou in the following lemma.
Lemma 1 ([38])
is in .
To show that we will provide a polynomial time reduction from Linear BorsukUlam to . To do this, we follow closely the technique used by Etessami and Yannakakis to show that [25]. The idea is to make a single call to to find an approximate solution to the problem for a suitably small
, and to then round to an exact solution by solving a linear program. To build the LP, we depend on the fact that we have access to the linear arithmetic circuit that represents
.Lemma 2
Linear BorsukUlam is in
4 Containment Results for Consensus Halving
4.1 Consensus Halving is in and =
We show that Consensus Halving is contained in . Simmons and Su [45] show the existence of an cut solution to the consensus halving problem by applying the BorsukUlam theorem, and we follow their approach in this reduction. However, we must show that the approach can be implemented using arithmetic circuits. We take care in the reduction to avoid gates, and so if the inputs to the problem are all linear arithmetic circuits, then our reduction will produce a Linear BorsukUlam instance. Hence, we also show that Linear Consensus Halving is in . The proof can be found in Appendix 0.C.
Theorem 4.1
The following two containments hold.

Consensus Halving is in .

Linear Consensus Halving is in .
We note that this also implies that , thereby completing the proof that . Specifically, FilosRatsikas and Goldberg have shown that approximateConsensus Halving is PPAcomplete, and their valuation functions are piecewise constant. Therefore, the integrals of these functions are piecewise linear, and so their approximateConsensus Halving instances can be reduced to Linear Consensus Halving. Hence Linear Consensus Halving is hard, which along with Lemma 2 implies the following corollary.
Corollary 1
.
4.2 Consensus Halving is in
The existential theory of the reals consists of all true existentially quantified formulae using the connectives over polynomials compared with the operators . The complexity class captures all problems that can be reduced in polynomial time to the existential theory of the reals.
We prove that Consensus Halving is in . The reduction simply encodes the arithmetic circuits using ETR formulas, and then constrains for every agent . The proof can be found in Appendix 0.D.
Theorem 4.2
Consensus Halving is in .
Using the same technique, we can also reduce BorsukUlam to an formula. In this case, we get an ETR formula that always has a solution, and so this result places the problem in , which is the subclass of in which the formula is guaranteed to be true.
Theorem 4.3
.
5 Hardness Results for Consensus Halving
In this section we prove that Consensus Halving is hard and that Consensus Halving is hard. These two reductions share a common step of embedding an arithmetic circuit into a consensus halving instance. So we first describe this step, and then move on to proving the two individual hardness results.
5.1 Embedding a circuit in a Consensus Halving instance
Our approach is inspired by [26], who provided a reduction from GCircuit [19, 39] to approximate consensus halving. However, our construction deviates significantly from theirs due to several reasons.
Firstly, the reduction in [26] works only for approximate consensus halving. Specifically, some valuations used in that construction have the form of , where is the approximation guarantee, so the construction is not welldefined when as it is in our case. Many of the gate gadgets used in [26] cannot be used due to this issue, including the gate, which is crucially used in that construction to ensure that intermediate values do not get too large. We provide our own implementations of the broken gates. Our gate gadgets only work when the inputs and outputs lie in the range , and so we must carefully construct circuits for which this is always the case. The second major difference is that the reduction in [26] does not provide any method of multiplying two variables, which is needed in our case. We construct a gadget to do this, based on a more primitive gadget for squaring a single variable.
Special circuit
Our reduction from an arithmetic circuit to consensus halving will use a very particular subset of gates. Specifically, we will not use , , or , and we will restrict so that must lie in . We do however introduce three new gates, shown in Table 2. The gate squares its input, the gate multiplies its input by two, but requires that the input be in , and the gate is a special minus gate that takes as inputs and outputs .
Special Gate  Constraint  Ranges 

We note that , , and can be implemented in terms of our new gates according to the following identities.
Also, a very important requirement of the special circuit is that both inputs of any gate are in . To make sure of that, we downscale the inputs before reaching the gate, and upscale the output, using the fact that .
The reduction to consensus halving
The reduction follows the general outline of the reduction given in [26]. The construction is quite involved, and so we focus on the highlevel picture here.
Each gate is implemented by 4 agents, namely in the consensus halving instance. The values computed by the gates are encoded by the positions of the cuts that are required in order to satisfy these agents. Agent performs the exact mathematical operation of the gate, and feeds the outcome in , who “trims” it in accordance with the gate’s actual operation. Then feeds her outcome to and , who make a copy of ’s correct value of the gate, with “negative” and “positive” labels respectively. This value with the appropriate label will be input to other gates.
The most important agents are the ones that perform the mathematical operation of each gate, i.e. agents . Figure 1 shows the part of the valuation functions of these agents that perform the operation. Each figure shows a valuation function for one of the agents, meaning that the blue regions represent portions of the object that the agent desires. The agent’s valuation function for any particular interval is the integral of this function over that interval.
To understand the highlevel picture of the construction, let us look at the construction for . The precise valuation functions of the agents in the construction (see (1) in Appendix 0.F.1) ensure that there is exactly one input cut in the region . The leftmost piece due to that cut in that region will belong to , while the rightmost will belong to . It is also ensured that there is exactly one output cut in the region , and that the first piece in that region will belong to and the second will belong to .
Suppose that gate in the circuit is of type and we want to implement it through a Consensus Halving instance. If we treat and in Figure 1 as representing , then agent will take as input a cut at point . In order to be satisfied, will impose a cut at point , such that , where: and . Simple algebraic manipulation can be used to show that is satisfied only when , as required.
We show that the same property holds for each of the gates in Figure 1. Two notable constructions are for the gates and . For the gate the valuation function of agent is nonconstant, which is needed to implement the nonlinear squaring function. For the gate , note that the output region only covers half of the possible output space. The idea is that if the result of is negative, then the output cut will lie before the output region, which will be interpreted as a zero output by agents in the construction. On the other hand, if the result is positive, the result will lie in the usual output range, and will be interpreted as a positive number. An example where and is shown in Figure 2.
Ultimately, this allows us to construct a consensushalving instance that implements this circuit. This means that for any , we can encode as a set of cuts, which then force cuts to be made at each gate gadget that encode the correct output for that gate. The full details of the construction are quite involved, and so we defer them to Appendix 0.F, where the following result is shown.
Lemma 3
Suppose that we are given an arithmetic circuit with the following properties.

The circuit uses the gates .

Every and has .

For every input , all intermediate values computed by the circuit lie in .
We can construct a consensushalving instance that implements this circuit.
5.2 Consensus Halving is hard
We show that Consensus Halving is hard by reducing from the problem of finding a Nash equilibrium in a player game, which is known to be a complete [25]. As shown in [25], this problem can be reduced to the Brouwer fixed point problem: given an arithmetic circuit computing a function , find a point such that . In a similar way to [26], we take this circuit and embed it into a consensus halving instance, with the outputs looped back to the inputs. Since Lemma 3 implies that our implementation of the circuit is correct, this means that any solution to the consensus halving problem must encode a point satisfying .
One difficulty is that we must ensure that the arithmetic circuit that we build falls into the class permitted by Lemma 3. To do this, we carefully analyse the circuits produced in [25], and we modify them so that all of the preconditions of Lemma 3 hold. This gives us the following result, which is proved in Appendix 0.G.
Theorem 5.1
Consensus Halving is hard.
This theorem, along with Theorem 4.1 give the following corollary.
Corollary 2
.
5.3 Consensus Halving is complete
We will show the hardness of Consensus Halving by reducing from the following problem Feasible, which is known to be complete [42].
Definition 3 (Feasible, )
Let be a polynomial. Feasible asks whether there exists a point that satisfies . asks whether there exists a point that satisfies .
The idea is to turn the polynomial into a circuit, and then embed that circuit into a consensus halving instance using Lemma 3. As before, the main difficulty is ensuring that the preconditions of Lemma 3 are satisfied. To do this, we must ensure that the the inputs to the circuit take values in , which is not the case if we reduce directly from Feasible. Instead, we first consider the problem , in which is constrained to lie in rather than , and we show the following result in Appendix 0.H.2.
Lemma 4
is complete.
is the subclass of in which variables are quantified over rather than . The above lemma follows from the fact that which we prove in Appendix 0.H.1, and the fact that is hard which we prove in Appendix 0.H.2. This equivalence of classes, together with the completeness of may be of independent interest.
We then proceed to reduce to Consensus Halving. We still don’t quite meet the requirements of Lemma 3, because the intermediate terms may be outside . We resolve this by implementing a circuit (called in Appendix 0.I) implementing only the positive terms of downscaled appropriately, and a circuit (called in Appendix 0.I) implementing the positive terms of again downscaled appropriately. The check agent is then satisfied if , which can only occur when .
There will be choice agents (the agents called in Appendix 0.F.1 with valuation functions shown in (1)) corresponding to the nodes of the circuit, who enforce that there is a cut for each of the nodes to the circuit, and together these cuts encode an input to the polynomial. Each agent introduced by Lemma 3 has an associated cut that is forced by the construction used in that lemma, and these cuts compute the output of the associated gate.
So far, every agent has a corresponding cut that is forced by the construction. There is, however, one final check agent (the agent called in Appendix 0.I) with valuation functions shown in (17)) who has the following properties.

If , then the check agent agrees that has been cut in half without an extra cut being made.

If , then the check agent requires one more cut to be made in order to be satisfied that has been cut in half.
Hence, if there exists a solution to Feasible, then there is a solution to , hence there is a cut that solves the Consensus Halving instance, and otherwise there is no such solution. The details of this reduction are given in Appendix 0.I, where the following result is shown.
Theorem 5.2
Consensus Halving is complete.
6 A QPTAS for Consensus Halving with polynomial valuation functions
In this section we show that an approximate solution to the consensus halving problem can be found in quasipolynomial time when each agent’s valuation function is presented as a single polynomial of constant or logarithmic degree. We will do so by formulating the problem as a formula in the approximate existential theory of the reals, and then applying the approximation theorem proved in [20, 21].
Our result implies that these instances can be solved approximately using a logarithmic number of cuts. We note that this is one of the most general classes of instances for which we could hope to prove such a result: any instance in which agents desire completely disjoint portions of the object can only be solved by an cut, and piecewise linear functions are capable of producing such a situation. So in a sense, we are exploiting the fact that this situation cannot arise when the agents have (nonpiecewise) polynomial valuations. The proof of the following lemma can be found in Appendix 0.J.
Lemma 5
For every Consensus Halving instance with agents, and every , if each agent’s valuation function is represented as a single polynomial of degree at most , then there exists an cut and pieces and such that:

every cut point is a multiple of ;

, for every agent .
As a consequence, we can perform a brute force search over all possible cuts to find an approximate solution, which can be carried out in time.
Theorem 6.1
Consensus Halving admits a QPTAS when the valuation function of every agent is a single polynomial of degree .
References
 [1] Z. Abel, E. D. Demaine, M. L. Demaine, S. Eisenstat, J. Lynch, and T. B. Schardl. Who needs crossings? Hardness of plane graph rigidity. In LIPIcsLeibniz International Proceedings in Informatics, volume 51. Schloss DagstuhlLeibnizZentrum fuer Informatik, 2016.

[2]
M. Abrahamsen, A. Adamaszek, and T. Miltzow.
The art gallery problem is ETRcomplete.
In
Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing
, pages 65–73. ACM, 2018.  [3] J. Aisenberg, M. L. Bonet, and S. Buss. 2d Tucker is PPA complete. Electronic Colloquium on Computational Complexity (ECCC), 22:163, 2015.
 [4] N. Alon. Splitting necklaces. Advances in Mathematics, 63(3):247–253, 1987.
 [5] N. Alon and D. B. West. The BorsukUlam theorem and bisection of necklaces. Proceedings of the American Mathematical Society, 98(4):623–628, 1986.

[6]
G. Amanatidis, G. Christodoulou, J. Fearnley, E. Markakis, C.A. Psomas, and
E. Vakaliou.
An improved envyfree cake cutting protocol for four agents.
In
International Symposium on Algorithmic Game Theory
, pages 87–99. Springer, 2018.  [7] H. Aziz and S. Mackenzie. A discrete and bounded envyfree cake cutting protocol for any number of agents. In 2016 IEEE 57th Annual Symposium on Foundations of Computer Science (FOCS), pages 416–427. IEEE, 2016.
 [8] H. Aziz and S. Mackenzie. A discrete and bounded envyfree cake cutting protocol for four agents. In Proceedings of the fortyeighth annual ACM symposium on Theory of Computing, pages 454–464. ACM, 2016.
 [9] D. Bienstock. Some provably hard crossing number problems. Discrete & Computational Geometry, 6(3):443–459, 1991.
 [10] V. Bilò and M. Mavronicolas. The complexity of decision problems about Nash equilibria in winlose games. In Proc. of SAGT, pages 37–48, 2012.
 [11] V. Bilò and M. Mavronicolas. Complexity of rational and irrational Nash equilibria. Theory of Computing Systems, 54(3):491–527, 2014.
 [12] V. Bilò and M. Mavronicolas. A catalog of EXISTSRcomplete decision problems about Nash equilibria in multiplayer games. In LIPIcsLeibniz International Proceedings in Informatics, volume 47, 2016.
 [13] V. Bilò and M. Mavronicolas. ExistentialRcomplete decision problems about symmetric Nash equilibria in symmetric multiplayer games. In LIPIcsLeibniz International Proceedings in Informatics, volume 66, 2017.
 [14] S. J. Brams and D. M. Kilgour. Competitive fair division. Journal of Political Economy, 109(2):418–443, 2001.
 [15] S. J. Brams and A. D. Taylor. An envyfree cake division protocol. The American Mathematical Monthly, 102(1):9–18, 1995.
 [16] S. J. Brams and A. D. Taylor. Fair Division: From cakecutting to dispute resolution. Cambridge University Press, 1996.
 [17] J. Canny. Some algebraic and geometric computations in PSPACE. In Proc. of STOC, pages 460–467, New York, NY, USA, 1988. ACM.
 [18] J. Cardinal and U. Hoffmann. Recognition and complexity of point visibility graphs. Discrete & Computational Geometry, 57(1):164–178, 2017.
 [19] X. Chen, X. Deng, and S.H. Teng. Settling the complexity of computing twoplayer Nash equilibria. Journal of the ACM (JACM), 56(3):14, 2009.
 [20] A. Deligkas, J. Fearnley, T. Melissourgos, and P. G. Spirakis. Approximating the existential theory of the reals. In G. Christodoulou and T. Harks, editors, Web and Internet Economics, pages 126–139, Cham, 2018. Springer International Publishing.
 [21] A. Deligkas, J. Fearnley, T. Melissourgos, and P. G. Spirakis. Approximating the existential theory of the reals. CoRR, abs/1810.01393, 2018.
 [22] X. Deng, J. R. Edmonds, Z. Feng, Z. Liu, Q. Qi, and Z. Xu. Understanding PPAcompleteness. In Proceedings of the 31st Conference on Computational Complexity, page 23. Schloss Dagstuhl–LeibnizZentrum fuer Informatik, 2016.
 [23] X. Deng, Z. Feng, and R. Kulkarni. Octahedral Tucker is PPAcomplete. In Electronic Colloquium on Computational Complexity Report TR17118, 2017.
 [24] F. Edward Su. Rental harmony: Sperner’s lemma in fair division. The American mathematical monthly, 106(10):930–942, 1999.
 [25] K. Etessami and M. Yannakakis. On the complexity of Nash equilibria and other fixed points. SIAM Journal on Computing, 39(6):2531–2597, 2010.
 [26] A. FilosRatsikas, S. K. S. Frederiksen, P. W. Goldberg, and J. Zhang. Hardness results for consensushalving. In 43rd International Symposium on Mathematical Foundations of Computer Science, MFCS 2018, August 2731, 2018, Liverpool, UK, pages 24:1–24:16, 2018.
 [27] A. FilosRatsikas and P. W. Goldberg. The complexity of splitting necklaces and bisecting ham sandwiches. arXiv preprint arXiv:1805.12559, 2018.
 [28] A. FilosRatsikas and P. W. Goldberg. Consensus halving is PPAcomplete. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2018, Los Angeles, CA, USA, June 2529, 2018, pages 51–64, 2018.
 [29] K. Friedl, G. Ivanyos, M. Santha, and Y. F. Verhoeven. Locally 2dimensional Sperner problems complete for the polynomial parity argument classes. In Italian Conference on Algorithms and Complexity, pages 380–391. Springer, 2006.
 [30] J. Garg, R. Mehta, V. V. Vazirani, and S. Yazdanbod. ETRcompleteness for decision versions of multiplayer (symmetric) Nash equilibria. ACM Transactions on Economics and Computation (TEAC), 6(1):1, 2018.
 [31] M. Grigni. A Sperner lemma complete for PPA. Information Processing Letters, 77(56):255–259, 2001.
 [32] C.J. Haake, M. G. Raith, and F. E. Su. Bidding for envyfreeness: A procedural approach to nplayer fairdivision problems. Social Choice and Welfare, 19(4):723–749, 2002.
 [33] D. E. Knuth. The Art of Computer Programming, Volume 3: (2Nd Ed.) Sorting and Searching. Addison Wesley Longman Publishing Co., Inc., Redwood City, CA, USA, 1998.
 [34] J. Matousek. Intersection graphs of segments and EXISTSR. arXiv preprint arXiv:1406.2636, 2014.
 [35] J. Matoušek. Intersection graphs of segments and . CoRR, abs/1406.2636, 2014.
 [36] R. Mehta. Constant rank bimatrix games are PPADhard. In Symposium on Theory of Computing, STOC 2014, New York, NY, USA, May 31  June 03, 2014, pages 545–554, 2014.
 [37] S. Ovchinnikov. Maxmin representation of piecewise linear functions. Beiträge zur Algebra und Geometrie, 43(1):297–302, 2002.
 [38] C. H. Papadimitriou. On the complexity of the parity argument and other inefficient proofs of existence. Journal of Computer and System Sciences, 48(3):498–532, 1994.
 [39] A. Rubinstein. Inapproximability of Nash equilibrium. SIAM Journal on Computing, 47(3):917–959, 2018.
 [40] M. Schaefer. Complexity of some geometric and topological problems. In International Symposium on Graph Drawing, pages 334–344. Springer, 2009.
 [41] M. Schaefer. Realizability of graphs and linkages. In Thirty Essays on Geometric Graph Theory, pages 461–482. Springer, 2013.
 [42] M. Schaefer and D. Stefankovic. Fixed points, Nash equilibria, and the existential theory of the reals. Theory Comput. Syst., 60(2):172–193, 2017.
 [43] Y. Shitov. A universality theorem for nonnegative matrix factorizations. arXiv preprint arXiv:1606.09068, 2016.
 [44] Y. Shitov. The complexity of positive semidefinite matrix factorization. SIAM Journal on Optimization, 27(3):1898–1909, 2017.
 [45] F. W. Simmons and F. E. Su. Consensushalving via theorems of BorsukUlam and Tucker. Mathematical Social Sciences, 45(1):15–25, 2003.
Appendix 0.A Proof of Lemma 1
Proof
This proof is essentially identical to the one given by Papadimitriou, but various minor changes must be made due to the fact that our input is an arithmetic circuit, and our domain is the sphere. His proof works by reducing to the Tucker problem. In this problem we have a antipodally symmetric triangulation of with set of vertices , and a labelling function that satisfies for all . The task is to find two adjacent vertices and such that , whose existence is guaranteed via Tucker’s lemma. Papadimitriou’s containment proof goes via the hypercube, but in [26] it is pointed out that this problem also lies in PPA when the domain is the sphere .
To reduce the problem for to Tucker, we choose an arbitrary triangulation of such that the distance between any two adjacent vertices is at most . Let . To determine the label of a vertex , first find the coordinate that maximises breaking ties arbitrarily, and then set if and otherwise.
Tucker’s lemma will give us two adjacent vertices and satisfying , and we must translate this to a solution to . If , then we have a violation of Lipschitz continuity. Otherwise, we have
Let . Note that by definition we have that for all , that for all , and that that and have opposite signs. These three facts, along with the fact that imply that for all . Hence we can conclude that meaning that is a solution to . ∎
Appendix 0.B Proof of Lemma 2
Proof
Suppose that we have a function that is represented as a linear arithmetic circuit. We will provide a polynomial time reduction to .
The first step is to argue that, for all , we can make a single call to in order to find an approximate solution to the problem. The only technicality here is that we must choose so as to ensure that no violations of Lipschitzness in the norm can be produced as a solution.
Fortunately, every linear arithmetic circuit computes a Lipschitz function where the bitlength of is polynomial in the size of the circuit. Moreover, an upper bound on can easily be computed by inspecting the circuit.

An input to the circuit has a Lipschitz constant of 1.

A gate operating on two gates with Lipschitz constants and has a Lipschitz constant of at most .

A gate operating on a gate with Lipschitz constant has a Lipschitz constant of at most .

A max or min gate operating on two gates with Lipschitz constants and has a Lipschitz constant of at most .
The Lipschitz constant for the circuit in the norm is then the maximum of the Lipschitz constants of the output nodes of the circuit. So, for any given that can be represented in polynomially many bits, we can make a single call to , in order to find an approximate solution to the BorsukUlam problem.
The second step is to choose an appropriate value for so that the approximate solution can be rounded to an exact solution using an LP. Let . Note that can also be computed by a linear arithmetic circuit, and that if and only if .
We closely follow the approach of Etessami and Yannakakis [25]
. They use the fact that the function computed by a linear arithmetic circuit is piecewiselinear, and defined by (potentially exponentially many) hyperplanes. They give an algorithm that, given a point
in the domain of the circuit, computes in polynomial time the hyperplane that defines the output of the circuit for . Furthermore, they show that the following can be produced in polynomial time from the representation of the circuit and from .
A system of linear constraints such that a point satisfies the constraints if and only if the hyperplane that defines the output of the circuit for also defines the output of the circuit for .

A linear formula that determines the output of the circuit for all points that satisfy .
To choose , the following procedure is used. Let be the number of inputs to , and let be an upper bound on the bitsize of the solution of any linear system with equations where the coefficients are drawn from the hyperplanes that define the function computed by . This can be computed in polynomial time from the description of the circuit, and will have polynomial size in relation to the description of the circuit. We choose .
We make one call to to find a point such that , meaning that . The final step is to round this to an exact solution of BorsukUlam. To do this, we can modify the linear program used by Etessami and Yannakakis [25]. We apply the operations given above to the circuit and the point to obtain the system of constraints and the formula for the hyperplane defining the output of for . We then solve the following linear program. The variables of the LP are a vector of length , and a scalar . The goal is to minimize subject to:
for  
for  
for each with  
for each with  
(see below regarding ) 
The first constraint ensures that we remain on the same hyperplane as the one defining the output of for . The second and third constraints ensure that . The fourth and fifth constraints ensure that has the same sign as , while the sixth constraint ensures that lies on the surface . Note that the operation in the sixth constraint is not a problem, since the fourth and fifth constraints mean that we know the sign of up front, and so we just need to add either or to the sum. All of the above implies that that is a approximate solution of BorsukUlam for .
We must now argue that the solution sets . First we note that the LP has a solution, because the point is feasible, and the LP is not unbounded since cannot be less than zero due to the second and third constraints. So let be an optimal solution. This solution lies at the intersection of linear constraints defined by rationals drawn from the circuit representing , and so it follows that is a rational of bit length at most . Since , it follows that , and thus is an exact solution to BorsukUlam for . ∎
Appendix 0.C Proof of Theorem 4.1
Proof
Let us first summarise the approach used by Simmons and Su [45]. Given valuation functions for the agents, they construct a BorsukUlam instance given by a function . Each point can be interpreted as an cut of , where gives the width of the th piece, and the sign of indicates whether the th piece should belong in or . They then define for each agent . The fact that flips the sign of each piece, but not the width, implies that . Hence, any point that satisfies has the property that for all agents , and so is a solution to the consensus halving property.
Our task is to implement this reduction using arithmetic circuits. Suppose that we are given arithmetic circuits implementing the integral of each agent’s valuation function. Given a point , we show that can be computed via a linear arithmetic circuit. The tricky part of this, is that we must only include the th piece in the sum if is positive.
We begin by observing that the operation of can be implemented via a linear arithmetic circuit. Specifically, via the following construction:
Hence, we can implement using only max, plus, and constant gates. Then, we define , and for each in the range , define:
The value of gives the start of the th piece. Next, for each in the range we define:
Note that is whenever is positive, and zero otherwise. Finally, define:
Using the reasoning above, we can see that is agent ’s valuation for piece whenever is positive, and zero otherwise. So we can define
implying that , as required.
To complete the proof, it suffices to note that none of the operations specified above use the gate , and so if each is specified by a linear arithmetic circuit, then will also be a linear arithmetic circuit. ∎
Appendix 0.D Proof of Theorem 4.2
Proof
The first step is to argue that an arithmetic circuit can be implemented as an ETR formula. Let be the arithmetic circuit. For every vertex we introduce a new variable . For every gate we introduce a constraint. For the gates in the set the constraints simply implement the gate directly, eg., for a gate we use the constraint . For a gate we use the formula
and likewise for a gate we use the formula
Taking the conjunction of the constraints for each of the gates yields an ETR formula that implements the circuit.
Now we perform the reduction from consensus halving to the existential theory of the reals. Suppose that we have been given, for each agent , an arithmetic circuit implementing the integral of agent ’s valuation function. We have already shown in the proof of Theorem 4.1 that, given a description of a cut given as a point in , we can create a circuit implementing and a circuit implementing for each agent . We also argued in that proof that can be implemented as an arithmetic circuit. Our ETR formula is as follows.
Comments
There are no comments yet.