Short Plane Supports for Spatial Hypergraphs

A graph $G=(V,E)$ is a support of a hypergraph $H=(V,S)$ if every hyperedge induces a connected subgraph in $G$. Supports are used for certain types of hypergraph visualizations. In this paper we consider visualizing spatial hypergraphs, where each vertex has a fixed location in the plane. This is the case, e.g., when modeling set systems of geospatial locations as hypergraphs. By applying established aesthetic quality criteria we are interested in finding supports that yield plane straight-line drawings with minimum total edge length on the input point set $V$. We first show, from a theoretical point of view, that the problem is NP-hard already under rather mild conditions as well as a negative approximability results. Therefore, the main focus of the paper lies on practical heuristic algorithms as well as an exact, ILP-based approach for computing short plane supports. We report results from computational experiments that investigate the effect of requiring planarity and acyclicity on the resulting support length. Further, we evaluate the performance and trade-offs between solution quality and speed of several heuristics relative to each other and compared to optimal solutions.


Introduction
A hypergraph H = (V, S) is a generalization of a graph, in which each hyperedge in S is a nonempty subset of the vertex set V , that is, S ⊆ P(V ) \ {∅}. Furthermore, we assume here that every element v ∈ V is in at least one hyperedge s ∈ S. Hypergraphs arise in many domains to model set systems representing clusters, groups or other aggregations. To allow for effective exploration and analysis of such data, visualization is often used. Indeed, drawing hypergraphs relates to set visualization, an active subfield of information visualization (see the recent survey of Alsallakh et al. [3]). Various methods have been developed to visualize set systems for elements fixed in (geo)spatial positions, such as Bubble Sets [8], LineSets [2], Kelp Diagrams [9] and Kelp Fusion [17]. These methods make different trade-offs between, e.g., Gestalt theory and Tufte's principle of ink minimization [19] to visually convey the set structures; user studies have been performed to analyze the effectiveness of such trade-offs [17].
An important concept to model the drawing of hypergraphs is that of a hypergraph support [13]: a support of a hypergraph H = (V, S) is a graph G = arXiv:1808.09729v1 [cs.CG] 29 Aug 2018 (V, E) such that every hyperedge s ∈ S induces a connected subgraph in G. In other words, for every hyperedge s, the restriction of G to only edges that connect vertices in s, denoted G[s], is connected and spans all vertices in s. Hypergraph supports correspond to a prominent visualization style for geospatial sets, namely that of connecting all elements of a set using colored links, such as seen in Kelpstyle diagrams [9,17] (see also Fig. 1) or LineSets [2]. Thus, finding an embedded support that satisfies certain criteria readily translates into a good rendering of the spatial set system. A "good" support should avoid edge crossings, a standard quality criterion in the graph-drawing literature [18]. Moreover, as per Tufte's principle of ink minimization [19], it should have small total edge length. Of course, one may argue that edges of the support that are used by multiple hyperedges do not significantly reduce the "ink" and thus multiplicity should be considered. However, we observe that such edges show co-occurrences of elements and thus have a potential added value in the drawing-user studies that establish the validity of this reasoning are beyond the scope of this paper. The shortest support need not be a tree, but to further build on this idea of co-occurrences, one may want to restrict the support to be acyclic-a support tree.
In many applications, the vertices have some associated (geo)spatial location, thereby prescribing their positions in the drawing of the support. We focus on this case where vertices have fixed positions in the plane and study supports that are embedded using straight-line edges. Fig. 2 shows an example on real-world data of restaurants, similar to those used in [17].
Contributions. The contributions of this paper are two-fold: on the one hand we fill some gaps in theoretical knowledge about computing plane supports and support trees; on the other hand, we perform computational experiments to gain more insight into the trade-offs on the complexity of the visual artifact for (implicit) support-based set visualization methods. Our focus is on the latter.
In Section 2 we explore computational aspects of the problem and introduce our algorithms. We observe that plane support trees always exist if at least one vertex is contained in all hyperedges, but show that length minimization is NP-hard. Moreover, the natural approach to extend a minimum spanning tree does not even yield a constant-factor approximation. Finally, we present two heuristics, one based on local search, the other on iteratively computing minimum spanning trees, as well as an exact integer linear program (ILP). In Section 3 we describe the results of two computational experiments. The first experiment compares the performance of the two heuristic algorithms in terms of quality and speed. Whereas the local search achieves better quality, the approximation algorithm is faster. The second experiment compares how well these algorithms perform compared to the optimum, computed via the ILP, and investigates the cost in terms of edge length incurred by requiring planarity or acyclicity. The effect of planarity and acyclicity seems to be predictably influenced by the number of hyperedges and the number of incident hyperedges per vertex, but not by the number of vertices. Moreover, the experiment shows that local search often achieves an optimal result. Related work. Regarding supports for elements with fixed locations, some results are already known. The results of Bereg et al. [5] imply that existence of a plane support tree for two disjoint hyperedges can be tested in polynomial time; this implies the same result for a plane support. This problem has also been studied in a setting with additional Steiner points [4,10]. Van Goethem et al. [11] enforce a stricter planarity than that of planar supports and investigate the resulting properties for elements on a regular grid, where only neighboring elements can be connected. However, solution length is of no concern in their results.
Without the planarity requirement, existence and length minimization of a (nonplane) support tree for fixed elements can be solved in polynomial time [14,15]. Hurtado et al. [12] show that length minimization of a support for two hyperedges is solvable in polynomial time. However, for three or more hyperedges this problem is NP-hard [1]. We show that this is in fact hard for two hyperedges if we do require planarity.
Planar supports without fixed elements have also received attention. Johnson and Pollak [13] originally showed that deciding whether a planar support exists is NP-hard; various restrictions have since been proven to be NP-hard (e.g., [7]). Contrasting these reductions, our hardness result (Theorem 1) requires only two hyperedges, but uses length minimization. Buchin et al. [7] show that testing for a planar support tree with bounded maximum degree is solvable in polynomial time; testing for a planar support tree such that the induced subgraph of each hyperedge is Hamiltonian can also be done in polynomial time [6].

Computing short plane supports
We first describe our theoretical results. Omitted proofs are in Appendix A.
Existence. The observation below gives a sufficient condition for the existence of a plane support tree. Bereg et al. [5] provide a necessary condition for |S| = 2, though the problem remains open for |S| > 2.
Observation 1. Consider a hypergraph H = (V, S) with no three vertices in V on a line, such that V A = s∈S s = ∅. Then H has a plane support tree.
Proof. We use the Euclidean minimum spanning tree on V A and connect each vertex in V \ V A to the closest one in V A . This readily yields a support tree; it is plane as no crossings are created when connecting to the closest point in V A and no overlaps are created in the absence of collinear points.
Without a vertex in V A , one can immediately construct instances that enforce a crossing in any support, e.g., an X-configuration of two disjoint hyperedges.
Approximation. In a support tree the subgraph induced by V A must be a connected subtree to satisfy the support property for all hyperedges. Next we consider using the above idea to start with an Euclidean minimum spanning tree (EMST) of V A and extend it to a support tree. Though this leads to an approximation algorithm for two hyperedges [12] if we allow intersections, we show below that the planarity requirement can cause the resulting support length to exceed any constant factor of the length of the shortest plane support tree. Lemma 1. There is a family of n-vertex hypergraphs H = (V, {r, b}) with V A = r ∩ b = ∅ such that any plane support of H that includes an EMST of V A is a factor Θ(|V |) longer than the shortest plane support tree.
Proof (sketch). The family is drawn in Fig. 3. The convex chains force the support with length Θ(n) · when the EMST on V A is used. Using a different tree on V A can give a total of length Θ(1) · .
Removing vertex w from construction in Fig. 3, we can similarly show that a plane support tree, which now necessarily includes the edge uv, is a factor Θ(n) longer than a shortest nonplane support tree. Corollary 1. There is a family of n-vertex hypergraphs H = (V, {r, b}) with V A = r ∩ b = ∅ such that any plane support tree of H is a factor Θ(n) longer than the shortest nonplane support tree. Computational complexity. Unfortunately, finding the shortest plane support and several restricted variants are NP-hard, as captured in the theorem below. It uses a fairly straightforward reduction from planar monotone 3-SAT [16].
Theorem 1. Let H = (V, {r, b}) be a hypergraph with vertices V having fixed locations in R 2 and with r ⊆ b or r ∩ b = ∅. It is NP-hard to decide whether H admits a plane support tree with length at most L for some L > 0.

Iterative minimum spanning trees
Here we focus on computing short supports without requiring planarity. As described by Hurtado et al. [12], EMSTs can be used to find an approximation of the shortest support. In particular, let H = (V, S) be a hypergraph with n vertices and k hyperedges; by computing an EMST for each hyperedge and taking their union, we get a support that is a k-approximation 5 of the shortest support. This algorithm runs in O(kn log n) time.
Suppose that we compute the EMSTs T 1 , . . . , T k in that order, for the k hyperedges in S. The final support is the union of these trees: its length is not increased by using an edge in T i that is already present in some T j (j < i). Hence, we can consider any pair of vertices that is adjacent in T 1 ∪ . . . ∪ T i−1 to have distance zero, when computing T i . This heuristically reduces the length of the resulting support (though the approximation ratio remains the same). However, the order in which hyperedges are considered now matters for the result. To alleviate this issue, we iteratively recompute the minimum spanning trees.
Algorithm. We define a computation sequence σ of a hypergraph H = (V, S) as a sequence of hyperedges that contains each hyperedge in S at least once. Each item s in the sequence σ represents the computation of the (not-quite Euclidean) MST on the vertices of s, such that distances between pairs of vertices that are part of the current support have weight 0 and weight equal to their Euclidean distance otherwise. We use T s to denote the current MST for hyperedge s ∈ S; the support G is always the union over all T s . As we compute a spanning tree for each hyperedge, G is a support for H when the algorithm terminates.
Efficiency. Implementing G with adjacency lists, we use O(nk) storage as each of the k trees has O(n) edges. To compute T s , we use Lemma 2 below to conclude that there are O(nk) candidate edges, ensuring that Prim's MST algorithm runs in O(nk + n log n) time. To see that we can determine the weight without overhead, consider all vertices to be indexed with numbers from 1 to n. When adding a vertex u to the current tree in Prim's algorithm, we first process the neighbors of u in G (having a weight 0) and mark that these have been processed in an array using the above mentioned vertex index. Only then do we process all other vertices (having weight equal to the Euclidean distance) that are not marked and are not in the current tree. The total algorithm thus takes O(|σ|(nk + n log n)) time and Θ(nk) space.
Lemma 2. Let P be a point set and F ⊆ P × P . Consider the MST T on P , based on edge weights 0 for edges in F and the Euclidean distance otherwise. Then T is a subset of F and the Euclidean MST on P .
Properties (k = 2). The main question that arises is how long a computation sequence σ must be such that that the result stabilizes, that is, any sequence that extends σ gives a support that has the same total length. We use G σ to denote the support resulting from computation sequence σ. Below, we sketch an argument that for k = 2, we need to only recompute one hyperedge: sequence σ = r, b, r or σ = b, r, b is sufficient to obtain a stable result. We can compute both sequences and use the result with smallest total edge length. Proof (sketch). We show that the third computation does not add a new edge with both vertices in r ∩ b. Hence, the second and fourth computation receive the same input and thus yield the same result.

Local search
The algorithm described in Section 2.1 appears to perform well in practice, as shown in Section 3. However, one may wonder whether other commonly employed heuristic approaches outperform it in the experiments. We therefore implement a local-search algorithm, specifically, a hill-climbing heuristic.
Algorithm. This approach assumes that in the given hypergraph H = (V, S), at least one vertex v ∈ V occurs in all hyperedges s ∈ S such that Observation 1 applies; let V A = s∈S s = ∅. We need to initialize our hill climbing approach with a valid (plane), easy to find albeit possibly suboptimal solution. Following Observation 1, we obtain this by first calculating an EMST of all vertices in V A , and subsequently connecting all vertices v ∈ V A to the nearest v ∈ V A . Afterwards, we iteratively execute rounds until no further improvement is gained. Each round consists of checking for each edge in the support if it can be removed, and if the hyperedges using it can be reconnected by (one or more) other edges that have a shorter total length than the removed edge without causing intersections. This check is nontrivial and done in a brute-force manner, improved by caching and pruning. At the end of each round, the edge replacement that reduces the total edge length most is actually executed. More rounds are evaluated until no single edge replacement reduces the total edge length.
As the initial state is a plane support tree, we can also readily enforce acyclicity, or relax the constraints to allow intersections.

Integer linear program
Theorem 1 implies that several variants of computing the shortest plane support are NP-hard. Here we briefly sketch how to obtain an integer linear programs (ILP) for a hypergraph H = (V, S), allowing us to leverage effective ILP solvers.
We introduce variables e u,v ∈ {0, 1}, indicating whether edge uv is selected for the support. This allows us to represent a graph with fixed vertices. Because the vertex locations are fixed, we can precompute edge lengths d u,v as well as which pairs of edges intersect. This gives the following basic program What remains is to ensure that the graph is also a support: we need additional constraints that imply that each hyperedge in S induces a connected subgraph. To this end, we construct a flow tree for each hyperedge s. We pick an arbitrary sink for the hyperedge, σ s ∈ s, that may receive flow, and let the remaining vertices in s generate one unit of flow. To formalize this, we introduce variables f s,u,v ∈ {0, 1, . . . , |s| − 1} for each s ∈ S and u, v ∈ s with u = v. We now need the following constraints: (a) the incoming flow at σ s is exactly |s| − 1; (b) the outgoing flow at σ s is zero; (c) except for σ s , each vertex in s sends out one unit of flow more than it receives; (d) flow can be sent only over selected edges.
Variants. The ILP results in the shortest plane support for H. It can easily be modified to give a shortest (plane or unconstrained) support tree as well as to penalize or admit a limited number of intersections. The latter requires additional variables to indicate whether both edges of a crossing pair are used.

Experiments
As discussed above, there are various ways of defining and computing good supports. In this section we discuss several computational experiments that were performed to gain insight into the trade-offs between the different methods and properties. In particular, we use two different setups. First, we exclude optimal but slow algorithms to extensively compare the heuristic algorithms. Second, we include optimal algorithms to answer questions about the effect of requiring planarity or support trees, and to investigate how well heuristic algorithms approximate the optimal solution, albeit on smaller data sets.
Algorithms. We shall study four algorithms under various conditions in these experiments. In particular, we use MSTApproximation to refer to the simple approximation algorithm of computing a minimum spanning tree for each hyperedge and then taking their union [12]. We refer to our heuristic improvement as MSTIteration (Section 2.1). Finally, we use LocalSearch to indicate our local search algorithm (Section 2.2) and Opt to denote an exact algorithm for computing optimal solutions. The latter two allow four different conditions, by requiring a plane support, a support tree, both (i.e., a plane support tree) or neither (unrestricted). We append P, T, PT and U to denote these conditions. Data generation. We generate a random hypergraph H = (V, S) via the procedure described in Appendix B.1. Our method ensures that at least one vertex is an element of all hyperedges (necessary for LocalSearch, see Section 2.2), and that each hyperedge has at least two vertices. The procedure generates a hypergraph with n vertices, s hyperedges and a degree distribution d according to one of the following scheme: even All degrees occur equally frequently. mid Degrees are drawn from a normal distribution with a peak on k/2. low Degrees are drawn from a normal distribution with a peak on 1. high Degrees are drawn from a normal distribution with a peak on k.

Experiment 1: comparison of heuristics
Here we focus on answering the following three questions: (1) how much does the spanning tree iteration help to reduce the length of the support, compared to computing the minimum spanning trees in isolation; (2) which heuristic algorithm performs best in terms of support length; (3) which heuristic algorithm performs best in terms of computation time?
Setup. For each combination of n = 20, 40, 60, 80, 100, k = 2, 3, 4, 5, 6, 7 and d = even, mid, low, high, we generate 1000 random hypergraphs with n vertices and k hyperedges according to degree distribution scheme d. For each hypergraph, we perform six algorithms: MSTApproximation and MSTIteration as well as LocalSearch U/T/P/PT. This experiment was run on one machine, sequentially in a single thread to also allow for comparison of runtime performance. The machine was an HP ZBook with an Intel Core i7-6700HQ CPU, 24 GB RAM and running Windows 8.1.
Results. We first consider question (1) and compare MSTApproximation and MSTIteration. Since MSTIteration can only improve upon MSTApproximation, we express this as a ratio between 0 and 1. In Fig. 4 we show the results for n = 20, 60, 100 ( Fig. 10 in Appendix B.2 provides the chart for all cases). Interestingly, the median gain remains roughly equal as we increase the number of vertices, though the variance becomes lower. Increasing the number of hyperedges gradually increases the relative gain of MSTIteration. We also observe a dependency on the degree distribution. In particular, mid and even systematically benefit more from iteration than low and high. We explain this by observing that in the extreme cases MSTApproximation is optimal: if all vertices have degree 1, then the optimal support is simply the union of all (disjoint) minimum spanning trees; if all vertices have degree k, then the optimal support is also simply the minimum spanning tree on the vertices. Difficulties arise when having many vertices that are part of multiple but not all hyperedges. This corresponds to the mid and even schemes. Let us now turn towards question (2), and consider the resulting support length of the LocalSearch algorithm as well. We omit MSTApproximation from these comparisons, since MSTIteration always performs at least as well.
In Fig. 5 we show the results for n = 40 and 100 ( Fig. 11 in Appendix B.2 provides the chart for all cases). As one may expect, the length increases gradually with more hyperedges, as the support must use more edges to ensure that each hyperedge induces a connected subgraph. Moreover, we see that LocalSearch U consistently outperforms MSTIteration. To be exact, this is the case in 98.5% of all trials; the average ratio of LocalSearch U to MSTIteration (including those trials in which MSTIteration performs better) is 0.877, that is, the support length is over 12% shorter on average. The effect of degree distribution also stands out. In low and mid, requiring planarity or a support tree has a large effect on the support length, whereas this is not the case in even and high. To explain this, observe that the minimum spanning tree on vertices that are in many or all hyperedges is planar and likely a part of the computed solution; in the even and high cases, there are comparatively many such vertices which can then serve as places to connect the other vertices in the support. In the low and mid cases, there are only few such vertices and thus the shortest connections that can be used to connect these to such a "backbone" structure are likely to intersect other connections. Though the number of vertices has little effect on MSTIteration and LocalSearch U, this does exacerbate the  above problem: more vertices leads to a larger increase in support length when we enforce planarity or a support tree. Finally, we briefly consider question (3) and compare the computation times of the various algorithms (see Fig. 6, or Fig. 12 in Appendix B.2). We see that the number of hyperedges impacts the computation only slightly, whereas the number of vertices has a much stronger effect. MSTIteration clearly outperforms the LocalSearch variants, running on average 95.11% faster than Lo-calSearch U over all trials (98.73% faster on trials with n = 100). Another clear pattern is that requiring planarity with LocalSearch increases the running time significantly (272.64% slower over all trials, 354.06% on trials with n = 100); the number of steps to arrive at a local minimum is not sufficiently reduced to compensate for the time spent on checking intersections.

Experiment 2: comparison of optimality
Here we focus on answering two questions: (1) how is the support length affected by additionally requiring that the support is a tree and/or is planar; (2) how well do the heuristic algorithms approximate the optimal solution?
Setup. For each combination of n = 10, 15, 20, k = 2, 3 and d = low, mid, we generate 1000 random hypergraphs with n vertices, k hyperedges according to degree distribution scheme d. For each hypergraph, we run the LocalSearch U/T/P/PT and compute an optimal solution Opt U/T/P/PT 6 . To obtain a large enough number of trials, these experiments were run on different machines simultaneously and in concurrent threads. As such, we refrain from analyzing algorithm speed in this experiment.
Failed trials. In about 3.4% of the CPLEX runs for n = 20, the computation would run out of memory and therefore not finish successfully. We ran additional trials to compensate, eventually obtaining 1000 successful trials. This likely biases the results for n = 20 towards including only the "easier" situations. Appendix B.3 provides more details including statistics on which cases failed and indicators of the "difficulty" of these cases.
Results. Let us first compare the optimal solutions according to the four different restrictions. In Fig. 7 we show the results. For two hyperedges, we see that there is little to no effect of requiring support trees, but a small worst-case effect for requiring plane supports for the low case-the median increases only slightly. For three hyperedges, we see that the effects become slightly larger. Most noticeable is that enforcing support trees has now a slight effect, even for only a few vertices. In terms of plane supports, we see a similar pattern as before, that is, that of an increase particularly in the low case, but also some in the mid case. Note that the effects for n = 20 are potentially underestimated.
Let us now turn towards how well LocalSearch performs with respect to the optimal solution. Our results indicate that in a majority of the cases, our heuristic actually achieves optimal results (see Fig. 8). For n = 10,15 we see a clear decrease of this percentage for plane supports and trees; we attribute the apparent increase at n = 20 to the failed trials. To further see how well LocalSearch performs if it fails to achieve optimal results, we look at the ratio between the support length it achieves and the optimal support length. In all cases, we observe a ratio of less than 1.61. The 90-, 95-, and 99-percentile of this ratio was worst for LocalSearch PT, being 1.05, 1.09, and 1.19, respectively. Again, we have to keep in mind that the data for n = 20 likely exclude some more difficult cases and thus the trend in the increasing ratio might extend further for a larger number of vertices.

Conclusion
Motivated by the NP-hardness of computing shortest plane supports, we introduced and evaluated two heuristic algorithms for the problem. Our experiments showed that the heuristic LocalSearch often achieves the optimal solution, and otherwise computes a support that is less than 20% longer than the optimal solution in 99% of the cases. Moreover, our experiments showed that LocalSearch performs better than MSTIteration, which in turn is a k-approximation for k hyperedges. We can also guarantee that LocalSearch (without restrictions) is a k-approximation by initializing it using either MSTApproximation or MSTIteration, though it is not clear whether this change will generally improve the result of LocalSearch. There is a trade-off between speed and support length, where MSTIteration is better for the former and LocalSearch for the latter. We also observed that the increase in support length caused by additional requirements, depends both on the number of sets and the number of set memberships per element, but this behavior seems predictable and not to depend on the number of elements.
Future work. From the theoretical side, several questions remain open. For example, can we efficiently decide whether a plane support tree exists? We currently know how to answer this only for two hyperedges (using Observation 1 and [5]). Furthermore, how many iterations do we need for MSTIteration with more than two hyperedges, to guarantee that the computation stabilizes?
Our experiments indicate that our local search algorithm does not always perform optimally, especially when requiring plane supports. It is, however, based on simple hill climbing. Can we employ better search techniques such as simulated annealing to efficiently find better solutions?
Finally, we chose to generate random hypergraphs for our experiments, as to not depend on particular properties of (geospatial) configurations that may be inherent to some real-world data sets. While this reduces the explanatory power with respect to real-world data sets, it provides us with more insight into the structural problem, unbiased by unknown or hidden structures of real-world data. We leave it to future work to further dive into real-world data sets, to see if similar trends and patterns emerge or more difficult structures arise and to evaluate the impact of the different heuristics on readability.
A Appendix: Omitted proofs Lemma 1. There is a family of n-vertex hypergraphs H = (V, {r, b}) with V A = r ∩ b = ∅ such that any plane support of H that includes an EMST of V A is a factor Θ(|V |) longer than the shortest plane support tree.
Proof. The hypergraph family is illustrated in Fig. 3 (on page 4).
The set V A = {u, v, w} consists of three vertices whose EMST T has length + 1 and is indicated by the black edges in Fig. 3(a). The remaining vertices in V \ V A are indicated in red and blue (indicating membership of r and b) and placed inside a disk of radius ε just left of the midpoint of edge uv. The vertices alternate in colors from left to right and form two mirrored convex chains.
Since edge uv of T splits the vertices in V \ V A and by their placement on convex chains, the shortest extension of T into a plane support tree is to connect every vertex to u (Fig. 3(a)). This yields a total length of the support tree of Θ(n) · . If, however, V A is connected by a slightly longer tree, the remaining vertices in V \ V A can be joined by two comb-shaped structures as shown in Fig. 3(b). The resulting plane support tree has length of Θ(1) · . Theorem 1. Let H = (V, {r, b}) be a hypergraph with vertices V having fixed locations in R 2 and with r ⊆ b or r ∩ b = ∅. It is NP-hard to decide whether H admits a plane support tree with length at most L for some L > 0.
Proof. We first show the reduction for the case that r ⊆ b. We use a reduction from planar monotone 3-SAT [16]. Here, we are given a 3-CNF formula φ with n variables v 1 , . . . , v n and m clauses c 1 , . . . , c m such that every clause either has three positive literals or three negative literals. Moreover, we are given an embedding of φ as a graph, with rectangular vertices for variables on a horizontal line, and clauses as rectangles above or below the line (depending on whether the clause is positive or negative). Vertical edges connect clauses to the variables of their literals.
We must construct a hypergraph H = (V, {r, b}) such that r ⊆ b. In the remainder, we assign vertices to either r (red) or b (blue), understanding that any red vertex is also in b.
We now place additional blue vertices for each clause c a . We assume that this clause has positive literals for variable v i , v j , and v k ; the construction for clauses with negative literals is symmetric, using negative y-coordinates instead. First, we place 3a + 1 blue vertices from (3(i − 1)(m + 1) + 3p, 2) to (3(i − 1)(m + 1) + 3p, 2 + 3a) at unit distance, to represent the incidence from c a to variable v i , using the given embedding to determine that c a is the pth clause incident from above to v i . Analogously, we place the blue vertices for v j and v k . Now, we place further blue vertices at unit distance with y-coordinate 2 + 3a from the leftmost to the rightmost top vertex we just placed. The result is given in Fig. 9. One clause requires at most 3(3m + 1) vertices for the variable incidence and less than 3n · (m + 1) for the horizontal line connecting these. We can now readily measure the length of the minimum spanning tree on the blue vertices of one clause. We use L a to denote this length; note that L a is an integer at most 3(3m + 1) + 3n · (m + 1).
The value of L that we select is 2(n + 1) + 3n · (m + 1) + n(3m + 2) + 2m + a∈[1,m] L a . This finalizes the construction. It is polynomial since we placed 3(n + 1) red vertices and n · (3m − 2) blue vertices for the variables and at most m · (3(3m + 1) + 3n · (m + 1)) for the clauses: this is O(nm 2 ) vertices. Moreover, we claim that our constructed hypergraph admits a plane support tree of length at most L, if and only if φ is satisfiable.
Assume we have a plane support tree of length at most L. First, we observe that all points in r must be connected: the minimal way of doing so connects the three vertices with the same x-coordinate and uses one horizontal line to connect one triplet to the next. This has exactly length 2(n + 1) + 3n · (m + 1), corresponding to the first two terms defining L. The minimal way of connecting the lines inside the variables to the red tree takes length n(3m + 2) in total: this is the third term defining L. Finally, to connect the clause vertices, we need length at least L a per clause, the last term of L. We note that any solution must use these constructions on the blue vertices, since all vertices are at unit distance; other blue vertices are at distance at least 2. However, the support tree is connected: thus it must still have connections from each gadget to either a red vertex or a blue vertex of a variable. The budget we have for this is 2m in total. Since each clause needs a connection of length at least 2, all clauses use exactly length 2. The only vertices within distance 2 of a clause are the three blue vertices of the variables with y-coordinate zero (one of each literal of the clause). Thus, each clause must have exactly one length-2 edge to one of these variable vertices. Since the support tree is plane, this cannot cross the horizontal links used to connect the red vertices. We can now readily obtain a satisfying assignment for φ, by looking at which of the two horizontal lines is used to connect the red vertices: if the one at the top is used, that variable is set to false; it is set to true otherwise.
To prove the converse, assume that we have a satisfying assignment. Using the same reasoning as above, we can construct the plane support tree by picking the connecting horizontal lines for the red vertices according to the satisfying assignment: this readily leads us to conclude that we can connect each clause using a length-2 connection that does not intersect the horizontal lines for the red vertices.
Finally, let us consider the case that r and b are disjoint. The reduction can easily be amended to work for this case: the red vertices are only in r rather than r and b. This then needs slightly more spacing such that we can add a few extra blue vertices that can be used to connect all the blue vertices of the variables into a single component using only length-1 edges.
Lemma 2. Let P be a point set and F ⊆ P × P . Consider the MST T on P , based on edge weights 0 for edges in F and the Euclidean distance otherwise. Then T is a subset of F and the Euclidean MST on P .
Proof. Let T denote the Euclidean MST on P . Assume that MST T has some edge e that is neither in F nor in T . Since T is a tree, removing e from it partitions the tree into two connected components. By definition, T contains an edge e that connects the two components and by assumption e = e. Since T is the Euclidean MST 7 , we know that e < e , where · denotes the Euclidean length. Since e is not in F , the weight it contributes to T is e and thus we can find a shorter spanning tree T * , by replacing e with e in T . This contradicts that T is the MST, thus proving the lemma.
Observation 2. A computation sequence featuring two consecutive occurrences of the same hyperedge achieves the same result as the computation sequence in which these consecutive occurrences have been replaced by a single occurrence. Hence, any computation sequence (that is not equivalent to some shorter sequence) consists of alternating r's and b's. Proof. By Observation 2, consider σ to start either (i) with r, b, r, b, . . . or (ii) with b, r, b, r, . . . . We will show that the subsequence σ consisting of the first three hyperedges of σ achieves the same support as σ .
Consider all edges (v i , v j ) ∈ V × V . There are four cases: -If both v i and v j are in both r and b, let the edge be in a set P of purple edges. -Else, if v i and v j are both in r, let the edge be in a set R of red edges.
-Else, if v i and v j are both in b, let the edge be in a set B of blue edges.
-Else, the edge will never be a part of a support as the vertices do not share a color.
Without loss of generality we consider case (i). Let the support constructed after step i of σ be called G i , so that we have G 1 , G 2 and G 3 . We show that P (G 2 ) = P (G 3 ), where P (G) denotes taking the subset of edges of G that are in P .
. Let e p ∈ P (G 3 ). For a contradiction, assume e p ∈ P (G 2 ). As edges in P are never removed from the support once they are added -they have weight 0, after all -, we have e p ∈ P (G 1 ) either. As G 1 is the Euclidean MST of r, by the cut property of MSTs there is another edge e ∈ R ∪ P shorter than e p in the cut induced by e p that must be a part of the MST instead. 8 When constructing G 3 , again e will be chosen over e p , and thus e p ∈ P (G 3 ). P (G 2 ) ⊆ P (G 3 ). Let e p ∈ P (G 2 ). We already established that edges in P are never removed from the support once they are added, hence e p ∈ P (G 3 ).
Take an edge e ∈ G 3 . For a contradiction, assume e ∈ G 4 . As edges in P are not removed and edges in R remain untouched, e ∈ B. As e ∈ G 4 and the fourth step calculates MST(b), the cut property tells us that some other edge e ∈ B ∪ P is shorter and in MST(b) instead. But then e would have been added in G 2 and hence e ∈ G 3 . G 4 ⊆ G 3 . Take an edge e ∈ G 4 . For a contradiction, assume e ∈ G 3 . This means e ∈ R, as such edges cannot be added when computing MST(b). Edges in P are never removed, thus e ∈ G 2 . The second step of σ computed MST(b), hence by the cut property there must be another edge e , shorter than e, part of MST(b) instead. Indeed, this implies e ∈ MST(b). However, as G 4 is computing an MST for b and we assumed e ∈ G 4 , e ∈ MST(b).

B Appendix: Experimental results
This appendix provides additional details regarding the experiments of Section 3. Upon acceptance, we intend to make a version available on ArXiv to provide these additional details.

B.1 Data generation
We generate a random hypergraph H = (V, S) via to the procedure below. We use n = |V | and k = |S| to denote the desired number of vertices and hyperedges respectively.

Initialize an array
indicates that we wish to generate D[i] vertices of degree i. To this end, we define four schemes, where we always restrict the degrees to be between 1 and k. even All degrees occur equally frequently. If n mod k = 0, then degrees one through n mod k occur once more than the others. mid We generate n random degrees using a normal distribution. We draw a random value g from N (0.5, 2/9) and map this to degree 1 + kg . The distribution of degrees is expected to look like a Gaussian curve with its peak on k/2. low Similar to the mid scheme, we draw a random value g from N (0, 2/5) and map this to degree 1+ k|g| . The distribution of degrees is expected to look like a Gaussian curve with its peak on 1. high Similar to the mid scheme, we draw a random value g from N (0, 2/5) and map this to degree k − k|g| . The distribution of degrees is expected to look like a Gaussian curve with its peak on k. To explain the four steps in this algorithm, we treat them in reverse order. 4. We generate all desired n vertices and assign them to hyperedges. We first pick from those hyperedges that have less than two vertices, to ensure that each hyperedge contains at least two vertices. This ensures that all hyperedges have influence on the support. We pick a random degree, to avoid biasing small hyperedges towards low degree or high degree vertices. 3. We ensure that the sum over all degrees (over all nodes) is at least 2k. We need this lower bound on the sum of degrees, to ensure that we are able to pick at least two vertices for every hyperedge. 2. We ensure that there is at least one vertex that occurs in all hyperedges; this step is optional but necessary to ensure that our local search algorithm can be initialized. It guarantees that a planar solution exists, see Section 2.2. 1. We decide on the distribution over the degrees. That is, how many vertices shall we have of degree i? This can be done according to various schemes. The four schemes used in this paper are described in the main text.

B.3 Experiment 2
Failed trials. CPLEX was allocated 24GB of RAM and 64GB of file storage. Nonetheless, the CPLEX computation would run out of memory and therefore not finish successfully for some cases with n = 20. We have therefore ran 1730 trials for each of the four conditions (k × d) with four settings for Opt; 941 runs out of these 27, 680 runs failed. This is shown in Table 1. We filtered out erroneous trials, leaving 1138 trials, 1000 of which were used for the analysis of the results to match the cases for n = 10, 15. This may bias the results towards only including the easier cases on which CPLEX was successful; this should be taken into consideration for the upcoming results discussion. To localize and quantify this bias, we counted which conditions failed and, for each condition, measured the average length of the LocalSearch results in the successful and failed trials (see Table 1). We note that the tree and plane tree cases are impacted most significantly. We also see that the ratio is mostly well above one, suggesting that indeed the more difficult cases have now been excluded from the analysis.