# Square-Cut Pizza Sharing is PPA-complete

We study the computational complexity of computing solutions for the square-cut pizza sharing problem. In this problem, we have n mass distributions in the plane, and the task is to find a path that uses horizontal and vertical segments that splits each of the masses in half while making at most n-1 turns. We show that finding an approximate solution to this problem is PPA-complete, while finding an exact solution is FIXP-hard and in BU. Our PPA-hardness result applies even when all mass distributions are unions of non-overlapping squares, and our FIXP-hardness result applies even when all mass distributions are unions of weighted squares and right-angled triangles. When the path is restricted to have at most n-2 turns, we show that the approximate problem becomes NP-complete, and the exact problem becomes ETR-complete.

Comments

There are no comments yet.

## Authors

• 18 publications
• 12 publications
• 7 publications
• ### The Perfect Matching Cut Problem Revisited

In a graph, a perfect matching cut is an edge cut that is a perfect matc...
07/13/2021 ∙ by Van Bang Le, et al. ∙ 0

read it

• ### The complexity of sharing a pizza

Assume you have a 2-dimensional pizza with 2n ingredients that you want ...
09/14/2021 ∙ by Patrick Schnider, et al. ∙ 0

read it

• ### Linear Discrepancy is Π_2-Hard to Approximate

In this note, we prove that the problem of computing the linear discrepa...
07/02/2021 ∙ by Pasin Manurangsi, et al. ∙ 0

read it

• ### The Computational Complexity of Finding Hamiltonian Cycles in Grid Graphs of Semiregular Tessellations

Finding Hamitonian Cycles in square grid graphs is a well studied and im...
05/08/2018 ∙ by Kaiying Hou, et al. ∙ 0

read it

• ### Tatamibari is NP-complete

In the Nikoli pencil-and-paper game Tatamibari, a puzzle consists of an ...
03/18/2020 ∙ by Aviv Adler, et al. ∙ 0

read it

• ### Geometric Interpretation of side-sharing and point-sharing solutions in the P3P Problem

It is well known that the P3P problem could have 1, 2, 3 and at most 4 p...
01/29/2019 ∙ by Bo Wang, et al. ∙ 0

read it

• ### Towards a Dichotomy for Minimally Factorizing the Provenance of Self-Join Free Conjunctive Queries

We consider the problem of finding the minimal-size factorization of the...
05/29/2021 ∙ by Neha Makhija, et al. ∙ 0

read it

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

Mass partition problems ask us to fairly divide measurable objects that are embedded into Euclidean space [RS20]. Perhaps the most well-known mass partition problem is the ham sandwich problem, in which three masses are given in three-dimensional Euclidean space, and the goal is to find a single plane that cuts all three masses in half. Recently, there has been interest in pizza sharing problems, which are mass partition problems in the two-dimensional plane. For example, it was recently shown that it is possible to simultaneously bisect four two-dimensional masses using two straight-line cuts [BPS19].

In this paper, we focus on a different but related problem that we call square-cut pizza sharing. In this problem, there are masses in the plain. The task is to simultaneously bisect all masses using cuts, but the method of generating the cuts is different. Specifically, we seek a square-cut, which consists of a single path that is the union of horizontal and vertical line segments. See Figure 1 for two examples of square-cuts. Intuitively, we can imagine that a pizza cutter is placed on the plane, and is then moved horizontally and vertically without being lifted in order to produce the cut. Note that the path is allowed to wrap around on the horizontal axis: if it exits the left or right boundary, then it re-appears on the opposite boundary. So the cut on the right in Figure 1 is still considered to be a single square-cut.

It has been shown that, given masses, there always exists a square-cut-path (termed SC-path) that makes at most turns and simultaneously bisects all of the masses [KRS16]. This holds even if the SC-path is required to be -monotone, meaning that the path never moves downwards [KRS16]. In this paper, we will study the computational complexity of finding such an SC-path.

Computational complexity of fair division problems. There has been much interest recently in the computational complexity of fair division problems. In particular, the complexity class has risen to prominence, because it appears to naturally capture the complexity of solving these problems. For example, it has recently been shown that the ham sandwich problem and the well-known necklace splitting problem are both -complete [FRG18-Necklace].

More generally, captures the problem of finding a solution to a problem whose solution is guaranteed by the Borsuk-Ulam theorem, since finding an approximate solution to a Borsuk-Ulam function, or finding an exact solution to a linear Borsuk-Ulam function are both known to be -complete problems [Papadimitriou94-TFNP-subclasses, DFMS21]. The existence of solutions to the ham sandwich problem, the necklace splitting problem, and indeed the square-cut pizza sharing problem can all be proved via the Borsuk-Ulam theorem111It has also been shown that the Borsuk-Ulam theorem is equivalent to the ham sandwich theorem which states that the volumes of any compact sets in can always be simultaneously bisected by an

-dimensional hyperplane

[KA17]..

###### Theorem 1 (Borsuk-Ulam).

Let be a continuous function, where is a -dimensional sphere. Then, there exists an such that .

The other class of relevance here is the class , which consists of all problems that can be reduced to finding an exact solution to a Borsuk-Ulam function [DFMS21]. This class is believed to be substantially harder than the class , because it is possible to construct a Borsuk-Ulam function that only has irrational solutions. Due to this, it is not currently expected that will be contained in (which is the class of function problems whose solutions can be verified in polynomial time), whereas the containment of in is immediate.

Unfortunately, it is not currently known whether has complete problems. There are, however, problems in that are known to be -hard [DFMS21]. is the class of problems that can be reduced to finding an exact fixed point of a Brouwer function [EY10-Nash-FIXP]. It is known that , and since there exist Brouwer functions that only have irrational fixed points, it is likewise not expected that will be contained in .

Our contribution. We study the computational complexity of the square-cut pizza sharing problem, and we specifically study the case where all masses are unions of weighted polygons. We study both the exact and the approximate versions of the problem. All of our results are summarized in Table 1.

For the approximate problem, our main result is to show that finding a square cut with turns that -approximately bisects mass distributions is a -complete problem. In fact, we show three different hardness results for the approximate problem.

• Our main hardness result show hardness for , and it is able to show that it is -hard even to find an SC-path with turns, where is a constant.

• By making adjustments to the result above, we are able to extend the hardness to the case where all of the polygons are axis-aligned unweighted non-overlapping squares.

• Finally, we are able to show a hardness result for constant , but in this case the hardness is -hardness, which is a slightly weaker hardness result than -hardness.

We then turn our attention to the computational complexity of finding an exact solution to the problem. Here we show that the problem of finding an SC-path with at most turns that exactly bisects masses lies in , and is -hard. This hardness result applies even if all mass distributions are unions of weighted axis-aligned squares and right-angled triangles. In order to prove this result, we provide a simpler existence proof for a solution to the square-cut pizza sharing problem that follows the lines of the original proof from [KRS16].

Finally, we study the decision version of the problem. While a solution to the problem is guaranteed to exist for cuts that make turns, this is not the case if only turns are allowed. We show that deciding whether there exists an approximate solution that makes at most turns is -complete, and deciding whether there is an exact solution that makes at most turns is -complete, where consists of every decision problem that can be formulated in the existential theory of the reals.

From a technical point of view, our containment results are shown by directly reducing the square-cut pizza sharing problem to the Borsuk-Ulam problem. Our hardness results are obtained by reducing from the consensus halving problem, which was one of the first fair-division problems to be shown to be -complete [FRG18-Consensus]. We provide a single reduction from consensus halving to square-cut pizza sharing, and then the various different hardness results for consensus halving yield the different results that we have stated above. We remark that, if in the future, consensus halving is shown to be -complete under block and triangle valuations for the agents, then our work will also imply that exact square-cut pizza sharing will also be -complete.

The technical parts of the proofs are deferred to the Appendix.

Further related work. Since mass partitions lie in the intersection of topology, discrete geometry, and computer science there are several surveys on the topic; [blagojevic2018topology, de2019discrete, Mat03BorsukUlam, ziv17] focus on the topological point of view, while [agarwal1999geometric, edelsbrunner2012algorithms, kaneko2003discrete, kano2020discrete, matousek2013lectures] focus on computational aspects. Consensus halving [SS03-Consensus] is the mass partition problem that received the majority of attention in Theoretical Computer Science so far [DFRH, filos2018hardness, FRG18-Necklace, FRHSZ2020consensus-easier, filos2020topological].

## 2 Preliminaries

Mass distributions. A mass distribution on is a measure on the plane such that all open subsets of are measurable, , and for every subset of with dimension lower than 2. A mass distribution is finite-separable, or simply separable, if it can be decomposed into a finite set of non-overlapping areas such that . In addition, a separable mass distribution is piece-wise uniform, if for every and every it holds that for some independent of . A separable mass distribution is uniform if for every it holds that . Finally, a mass distribution is normalised if . A set of mass distributions has overlap if any point of belongs to at most distributions.

Mass distributions can be categorized according to their shape as well. So, a separable mass distribution is a:

• -polygon, if it can decomposed into non-overlapping polygons ;

• --square, if it can decomposed into squares each of edge-size , when we say that it is a unit-square.

We will denote by a triangle with vertices and, when clear from context, we will also use the same notation to indicate the area of the triangle. Two intersecting line segments , define two angles, denoted and . The order of the vertices implies a direction of the segments, i.e. in the former angle we have , and in the latter we have , . We consider the direction of the segments and define the angle to be the intersection of the left halfspaces of the segments. Therefore . This order will not matter if clear from context (e.g. in triangles).

Square-cut-paths. A square-cut-path, denoted for brevity SC-path, is a non-crossing directed path that is formed only by horizontal and vertical line segments and in addition it is allowed to “wrap around” in the horizontal dimension. Figure 1 shows two examples of SC-paths. A turn of the path is where a horizontal segment meets with a vertical segment. An SC-path is -monotone if all of its horizontal segments are monotone with respect to axis. Any SC-path naturally partitions the plane into two regions, that we call and .

Pizza sharing. An SC-path -bisects a mass distribution , if and it simultaneously -bisects a set of mass distributions if for every . The -SC-Pizza-Sharing problem is to find a SC-path with turns that simultaneously -bisects a set of mass distributions.

[backgroundcolor=white!90!gray, leftmargin=nerleftmargin=4pt, innertopmargin=4pt, skipabove=5pt,skipbelow=5pt]

###### Definition 2.

For any , the problem -SC-Pizza-Sharing is defined as follows:

• Input: and mass distributions on .

• Output: A partition of to and using a -monotone SC-path with at most turns such that for each mass distribution it holds that .

In [KRS16] it was proven that -SC-Pizza-Sharing always admits a solution for every . Although it is not hard to construct instances of -SC-Pizza-Sharing where turns are necessary for any SC-path in order to define a solution, there might be cases where a solution can be achieved with an SC-path with fewer turns. Hence, study the decision version of the problem, denoted -SC-Pizza-Sharing(D), where we ask whether we can find a solution with turns, where .

Complexity classes. -SC-Pizza-Sharing is an example of a total problem, which is a problem that always has a solution. The complexity class (Total Function [Megiddo1991] contains all total problems whose solutions can be verified in polynomial time.

There are several well-known subclasses of that we will use in this paper. The class , defined in [Papadimitriou94-TFNP-subclasses], captures problems whose totality is guaranteed by the parity argument on undirected graphs. The complexity class is the subclass of containing all problems whose totality is guaranteed by the parity argument on directed graphs. We will show hardness and completeness results for these classes by reducing from the consensus halving problem, which is discussed below.

The complexity class consists of all decision problems that can be formulated in the existential theory of the reals [Matousek14, scha09]. It is known that  [C88], and it is generally believed that is distinct from the other two classes. The class (Function ) consists of all search problems whose decision version is in .

We also use two complexity classes that can be the thought of as capturing total search problems within , or to be more specific, (Total Function ).222Both and were introduced in [DFMS21] as the natural analogues of and . The class was introduced in [DFMS21] and captures problems whose totality is guaranteed by the Borsuk-Ulam theorem. The class was defined in [EY10] and captures problems whose totality is guaranteed by Brouwer’s fixed point theorem.

Consensus Halving. The hardness results that we will show in this paper will be shown by a reduction from the consensus halving problem.

In the -Consensus-Halving problem, there is a set of agents with valuation functions over the interval , and the goal is to find a partition of the interval into subintervals labelled either “” or “”, using at most cuts. This partition should satisfy that for every agent , the total value for the union of subintervals labelled “” and the total value for the union of subintervals labelled “” is the same up to , i.e., . We will consider the following types for a valuation function ; see Figure 2 for a visualization.

• -block. can be decomposed into at most non-overlapping (but possibly adjacent) intervals where interval has density and 0 otherwise. So, for every and .

• 2-block uniform. is two-block and the density of every interval is .

• -block-triangle. is the union of a -block valuation function and an extra interval , where for every and for every .

## 3 Containment results for Sc-Pizza-Sharing

In this section we present containment results for the exact and approximate versions of SC-Pizza-Sharing that we study in this paper. All of our containment results revolve around a proof that solutions exist for SC-Pizza-Sharing that utilizes the Borsuk-Ulam theorem. A proof of this kind was already presented in [KRS16], but we will present our own proof which is conceptually simpler, as it does not use any involved topological techniques. An advantage of our proof is that it can be made algorithmic, and so it can be used to show that SC-Pizza-Sharing is contained in . Then, by making simple modifications to the containment proof, we show the other containment results hold.

### 3.1 Containment results for exact Sc-Pizza-Sharing

Existence of a SC-Pizza-Sharing solution. We begin by proving that a solution to exact SC-Pizza-Sharing always exists. This proof holds for arbitrary mass distributions, but for our algorithmic results we will only consider the case where the mass distributions are unions of polygons with holes. Our proof is based on the proof of Karasev, Roldán-Pensado and Soberón given in [KRS16], but they use more involved techniques from topology, which we would like to avoid, since our goal is to implement the result algorithmically.

Let denote the sphere in -dimensions. The Borsuk-Ulam theorem states that if is a continuous function, then there exists a point such that . We will show how to encode SC-paths as a points in , and then we will build a function that ensures that only when the SC-path corresponding to is a solution to the SC-Pizza-Sharing problem.

Figure 3 gives an overview for our SC-path embedding. The embedding considers only -monotone SC-paths. The path itself is determined by the points , , …, and , , …, which define the points at which the path turns. The path begins on the boundary on the line , and then moves to , at which points it turns and moves upwards to , and it then turns to move to , and so on.

But these points alone do not fully specify the path, since the decision of whether to move to the right or to the left when moving from to has not been specified. To do this, we also include signs that are affixed to each horizontal strip. We will call the two sides of the cut side A (non-shaded) and side B (shaded). The -st strip is split into two by the vertical line segment on that starts from point and ends at , with one part being on side A, and the other being on side B. If the strip is assigned the sign then the area on the left of the strip is on side A of the cut, while if the strip is assigned the sign then the areas on the right of the strip is on side A of the cut. Once the sides of the cut have been decided, there is then a unique way to move through the points in order to separate sides A and B.

So, an SC-path with turns, can be represented by variables and signs. We then embed these into the sphere in the following way. We give an informal description here, and the full definition will be given in the proof of Theorem 3. We encode the values as variables where , while the values are encoded as values in , where defines the th value on the axis. We use the signs of the variables to define the signs for the strips. Finally, we then shrink all variables so that their sum lies in , and we embed them as a point in using one extra dimension as a slack variable in case the sum of the absolute values of the variables does not equal 1.

The key property is that, if a point represents an SC-path, then the point represents exactly the same SC-path but with all signs flipped, and thus sides A and B will be exchanged. Therefore, we can write down a function , where outputs the amount of mass of the -th mass distribution that lies on the A side of the cut, and therefore any point satisfying must cut all mass distributions exactly in half.

So, we get the following theorem that is proved formally in Appendix B.

###### Theorem 3 (originally by [Krs16]).

Let be a positive integer. For any mass distributions in , there is a path formed by only horizontal and vertical segments with at most turns that splits into two sets of equal size in each measure. Moreover, the path is -monotone.

-containment. The next step is to turn this existence result into a proof that SC-Pizza-Sharing is contained in . We begin by recapping the definition of given in [DFMS21]. An arithmetic circuit is a circuit that operates on real numbers, and uses gates from the set , where a -gate outputs the constant , a gate multiplies the input by a constant , and all other gates behave according to their standard definitions. The class contains every problem that can be reduced to Borsuk-Ulam. [backgroundcolor=white!90!gray, leftmargin=nerleftmargin=4pt, innertopmargin=4pt, skipabove=5pt,skipbelow=5pt]

###### Definition 4 (Borsuk-Ulam).
• Input: A continuous function presented as an arithmetic circuit

• Task: Find an such that .

While Theorem 3 utilizes the Borsuk-Ulam theorem, it does not directly show containment in , because it does not construct an arithmetic circuit. We now show how this can be done if the mass distributions are unions of polygons with holes.

The key issue is how to determine how much of a polygon lies on a particular side of the cut. To do this, we first triangulate all polygons, as shown in Figure 4(a) to obtain mass distributions that are the unions of triangles. We then break each individual triangle down into a sum of axis-aligned right-angled triangles. This is shown in Figure 4(b), where the triangle is represented as the sum of .

We then explicitly build an arithmetic circuit that, given the point used in Theorem 3, and a specific axis-aligned right-angled triangle, can output the amount of mass of that triangle that lies on side A of the cut. Then the function used in Theorem 3 can be built simply by summing over the right-angled triangles that arise from decomposing each of the polygons. So we get the following theorem, which is proved formally in Appendix C.

###### Theorem 5.

Exact SC-Pizza-Sharing for weighted polygons with holes is in .

containment. In the following theorem we show that the problem of deciding whether there exists an exact solution of SC-Pizza-Sharing with mass distributions and turns in the SC-path is in . Consequently, this implies that the respective search problem lies in , and as it is apparent from the containment result of this paper, when the problem is in (). To show this we use the proof of Theorem 5. The detailed proof can be found in Appendix D.

###### Theorem 6.

For any , deciding whether there exists an SC-path with turns that is an exact solution for SC-Pizza-Sharing with mass distributions is in .

### 3.2 Containment results for approximate Sc-Pizza-Sharing

containment. The following theorem shows containment of -SC-Pizza-Sharing via a reduction to the problem which is in [DFMS21].

[backgroundcolor=white!90!gray, leftmargin=nerleftmargin=4pt, innertopmargin=4pt, skipabove=5pt,skipbelow=5pt]

###### Definition 7 (ε\textsc−Borsuk−Ulam).
• Input: A continuous function presented as an arithmetic circuit, along with two constants .

• Task: Find one of the following.

1. A point such that .

2. Two points such that .

If the second task is accomplished, then we have found witnesses that function is not -Lipschitz continuous in the -norm as required. But if the first task is accomplished then we have an approximate solution to the Borsuk-Ulam problem. To prove the theorem we utilize Theorem 5 and the Lipschitzness of the function we have constructed in its proof. The detailed proof can be found in Appendix E.

###### Theorem 8.

-SC-Pizza-Sharing for weighted polygons with holes is in .

containment. Finally, we show deciding whether there exists a solution for -SC-Pizza-Sharing with turns is in , for any . We prove this via a reduction to problem when -SC-Pizza-Sharing is parameterized by the number of turns the SC-path must have. Our proof combines ideas and results from the proofs of Theorems 6, 8, and 5. The detailed proof can be found in Appendix F.

###### Theorem 9.

For any , deciding whether there exists an SC-path with turns that is a solution for -SC-Pizza-Sharing with mass distributions is in .

## 4 Hardness results for Sc-Pizza-Sharing

Here we show all hardness results regarding the exact and approximate versions of SC-Pizza-Sharing. In Section 4.1 we provide hardness reductions for -SC-Pizza-Sharing, while in Section 4.2 we give hardness reductions for exact SC-Pizza-Sharing.

### 4.1 Hardness results for approximate Sc-Pizza-Sharing

In this section we prove several hardness results for -SC-Pizza-Sharing. We give two different reductions that allow us to prove a variety of results. The first one, which we call the “overlapping” reduction, is conceptually simpler, and it reduces from -Consensus-Halving with -block valuations. It produces SC-Pizza-Sharing instances where every mass distribution is a union of piece-wise uniform unit-squares. We use this to prove -hardness, -hardness, and -hardness for the problem when we have overlapping mass distributions.

The second reduction, which we call the “checkerboard” reduction is more technical and reduces from -Consensus-Halving with 2-block uniform valuations. It allows us to prove -hardness even when every mass distribution is --unit-square uniform. While the overlapping reduction produces mass distributions that can overlap each other, the checkerboard reduction produces an instance in which the mass distributions do not touch each other.

Since both reductions are from -Consensus-Halving with block valuations, we will begin by introducing some notation. For both reductions, we will reduce from an instance of -Consensus-Halving with k-block valuations for the agents. Thus, the valuation function of agent is defined by the subintervals for .

The first step of both reductions is to partition to subintervals that are defined by points of interest. We say that a point is a point of interest if it coincides with the beginning or the end of a valuation block of an agent; formally, is a point of interest if for some and . Let denote the points of interest and denote the intervals of interest. Observe that . In addition, observe that for every the difference is polynomially bounded with respect to the input size.

Overview of the overlapping reduction. The key idea behind the reduction is to encode Consensus-Halving instance as a sequence of diagonal squares in the SC-Pizza-Sharing instance. This can be seen in Figure 5. On the left we show a Consensus-Halving instance with three agents. The points of interest, which consist of any point at which some agent’s valuation changes, are shown along the bottom of this instance. These points conceptually splits the Consensus-Halving instance into blocks, since in between any pair of consecutive points of interest, all agents have a non-changing valuation.

On the right in Figure 5 we show how this instance is encoded in the SC-Pizza-Sharing instance. There are three mass distributions, coloured blue, green, and red, and each mass distribution corresponds to an agent from the Consensus-Halving instance. The instance consists of a sequence of squares, which are lined up diagonally, and each square corresponds to the corresponding block from the Consensus-Halving instance. Square corresponds to the region between and and so contains a single block from the blue mass distribution, square corresponds to the region between and and so contains three blocks, and so on. The squares are weighted according to the valuations of the agents, so in , the red and green squares get higher weights than the blue square, since the red and green agents value that block higher than the blue agent does.

The key observation is that if an SC-path cuts two distinct squares, then it must make at least one turn in between due to the diagonal arrangement of the squares. This will allow us to transform an SC-path with turns into a sequence of cuts for the Consensus-Halving instance: every time the path passes through a square, we transform it into a cut in the corresponding block in the Consensus-Halving instance. The weighting of the squares ensures that, if the SC-path cuts each of the mass distributions in half, then the cuts will be a solution to the Consensus-Halving instance.

The construction. We are ready to formally define the reduction. Starting from an instance of Consensus-Halving, we will construct an -SC-Pizza-Sharing instance .

For every agent we will create a mass distribution . We will create unit-squares which will be the locations where the mass distributions are placed. Unit-square is defined by the points , and , meaning that squares and are diagonally adjacent.

If agent has positive value over the interval of interest , then mass distribution has density over the -th unit-square. This means that for any mass distribution that appears in square and any area of size in square , we have that .

Observe that by the way the instance is constructed, any SC-path with turns can traverse at most squares. We must now show how the SC-path can be mapped to a solution for .

Figure 6 shows how we translate an SC-path into a sequence of cuts for . The first two diagrams show the simple case where the SC-path passes through a square without turning. This can simply be mapped back to a single cut in that cuts the same proportion of mass from the block.

If the SC-path turns inside a square, then we must be more careful. In the third diagram the path turns inside the square, and the square immediately before and the square immediately after the square are both on the same side of the cut. This means that we cannot use a single cut in , because then one of the two adjacent blocks would be in the red region. So instead, we use two cuts. This is not a problem, because the extra turn inside the square means that we can afford to use an extra cut inside this block in .

Fortunately, even if the path passes through the square multiple times, we never need to use more than two cuts in . In general, if the lower left corner of the square and the upper right corner of the square are on the same side of the SC-path, then we use two cuts in then we can use one cut. The final example in Figure 6 shows that, even though the SC-path passes through the square multiple times, we can still map this back to a single cut in because the lower left and upper right corners of the square are on opposite sides of the path. Formally, the translation between SC-paths and cuts in is given in the following lemma, whose proof appears in Appendix G.

###### Lemma 10.

Every solution of the -SC-Pizza-Sharing instance with an SC-path with turns corresponds to a solution of the -Consensus-Halving instance with cuts.

Hardness results. So far we have reduced Consensus-Halving to -SC-Pizza-Sharing, but the hardness result that we obtain depends on the instance of Consensus-Halving that we start with. We will show that, by varying this instance, we can obtain a variety of hardness results.

We begin by showing -hardness. In [FRHSZ2020consensus-easier] it was proven that -Consensus-Halving is -hard for even when we are allowed to use cuts, for some constant . This result, combined with Lemma 10, gives us the following.

###### Theorem 11.

-SC-Pizza-Sharing is -hard for , even when an SC-path with turns is allowed for some constant , and every mass distribution is piece-wise uniform over polynomially many unit-squares.

Next we can show -hardness. In [filos2018hardness] it was proven that -Consensus-Halving is -hard for a constant , 6-block valuation functions, and even when we are allowed to use cuts, for some constant . In addition, every agent has positive value for at most six intervals of interest and for every interval of interest at most three agents have positive value. So, combining this with Lemma 10 gives us the following.

###### Theorem 12.

-SC-Pizza-Sharing is -hard for some absolute constant , even when an SC-path with turns is allowed, for some constant , every mass distribution is piece-wise uniform over six unit-squares, and at any point of the plane at most three mass-distributions overlap.

Finally we can show an -hardness result. The instances from [filos2018hardness] were used to prove that it is -hard to decide whether -Consensus-Halving admits a solution with cuts. Again, we can use Lemma 10 to get the following.

###### Theorem 13.

It is -hard to decide if an -SC-Pizza-Sharing instance admits a solution with an SC-path with turns, even when every mass distribution is piece-wise uniform over six unit-squares, and at any point of the plane at most three mass-distributions overlap.

The checkerboard reduction. Finally, we show that the problem remains -hard even for unweighted non-overlapping squares. More formally, this means that the -th mass distribution consists of squares of size each and

is uniformly distributed over the

squares. In addition, there is no overlap between the mass distributions.

To do this, we use the same ideas as the overlapping reduction, but rather than producing overlapping squares, we create blocks instead that are filled with a checkerboard pattern to ensure that none of the mass distributions overlap. This is shown in Figure 7. The diagram on the left shows a Consensus-Halving instance, and the diagram on the right shows the corresponding SC-Pizza-Sharing instance. Note that now each block is filled by a tiling that contains squares from the mass distributions that appear in the corresponding interval of interest, where the tiling itself is shown in the middle figure. This ensures that no two mass distributions overlap.

The size of the squares associated with a specific mass distribution that appear in a tile are in proportion to the agent’s valuations in the Consensus-Halving instance. Since the squares in the tiles have different sizes, SC-paths in this instance do not perfectly map to cuts in the Consensus-Halving instance, since, for example, a different proportion of the red and blue masses may be cut within a single square. However, we are able to show that with a sufficiently dense tiling, the difference in proportions can be bounded, and so we can still recover an -solution for Consensus-Halving from an -solution for SC-Pizza-Sharing. The following theorem is proved formally in Appendix H.

###### Theorem 14.

-SC-Pizza-Sharing is -hard even when is inverse-polynomial with respect to , one is allowed to use turns for some constant , every mass distribution is uniform --square with , and there is no overlap between any two mass distributions.

### 4.2 Hardness results for exact Sc-Pizza-Sharing

In this section we show hardness results for exact SC-Pizza-Sharing. We prove that solving SC-Pizza-Sharing is -hard and that deciding whether there exists a solution for SC-Pizza-Sharing with strictly less than turns is -hard. We prove these results using a reduction that we call the “exact” reduction, which again starts from Consensus-Halving. This time however we will use the instances of Consensus-Halving produced in [DFMS21], which we will denote by . We note that here the input consists of sets of points, i.e. we describe polygons by their vertices (see Appendix A). In [DFMS21] the -hard family of instances we reduce from had as input arithmetic circuits capturing the cumulative valuation of agents on , which were piece-wise polynomials of maximum degree 2. However, since their (density) valuation functions consist of only rectangles and triangles, the input can also be sets of points that define the aforementioned shapes. So, there is no need for extra translation of the input of Consensus-Halving to the input of SC-Pizza-Sharing.

-hardness. Here we show that finding an exact solution to SC-Pizza-Sharing is -hard. The key difference between this reduction and the previous reductions on the approximate versions is that the instance contains triangular shaped valuations for agents. More specifically, all of the following hold:

1. the valuation function of every agent is 4-block+triangle, or 6-block;

2. every triangle has height 2 and belongs to exactly one interval of interest of the form ;

3. for every agent there exists an interval that contains more than half of their total valuation and in addition for every we have .

We will follow the same approach as in the overlapping reduction. Namely, every interval of interest will correspond to a unit-square located on the diagonal of the instance. Block-shaped valuations will be translated as before. For the triangular valuations, Point 2 guarantees that no triangle is split over two different intervals of interest. Hence, we can create an axis-aligned triangle inside the unit-square. Formally, if there exists a triangle in the interval of interest , then we create a triangle with vertices , , with density 1; this is because all triangles in the Consensus-Halving instance have the same value. Figure 8 shows an example of this.

One complication is that, if the SC-path turns inside a square, then it may not be possible to map this back to cuts in the SC-Pizza-Sharing instance. One example of this would be when the path cuts a portion of the square without cutting the triangle at all. Fortunately, we are able to use point 3 above to show that all exact solutions to the SC-Pizza-Sharing instance must pass through distinct squares. Therefore, if a SC-path “wastes” a turn by turning inside a square, then it can pass through at most distinct squares, and so it cannot be an exact solution to the SC-Pizza-Sharing instance.

Hence we can restrict ourselves to SC-paths that do not turn inside a square. The mapping from SC-paths to Consensus-Halving cuts is the same as the overlapping reduction. Here, in particular, we rely on the fact that if the SC-path does not turn inside a square, then it must pass through the triangular mass either horizontally or vertically, and so we can map this back to a single cut in the Consensus-Halving instance.

The following lemma is proved formally in Appendix I.

###### Lemma 15.

Any SC-path that is a solution for the produced SC-Pizza-Sharing instance, does not turn inside any unit-square.

Combining Lemma 15 and the -hardness proven for in [DFMS21] gives us the following result.

###### Theorem 16.

SC-Pizza-Sharing is -hard even when every mass distribution consists of at most six pieces that can be unit-squares or right-angled triangles, and they have overlap 3.

-hardness. We can also show that deciding whether there is an exact SC-Pizza-Sharing solution with turns exists is -hard. To show this, we will use a result of [DFMS21], where it was shown that deciding whether there exists an exact Consensus-Halving solution with agents and cuts is -hard. We give a reduction from this version of Consensus-Halving to the decision problem for SC-Pizza-Sharing. The reduction uses the same ideas that we presented for the -hardness reduction. The full details are in Appendix J, where the following theorem is shown.

###### Theorem 17.

It is -hard to decide if an exact SC-Pizza-Sharing instance admits a solution with a SC-path with turns.

## 5 Conclusion

We studied the complexity of SC-Pizza-Sharing and we have shown that finding an approximate solution is -complete even in very simple scenarios. One advantage of our reductions is that they are quite general and can be used as black boxes to get further results. For example, if we can prove that -Consensus-Halving is -hard for a constant and block valuations, the Overlapping reduction implies -hardness for -SC-Pizza-Sharing.

Our work identifies several interesting problems that require extra investigation. The most important one is whether we can get in polynomial time a solution for -SC-Pizza-Sharing for some constant . What is the exact complexity SC-Pizza-Sharing when every mass distribution is a collection of axis-aligned rectangles? Our results show that the problem is -hard and that it belongs to . Is it complete for any of these classes? Another problem is the complexity of -SC-Pizza-Sharing when every mass distribution consists of a constant number of non-overlapping rectangles. Also, we have shown that computing an exact solution of SC-Pizza-Sharing is -hard and in . Is the problem complete for or ? We conjecture that it is -complete.

## Acknowledgements

The work of the third author has been supported by the Alexander von Humboldt Foundation with funds from the German Federal Ministry of Education and Research (BMBF).

## Appendix A Input representation of Sc-Pizza-Sharing.

While the mathematical proof of Theorem 3 holds for general measures which are absolutely continuous with respect to the Lebesgue measure, in the computational problem SC-Pizza-Sharing

we need a standardized way to describe the input, and therefore restrict to particular classes of measures. We consider the class of mass distributions that are defined by weighted polygons with holes. This class consists of mass distributions with the property that are succinctly represented in the input of a Turing machine.

We will use the standard representation of 2-d polygons in computational geometry problems, that is, a directed chain of points. Consider a polygon that is defined by points , where , for , which form a directed chain . This chain represents a closed boundary defined by the line segments for and a final one . Since we consider polygons with holes, we need a way to distinguish between the polygons that define a boundary whose interior has strictly positive weight and polygons that define the boundary of the holes (whose interior has zero weight). We will call the former solid and the latter hollow polygon. To distinguish between the two, we define a solid polygon to be represented by directed line segments with counterclockwise orientation, while a hollow polygon to be represented similarly but with clockwise orientation. Furthermore, each solid polygon , its weight and its holes in the interior, are grouped together in the input to indicate that all these directed chains of points represent a single polygon .

## Appendix B Proof of Theorem 3

Consider the exact SC-Pizza-Sharing problem, whose definition is the same as Definition 2 for . We are given measures in . For ease of presentation, we consider the measures to be normalized in instead of .

We shall first consider the case where is even, i.e. for some . The proof for is similar and is mentioned at the end of this case. Let us first split the unit-square into stripes using horizontal cuts , and denote also by and . Then, let us cut with directed (pointing upwards) vertical lines each of the stripes, except for the bottom one, where a cut starts from the horizontal segment and ends up touching . As stated earlier, the bottom stripe is not cut by any vertical cut (see Figure 3 for an example).

We also define the variables where , . The sign of , indicates the sign of the leftmost part of slice that defines, and we set the whole slice to have the sign of . Clearly, , since , and , by definition. A feasible solution of SC-Pizza-Sharing is then the vector ; this defines a directed path that consists of horizontal and vertical line segments with at most turns. We can recover this path using Algorithm 1. Note that in the algorithm we implicitly suggest to navigate using the following trick: if we are at a horizontal part of the path, say , and we hit the boundary or before we reach a vertical cut, then we wrap around in the horizontal dimension and continue from point or respectively.

We will now define a Borsuk-Ulam function, namely a continuous function , for a suitable dimension to be defined later. It will turn out that , but having it undetermined for as long as we can makes the proof transparent enough to help in the understanding of the cases where (see Theorems 6, 9 and their proofs). Let the variables be in the -sphere under the norm, i.e. . Notice that now instead of a variable we have . A vector in maps back to a feasible solution of SC-Pizza-Sharing in the following way:

 |zi|=min{i∑j=1|Zj|,1}−i−1∑j=1|zj|={|Zi|, if∑ij=1|Zj|<1,1−∑i−1j=1|zj|, otherwise,
 |zm+1|=1−m∑i=1|zj|,
 andsign(zi) =sign(Zi),∀i∈[m] sign(zm+1) =sign(R).

Also,

 xi=min{|Xi|,1},andsign(xi)=sign(Xi),∀i∈[m].

Finally, we highlight that in the map-back process, is only used to indicate the sign of variable , while its absolute value has no other purpose than to serve as a remainder: it ensures that , i.e. it is .

For any given point , the Borsuk-Ulam function is defined to be the total “” (positive) measure on induced by , and we denote it by , that is, . The total positive measure is a continuous function of the variables. is mapped on (i.e. ), therefore it affords to capture distinct measures. By the Borsuk-Ulam theorem, there exist two antipodal points such that . Notice that , since by flipping the signs of the variables of , we consider the “” (negative) measure of induced by . Therefore, when we will have , that is, in each of the measures, the positive total measure equals the negative one. By mapping back to the corresponding point , we get a solution to SC-Pizza-Sharing. The total number of turns of the directed path is .

The proof is similar when . The horizontal cuts are again , but the vertical cuts are , meaning that the top slice is not vertically cut. Also, it is easy to see that one could consider the path to be again -monotone but in the opposite direction, meaning that there is no line segment pointing upwards.

###### Remark 18.

Note that a symmetric proof exists, where the slices are vertical instead of horizontal, and the cuts within the slices are horizontal instead of vertical. The analysis is similar to the one we give here, and it guarantees the existence of an SC-path which is allowed to wrap around in the vertical dimension, it bisects all measures and is -monotone with no line segment heading left (or right).

## Appendix C Proof of Theorem 5

Consider an arbitrary instance of exact SC-Pizza-Sharing, i.e. the one of Definition 2, where we additionally restrict the mass distributions to be weighted polygons (with holes). For ease of presentation, we will give distinct colours to the mass distributions , and call them colours . We are given a set of polygons with holes in the input form described in Appendix A. We will first do a preprocessing of the input: (a) normalization in , and (b) triangulation. The former is needed in order to simulate the space of the mathematical existence proof of Theorem 3, while the latter allows us to construct the Borsuk-Ulam function of the aforementioned proof via circuits. For the computation of the Borsuk-Ulam function described in Appendix B we need a way of computing the “positive” measure of a polygon, as dictated by a given feasible solution . To simplify this computation, we will triangulate further the polygon to end up with only non-obtuse triangles, which can be decomposed into axis-aligned right-angled triangles (Appendix C.1).

For task (a) we first check among all polygons of all colours, what the smallest and greatest coordinates of their vertices are, which defines a rectangle that includes all our polygons. Then, we find the square with smallest sides within which the aforementioned rectangle can be inscribed. Finally, by shifting the rectangle so that its bottom left vertex is at , and then scaling it down so that each side is of length , we get a normalized input where each polygon is in and their relative positions and areas are preserved. Task (b) is easily taken care of via already known algorithms (e.g. [GareyJPT78, AsanoAP86, Mehlhorn84, GhoshM91]) that triangulate polygons with holes in time (which is optimal) without inserting additional vertices.

### c.1 Computing areas of polygons via axis-aligned right-angled triangle decomposition

Here we first show how an arbitrary triangle can be decomposed into right-angled triangles whose right angle is additionally axis-aligned. Then, by using only the allowed gates of , we present a way to construct a Borsuk-Ulam function. We show that any solution of Borsuk-Ulam whose input is the aforementioned function can be mapped back in polynomial time to an exact SC-Pizza-Sharing solution.

By the definition of the Borsuk-Ulam function of Section 3, it is apparent that we need to be able to compute parts of the area of a polygon, depending on where square-cuts fall. The function we provide can compute parts of the area of axis-aligned right-angled triangles. For that reason, after a standard triangulation (e.g. using the technique of [AsanoAP86]) we further preprocess it and decompose each obtuse triangle into two right-angled triangles, by adding an extra line segment.

In particular, we check the obtuseness of a triangle by computing the squared lengths of its sides (each is rational; a sum of squares of rationals), taking the largest one, w.l.o.g. and then checking whether . If the inequality is not true then is non-obtuse and we proceed. Otherwise, we add the line segment that starts from and ends at on side , where . The coordinates of are rationals since they are the solution of the following two equations: (a) one that dictates that is on : , and (b) one that captures the fact that and are perpendicular: . In fact,

 xD=(yA−yD)[(yB−yA)(xA−xC)+(yA−yC)xA]+xB(xA−xC)2(xA−xC)(xA−xC+yA−yC),and yD=yA−yCxA−xC(xD−xA)+yA.

At this point the triangulation of each polygon consists of non-obtuse triangles. The following proposition makes the computation of areas of these triangles’ parts possible via a decomposition into axis-aligned right-angled triangles.

###### Proposition 19.

The area of any non-obtuse triangle can be computed by the areas of five axis-aligned right-angled triangles.

###### Proof.

A proof by picture is presented in Figure 4, where we draw a segment from the top-left corner to the bottom-right one, and .

The proof is immediate if we show that every non-obtuse triangle can be tightly inscribed inside a rectangle, meaning that all of its vertices touch the rectangle’s perimeter. In particular, the rectangle has coordinates , , , and .

First, we argue that one of ’s vertices is on a corner of the rectangle. W.l.o.g. suppose . If or then is the bottom-left or top-left corner of the rectangle, respectively. Otherwise, suppose w.l.o.g. that . If then is the bottom-right corner of the rectangle. Otherwise, . Then, if , is the top-right corner of the rectangle. Otherwise, and is the top-left corner of the rectangle. We conclude that a vertex of the triangle, w.l.o.g. , is on a corner of the rectangle.

Now we need to show that and lie on the perimeter of the rectangle. By the definition of the aforementioned rectangle’s vertices, it cannot be that both and are not on the perimeter; if for example is the top-right corner then , therefore vertex touches the lower side of the rectangle, and similarly if is any of the other corners. Now, for the sake of contradiction, suppose that the remaining vertex, w.l.o.g. does not touch the perimeter of the rectangle. Then, by definition of the rectangle’s vertices, is on another corner. If and are on the same side of the rectangle, then it is clear by the definition of the rectangle’s coordinates that must be on the perimeter of it. Otherwise and are diagonal corners of the rectangle. Then, is the largest side of the triangle and if is not on the boundary, it holds that , meaning that is obtuse, a contradiction. Therefore, any non-obtuse triangle can be tightly inscribed in a rectangle. ∎

### c.2 Constructing the Borsuk-Ulam function

Here we show how to construct the Borsuk-Ulam function