 # Computing Exact Solutions of Consensus Halving and the Borsuk-Ulam Theorem

We study the problem of finding an exact solution to the consensus halving problem. While recent work has shown that the approximate version of this problem is PPA-complete, we show that the exact version is much harder. Specifically, finding a solution with n cuts is FIXP-hard, and deciding whether there exists a solution with fewer than n cuts is ETR-complete. We also give a QPTAS for the case where each agent's valuation is a polynomial. Along the way, we define a new complexity class BU, which captures all problems that can be reduced to solving an instance of the Borsuk-Ulam problem exactly. We show that FIXP ⊆ BU ⊆ TFETR and that LinearBU = PPA, where LinearBU is the subclass of BU in which the Borsuk-Ulam instance is specified by a linear arithmetic circuit.

## Authors

##### 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

Dividing resources among agents in a fair manner is among the most fundamental problems in multi-agent systems . 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 fair-division problem called consensus-halving: 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 Borsuk-Ulam theorem from algebraic topology . The necklace splitting and ham-sandwich problems are two other examples of fair-division problems for which the existence of a solution can be proved via the Borsuk-Ulam 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 , even for that is inverse-polynomial in  . The problem of deciding whether there exists an approximate solution with -cuts when is -complete . 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 , but finding an exact Brouwer fixed point is complete for (and the defining problem of) a complexity class called  .

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 square-root-sum 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 , 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 Borsuk-Ulam 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  , 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 .

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  , 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 Borsuk-Ulam 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 piecewise-linear-consensus halving is -hard, which completes the containment [28, 27].

Finally, we show that, for the case where each agent has a (non-piecewise) 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  who showed -completeness of the Sperner problem for a non-orientable 3-dimensional space. In  this result was strengthened for a non-orientable and locally 2-dimensional space. In , 2-dimensional Tucker was shown to be -complete; this result was used in [28, 27] to prove -completeness for approximate consensus halving. In  -completeness was proven for a special version of Tucker and for problems of the form “given a discrete fixed point in a non-orientable space, find another one”. Finally, in  it was shown that octahedral Tucker is -complete. In , a subclass of that consists of 2-dimensional fixed-point problems was studied, and it was proven that .

A large number of problems are now known to be -complete: geometric intersection problems [34, 40], graph-drawing problems  [1, 9, 18, 41], matrix factorization problems [43, 44], the Art Gallery problem , 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.

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  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

cut-points , and a vector of signs . The cut-points split into up to pieces. Note that they may in fact split into fewer than pieces in the case where two cut-points 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  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 .

## 3 The Class BU

The Borsuk-Ulam 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 (Borsuk-Ulam)

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 antipode-preserving homeomorphism of , where by “antipode-preserving” 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 Borsuk-Ulam problem as follows. [title= Borsuk-Ulam ] 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 (BU)

The complexity class consists of all search problems that can be reduced to Borsuk-Ulam in polynomial time.

### 3.1 LinearBU

When the input to a Borsuk-Ulam instance is a linear arithmetic circuit, then we call the problem Linear Borsuk-Ulam, and we define the class as follows.

###### Definition 2 (LinearBU)

The complexity class consists of all search problems that can be reduced to Linear Borsuk-Ulam in polynomial time.

We will show that . The proof that is similar to the proof that Etessami and Yannakakis used to show that  , while the fact that will follow from our results on consensus halving in Section 4.

To prove we will reduce to the approximate Borsuk-Ulam problem. It is well known that the Borsuk-Ulam theorem can be proved via Tucker’s lemma, and Papadimitriou noted that this implies that finding an approximate solution to a Borsuk-Ulam problem lies in  . This is indeed correct, but the proof provided in  is for a slightly different problem111The problem used in 

presents the function as a polynomial-time 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 self-contained proof here. We define the approximate Borsuk-Ulam problem as follows.

[title= ] Input: A continuous function presented as an arithmetic circuit, along with two constants .

Task: Find one of the following.

1. A point such that and .

2. Two points such that .

The first type of solution is an approximate solution to the Borsuk-Ulam 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 doubly-exponentially large numbers, and the reduction to Tucker may not be able to find an approximate solution for such circuits. We now re-prove the result of Papadimitriou in the following lemma.

###### Lemma 1 ()

is in .

To show that we will provide a polynomial time reduction from Linear Borsuk-Ulam to . To do this, we follow closely the technique used by Etessami and Yannakakis to show that  . 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 Borsuk-Ulam is in

The proofs of these two lemmata can be found in Appendix 0.A and 0.B respectively.

## 4 Containment Results for Consensus Halving

### 4.1 (n,n)-Consensus Halving is in BU and LinearBU = PPA

We show that -Consensus Halving is contained in . Simmons and Su  show the existence of an -cut solution to the consensus halving problem by applying the Borsuk-Ulam 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 Borsuk-Ulam 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, Filos-Ratsikas and Goldberg have shown that approximate--Consensus Halving is PPA-complete, and their valuation functions are piecewise constant. Therefore, the integrals of these functions are piecewise linear, and so their approximate--Consensus Halving instances can be reduced to -Linear Consensus Halving. Hence -Linear Consensus Halving is -hard, which along with Lemma 2 implies the following corollary.

.

### 4.2 (n,k)-Consensus Halving is in ETR

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 Borsuk-Ulam 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.

.

## 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 , 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  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 well-defined when as it is in our case. Many of the gate gadgets used in  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  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 .

We note that , , and can be implemented in terms of our new gates according to the following identities.

 max{a,b} =a+b2+|a−b|2=a2+b2+12max{a−b,0}+12max{a−b,0}, min{a,b} =a+b2−|a−b|2=a2+b2−12max{a−b,0}−12max{a−b,0}, a⋅b =2[(a2+b2)2−((a2)2+(b2)2)].

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 . The construction is quite involved, and so we focus on the high-level 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 high-level 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 non-constant, which is needed to implement the non-linear 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. Figure 2: An example where the computation at the output vout:=vi of a G[0,1]− gate with inputs vin1:=vj and vin2:=vk is simulated by the Consensus Halving instance. Here x[vj]=1/4 and x[vk]=3/4, hence x[vi]=0. The information about the values of the inputs is encoded by the cuts (red lines) in intervals v+j, and v−k imposed by agents exj and cenk respectively. The blue and green shapes depict the area below the valuation function of each of the 4 agents. The pink regions have label “+” while the yellow have label “−”. Agent adi performs the subtraction, by demanding that she is satisfied, and places a cut 1/10 to the left of the left endpoint of interval vai. Then agent midi gets satisfied by placing a cut at exactly the left endpoint of interval vmi, thus encoding the value 0 which is the correct output value of the gate. Finally, agents ceni,exi copy this value by enforcing similar cuts at the left endpoints of intervals v−i and v+i respectively. The encoded values in the latter two intervals are the “negative” and “positive” version of x[vi].

Ultimately, this allows us to construct a consensus-halving 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 consensus-halving instance that implements this circuit.

### 5.2 (n,n)-Consensus Halving is FIXP-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 . As shown in , 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 , 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 , 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.

.

### 5.3 (n,n−1)-Consensus Halving is ETR-complete

We will show the -hardness of -Consensus Halving by reducing from the following problem Feasible, which is known to be -complete .

###### Definition 3 (Feasible, \textscFeasible[0,1])

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 quasi-polynomial 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 (non-piecewise) 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

•  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 LIPIcs-Leibniz International Proceedings in Informatics, volume 51. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2016.
•  M. Abrahamsen, A. Adamaszek, and T. Miltzow. The art gallery problem is ETR-complete. In

Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing

, pages 65–73. ACM, 2018.
•  J. Aisenberg, M. L. Bonet, and S. Buss. 2-d Tucker is PPA complete. Electronic Colloquium on Computational Complexity (ECCC), 22:163, 2015.
•  N. Alon. Splitting necklaces. Advances in Mathematics, 63(3):247–253, 1987.
•  N. Alon and D. B. West. The Borsuk-Ulam theorem and bisection of necklaces. Proceedings of the American Mathematical Society, 98(4):623–628, 1986.
•  G. Amanatidis, G. Christodoulou, J. Fearnley, E. Markakis, C.-A. Psomas, and E. Vakaliou. An improved envy-free cake cutting protocol for four agents. In

International Symposium on Algorithmic Game Theory

, pages 87–99. Springer, 2018.
•  H. Aziz and S. Mackenzie. A discrete and bounded envy-free 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.
•  H. Aziz and S. Mackenzie. A discrete and bounded envy-free cake cutting protocol for four agents. In Proceedings of the forty-eighth annual ACM symposium on Theory of Computing, pages 454–464. ACM, 2016.
•  D. Bienstock. Some provably hard crossing number problems. Discrete & Computational Geometry, 6(3):443–459, 1991.
•  V. Bilò and M. Mavronicolas. The complexity of decision problems about Nash equilibria in win-lose games. In Proc. of SAGT, pages 37–48, 2012.
•  V. Bilò and M. Mavronicolas. Complexity of rational and irrational Nash equilibria. Theory of Computing Systems, 54(3):491–527, 2014.
•  V. Bilò and M. Mavronicolas. A catalog of EXISTS-R-complete decision problems about Nash equilibria in multi-player games. In LIPIcs-Leibniz International Proceedings in Informatics, volume 47, 2016.
•  V. Bilò and M. Mavronicolas. Existential-R-complete decision problems about symmetric Nash equilibria in symmetric multi-player games. In LIPIcs-Leibniz International Proceedings in Informatics, volume 66, 2017.
•  S. J. Brams and D. M. Kilgour. Competitive fair division. Journal of Political Economy, 109(2):418–443, 2001.
•  S. J. Brams and A. D. Taylor. An envy-free cake division protocol. The American Mathematical Monthly, 102(1):9–18, 1995.
•  S. J. Brams and A. D. Taylor. Fair Division: From cake-cutting to dispute resolution. Cambridge University Press, 1996.
•  J. Canny. Some algebraic and geometric computations in PSPACE. In Proc. of STOC, pages 460–467, New York, NY, USA, 1988. ACM.
•  J. Cardinal and U. Hoffmann. Recognition and complexity of point visibility graphs. Discrete & Computational Geometry, 57(1):164–178, 2017.
•  X. Chen, X. Deng, and S.-H. Teng. Settling the complexity of computing two-player Nash equilibria. Journal of the ACM (JACM), 56(3):14, 2009.
•  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.
•  A. Deligkas, J. Fearnley, T. Melissourgos, and P. G. Spirakis. Approximating the existential theory of the reals. CoRR, abs/1810.01393, 2018.
•  X. Deng, J. R. Edmonds, Z. Feng, Z. Liu, Q. Qi, and Z. Xu. Understanding PPA-completeness. In Proceedings of the 31st Conference on Computational Complexity, page 23. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik, 2016.
•  X. Deng, Z. Feng, and R. Kulkarni. Octahedral Tucker is PPA-complete. In Electronic Colloquium on Computational Complexity Report TR17-118, 2017.
•  F. Edward Su. Rental harmony: Sperner’s lemma in fair division. The American mathematical monthly, 106(10):930–942, 1999.
•  K. Etessami and M. Yannakakis. On the complexity of Nash equilibria and other fixed points. SIAM Journal on Computing, 39(6):2531–2597, 2010.
•  A. Filos-Ratsikas, S. K. S. Frederiksen, P. W. Goldberg, and J. Zhang. Hardness results for consensus-halving. In 43rd International Symposium on Mathematical Foundations of Computer Science, MFCS 2018, August 27-31, 2018, Liverpool, UK, pages 24:1–24:16, 2018.
•  A. Filos-Ratsikas and P. W. Goldberg. The complexity of splitting necklaces and bisecting ham sandwiches. arXiv preprint arXiv:1805.12559, 2018.
•  A. Filos-Ratsikas and P. W. Goldberg. Consensus halving is PPA-complete. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2018, Los Angeles, CA, USA, June 25-29, 2018, pages 51–64, 2018.
•  K. Friedl, G. Ivanyos, M. Santha, and Y. F. Verhoeven. Locally 2-dimensional Sperner problems complete for the polynomial parity argument classes. In Italian Conference on Algorithms and Complexity, pages 380–391. Springer, 2006.
•  J. Garg, R. Mehta, V. V. Vazirani, and S. Yazdanbod. ETR-completeness for decision versions of multi-player (symmetric) Nash equilibria. ACM Transactions on Economics and Computation (TEAC), 6(1):1, 2018.
•  M. Grigni. A Sperner lemma complete for PPA. Information Processing Letters, 77(5-6):255–259, 2001.
•  C.-J. Haake, M. G. Raith, and F. E. Su. Bidding for envy-freeness: A procedural approach to n-player fair-division problems. Social Choice and Welfare, 19(4):723–749, 2002.
•  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.
•  J. Matousek. Intersection graphs of segments and EXISTS-R. arXiv preprint arXiv:1406.2636, 2014.
•  J. Matoušek. Intersection graphs of segments and . CoRR, abs/1406.2636, 2014.
•  R. Mehta. Constant rank bimatrix games are PPAD-hard. In Symposium on Theory of Computing, STOC 2014, New York, NY, USA, May 31 - June 03, 2014, pages 545–554, 2014.
•  S. Ovchinnikov. Max-min representation of piecewise linear functions. Beiträge zur Algebra und Geometrie, 43(1):297–302, 2002.
•  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.
•  A. Rubinstein. Inapproximability of Nash equilibrium. SIAM Journal on Computing, 47(3):917–959, 2018.
•  M. Schaefer. Complexity of some geometric and topological problems. In International Symposium on Graph Drawing, pages 334–344. Springer, 2009.
•  M. Schaefer. Realizability of graphs and linkages. In Thirty Essays on Geometric Graph Theory, pages 461–482. Springer, 2013.
•  M. Schaefer and D. Stefankovic. Fixed points, Nash equilibria, and the existential theory of the reals. Theory Comput. Syst., 60(2):172–193, 2017.
•  Y. Shitov. A universality theorem for nonnegative matrix factorizations. arXiv preprint arXiv:1606.09068, 2016.
•  Y. Shitov. The complexity of positive semidefinite matrix factorization. SIAM Journal on Optimization, 27(3):1898–1909, 2017.
•  F. W. Simmons and F. E. Su. Consensus-halving via theorems of Borsuk-Ulam 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  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

 ∥g(u)−g(v)∥∞ ≤λ⋅∥u−v∥∞ ≤λ⋅ϵλ ≤ϵ

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 bit-length 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 Borsuk-Ulam 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 

. They use the fact that the function computed by a linear arithmetic circuit is piecewise-linear, 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 bit-size 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 Borsuk-Ulam. To do this, we can modify the linear program used by Etessami and Yannakakis . 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:

 Ax ≤b (Cx)i+C′i ≤z for i=1,…,n −((Cx)i+C′i) ≤z for i=1,…,n xi ≥0 for each i with pi≥0 xi <0 for each i with pi<0 n∑i=1|xi| =1 (see below regarding |xi|)

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 Borsuk-Ulam 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 Borsuk-Ulam for . ∎

## Appendix 0.C Proof of Theorem 4.1

###### Proof

Let us first summarise the approach used by Simmons and Su . Given valuation functions for the agents, they construct a Borsuk-Ulam 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:

 |x|:=max(x,0)+max(−x,0).

Hence, we can implement using only max, plus, and constant gates. Then, we define , and for each in the range , define:

 tj:=tj−1+|xk|.

The value of gives the start of the th piece. Next, for each in the range we define:

 pj:=max(xj,0).

Note that is whenever is positive, and zero otherwise. Finally, define:

 qj:=Fi(tj+pj)−Fi(tj).

Using the reasoning above, we can see that is agent ’s valuation for piece whenever is positive, and zero otherwise. So we can define

 b(x)i=n∑j=1qj,

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

 ((x[vout]=x[vin1])∧(x[vin1]≥x[vin2]))∨((x[vout]=x[vin2])∧(x[vin2]≥x[vin1])),

and likewise for a gate we use the formula

 ((x[vout]=x[vin1])∧(x[vin1]≤x[vin2]))∨((x[vout]=x[vin2])∧(x[vin2]≤x[vin1])).

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.

 ∃x⋅(n⋀