A Note On Universal Point Sets for Planar Graphs

We investigate which planar point sets allow simultaneous straight-line embeddings of all planar graphs on a fixed number of vertices. We first show that $(1.293-o(1))n$ points are required to find a straight-line drawing of each $n$-vertex planar graph (vertices are drawn as the given points); this improves the previous best constant $1.235$ by Kurowski (2004). Our second main result is based on exhaustive computer search: We show that no set of 11 points exists, on which all planar 11-vertex graphs can be simultaneously drawn plane straight-line. This strengthens the result by Cardinal, Hoffmann, and Kusters (2015), that all planar graphs on $n \le 10$ vertices can be simultaneously drawn on particular `universal' sets of $n$ points while there are no universal sets for $n \ge 15$. Moreover, we provide a set of 23 planar 11-vertex graphs which cannot be simultaneously drawn on any set of 11 points. This, in fact, is another step towards a (negative) answer of the question, whether every two planar graphs can be drawn simultaneously -- a question raised by Brass, Cenek, Duncan, Efrat, Erten, Ismailescu, Kobourov, Lubiw, and Mitchell (2007).


Introduction
A point set S in the Euclidean plane is called n-universal for a family G of planar n-vertex graphs if every graph G from G admits a plane straight-line embedding such that the vertices are drawn as points from S. A point set, which is n-universal for the family of all planar graphs, is simply called n-universal. We denote by f p (n) the size of a minimal n-universal set (for planar graphs), and by f s (n) the size of a minimal n-universal set for stacked triangulations, where stacked triangulations (a.k.a. planar 3-trees) are defined as follows: Definition 1 (Stacked Triangulations). Starting from a triangle, one may obtain any stacked triangulation by repeatedly inserting a new vertex inside a face (including the outer face) of the actual triangulation and making it adjacent to all the three vertices contained in the face. De Fraysseix, Pach, and Pollack [DFPP90] showed that every planar n-vertex graph admits a straight-line embedding on an (2n − 4) × (n − 2) grid -even if the combinatorial embedding (including the choice of the outer face) is prescribed. Moreover, the graphs are only embedded on a triangular subset of the grid. Hence, f p (n) ≤ n 2 − O(n). This bound was further improved to the currently best known bound f p (n) ≤ n 2 4 − O(n) [BCDE14] (see also [Sch90,Bra08]). Also various subclasses of planar graphs have been studied intensively: Any stacked triangulation on n vertices (with a fixed outer cell) can be drawn on a particular set of f s (n) ≤ O(n 3/2 log n) points [FT15]. For outerplanar graphs, it is known that any set of n points in general position is

Outline
Our first result is the following theorem, which further improves the lower bound on f s (n). We present its proof in Section 3. In Section 4 we present our second result, which is another step towards a (negative) answer of Question 1 and strengthens the results from [CHK15]. Its proof is based on exhaustive computer search.
Theorem 2 (Computer-assisted). There is a conflict collection consisting of 23 stacked triangulations on 11 vertices. Furthermore, there is no conflict collection consisting of 16 triangulations on 11 vertices.
Last but not least, since all known proofs for lower bounds make use of separating triangles, we also started the investigation of 4-connected triangulations. In Section 5 we present some n-universal sets of size n for 4-connected planar graphs for all n ≤ 17.

Proof of Theorem 1
To prove the theorem, we use a refined counting argument based on a construction of a set of labeled stacked triangulations that was already introduced in [CHK15]. There it was used to disprove the existence of n-universal sets of n ≥ 15 points for the family of stacked triangulations.
Definition 2 (Labeled Stacked Triangulations, cf. [CHK15, Section 3]). For every integer n ≥ 4, we define the family T n of labeled stacked triangulations on the set of vertices V n := {v 1 , ..., v n } inductively as follows: • T 4 consists only of the complete graph K 4 with labels v 1 , . . . , v 4 .
• If T is a labeled graph in T n−1 with n ≥ 5, and v i v j v k defines a face of T , then the graph obtained from T by stacking the new vertex v n to v i v j v k (i.e., connecting it to v i , v j , and v k ) is a member of T n .
It is important to notice that, when speaking of T n , we distinguish between elements if they are distinct as labeled graphs, even if their underlying graphs are isomorphic. The essential ingredient we will need from [CHK15] is the following.
(ii) Let P n = {p 1 , . . . , p n } be a set of n ≥ 4 labeled points in the plane. Then for any bijection π : V n → P n , there is at most one T ∈ T n such that the embedding of T , which maps each vertex v i to point π(v i ), defines a straight-line-embedding of T .
We need the following simple consequence of the above: Corollary 5. Let P = {p 1 , . . . , p m } be a set of m ≥ n ≥ 4 labeled points in the plane. Then for any injection π : V n → P , there is at most one T ∈ T n such that the embedding of T , which maps each vertex v i to point π(v i ), defines a straight-line-embedding of T .
Proof. Let T 1 , T 2 ∈ T n be two stacked triangulations such that π describes a plane straight-line embedding of both. Since π is an injection, this means that π defines a straight-line embedding of both T 1 , T 2 on the sub-point set Q := π(V n ) of P of size n. Applying Lemma 4(ii) to the bijection π : V n → Q and T 1 , T 2 , we deduce T 1 = T 2 . This proves the claim.
We are now ready to prove Theorem 1.
Proof of Theorem 1. Let n ≥ 4 be arbitrary and m := f s (n) ≥ n. There exists an n-universal point set P = {p 1 , . . . , p m } for all stacked triangulations, hence for every T ∈ T n there exists a straight-line embedding of T on P , with (injective) vertex-mapping π : V n → P . By Corollary 5, we know that no two stacked triangulations from T n (each of which has the same vertex set) yield the same injection π. Consequently, by Lemma 4(i), we have Let β(n) := fs(n) n . Using the fact that (Stirling-approximation) we deduce (taking logarithms) that: (1))αn, which is the claim.

Proof of Theorem 2 and Corollary 3
In the following, we outline the strategy which we have used to find a conflict collection of 23 stacked 11-vertex triangulations. A reader who is mainly interested in verifying our computational results might want to jump directly to Section 4.5.
One fundamental observation which we use throughout this section is the following: if an nuniversal point set has collinear points, then by perturbation one can obtain another n-universal point set in general position, i.e., with no collinear points. Hence, in the following we only consider point sets in general position. Also it is not hard too see that, if two point sets are combinatorially equivalent, i.e., there is a bijection such that the corresponding triples of points induce the same orientations, then both sets allow precisely the same straight-line drawings. Hence, in the following we further restrict our considerations to (non-degenerated) order types, i.e., the set of equivalence classes of point sets (in general position).

Enumeration of Order Types
The database of all order types of up to n = 11 points was developed by Aurenhammer, Aichholzer, and Krasser [AAK02,AK06] (see also Krasser's dissertation [Kra03]). The file for all order types of up to n = 10 points (each represented by a point set) is available online, while the file for n = 11 requires almost 100GB of storage and is available on demand [Aic]. Their algorithm starts with an abstract order type on k − 1 points (which only encodes the triple orientations of a point set), computes its dual pseudoline arrangement, and inserts a k-th pseudoline in all possible ways. Due to geometrical constraints, there are in fact abstract order types enumerated which do not have a realization as a point set. However, since every order type is in fact also an abstract order type, it is sufficient for our purposes to test all abstract order types -independent from realizability.
For means of redundancy and to provide a fully checkable and autonomous proof, we have implemented an alternative algorithm to enumerate all abstract order types based on the following idea: Given a set of points s 1 , . . . , s n with s i = (x i , y i ) sorted left to right 1 , and let denote the induced triple orientations, then the signotope axioms assert that, for every 4-tuple s i , s j , s k , s l with i < j < k < l, the sequence χ ijk , χ ijl , χ ikl , χ jkl 1 in the dual line arrangement the lines are sorted by increasing slope (index-triples are in lexicographic order) changes its sign at most once. For more information on the signotope axioms we refer to Felsner and Weil [FW01] (see also [BFK15]).
Given an abstract order type on k − 1 points, we insert a k-th point in all possible ways, such that the signotope axioms are preserved. With our C++ implementation, we managed to verify the numbers of abstract order types from [AAK02,AK06,Kra03]. In fact, the enumeration of all 2,343,203,071 abstract order types of up to n = 11 points (cf. OEIS/A6247) can be done within about 20 hours on a single CPU.

Enumeration of Planar Graphs
To enumerate all non-isomorphic maximal planar graphs on 11 vertices (i.e, triangulations), we have used the plantri graph generator (version 4.5) [BM99]. It is worth to note that also the nauty graph generator [MP14] can be used for the enumeration because the number of all (not necessarily planar) graphs on 11 vertices is not too large and the database can be filtered for planar graphs in reasonable time -negligible compared to the CPU time which we have used for later computations. For various computations on graphs, such as filtering stacked triangulations or to produce graphs for this paper, we have used SageMath [S + 18a] 2 .

Deciding Universality using a SAT Solver
For a given point set S and a planar graph G = (V, E) we model a propositional formula in conjunctive normal form (CNF) which has a solution if and only if G can be embedded on Sin fact, the variables encode a straight-line drawing.
To model the CNF, we have used • the variables M vp to describe, whether vertex v is mapped to point p, and • the variables A pq to describe, whether the straight-line segment pq between the two points p and q is "active" in a drawing.
It is not hard to use a CNF to assert that such a vertex-to-point mapping is bijective. Also it is easy to assert that, if two adjacent vertices u and v are mapped to points p and q, then the straight-line segment pq is active. For each pair of crossing straight-line segments pq and rs (dependent on the order type of the point set) at least one of the two segments is not allowed to be active.
Implementation detail: We have implemented a C++ routine which, given a point set and a graph as input, creates an instance of the above described model and then uses the solver MiniSat 2.2.0 [ES03] to decide whether the graph admits a straight-line embedding.

Finding Conflict Collections -A Quantitive Approach
Before we actually tested whether a set of 11 points is 11-universal or not, we discovered a few necessary criteria for the point set, which can be checked much more efficiently. These considerations allowed a significant reduction of the total computation times.
Phase 1: First of all, an 11-universal point set -if one exists -trivially has a triangular convex hull. Secondly, the planar graph depicted in Figure 1 asserts an 11-universal set S to have a certain structure. If the embedding is as on the left of Figure 1, then one of the two degree 3 vertices is drawn as extremal point of S, i.e., lies on the boundary of the convex hull conv(S) of S. After the removal of this particular point, the remaining 10 points have 4 convex layers of sizes 3, 3, 3, and 1, respectively. If the embedding is as on the right of Figure 1, then either one or two points of the blue triangle are drawn as extremal points of S (recall the triangular convex hull of S). And again, the points inside the blue triangle and outside the blue triangle have convex layers of sizes 3, 3, 1, and 3, 1, respectively. Altogether, only 293,114,696 of the 2,343,203,071 abstract order types on 11 points fulfill the two conditions. There exist stacked triangulations on 11 points in which every face is incident to a degree-3vertex; see for example G 11 in Figure 2. Independent from the embedding of such a graph, there is a degree-3-vertex on the outer face, and hence all inner points lie inside a triangle spanned by an interior point and two extremal points.
Phase 2: For each of the 293,114,696 abstract order types on 11 points which fulfill the conditions above, we have tested the embeddability of all maximal planar graphs on n vertices separately using a SAT-solver based approach [ES04]. In fact, as soon as one graph was not embeddable, the remaining graphs needed not to be checked. To speed up the computations we have used a priority queue: a graph which does not admit an embedding gets increased priority for other point sets to be tested first.
To keep the conflict collection as small as possible, we first filtered out all point sets which do not allow a simultaneous embedding of all planar graphs on 11 vertices with maximum degree 10. Only 278,530 of the 293,114,696 abstract order types remained (computation time about 100 CPU days). It is worth to note that there are 82 maximal planar graphs on 11 vertices with maximum degree 10 (cf. OEIS/A207), and that each of these graphs is a stacked triangulation.
At this point one can check with only a few CPU hours that the remaining 278,530 abstract order types are not 11-universal. Moreover, since some stacked triangulations on 11 vertices (e.g. G 8 from Figure 2) contain the graph from Figure 1 as a subgraph, the statement even applies to stacked triangulations. Consequently, the family of all 434 stacked triangulations on 11 vertices (cf. OEIS/A27610) is a conflict collection, and Corollary 3 follows directly.
Phase 3: To find a smaller conflict collection, we tested for each of the 434 stacked triangulations and each of the 278,530 remaining abstract order types, whether an embedding is possible (additional 35 CPU days). We used this binary information to formulate an integer program searching for a minimal set of triangulations, without simultaneous embedding. Using the Gurobi solver (version 8.0.0) [Gur18], we managed to find a collection G of 11 stacked triangulations which cannot be embedded simultaneously 3 ; see Listing 1 and Figure 2.
In fact, the Gurobi IP solver showed optimality and thus no conflict collection of size less than 11 can exist for n = 11. Since we asserted in Phases 1 and 2 that (1) the graph in Figure 1, (2) a triangulation where every face is incident to a vertex of degree 3, and (3) all 82 triangulations with maximum degree 10 occur in the conflict collection, this yields a conflict collection of size 95 = 1 + 1 + 82 + 11. In fact, since this subset of 11 stacked triangulations contains triangulations fulfilling properties (1) and (2) (see e.g. graphs G 8 and G 11 in Figure 2), we indeed have a conflict collection of size 93.
Phase 4: Recall that a minimal conflict collection not necessarily needs to fulfill the properties (1)-(3). Hence we again repeat the strategy from Phase 2, except that we test for the embeddability of the 11 stacked triangulations from the collection G obtained in Phase 3 instead of the 82 maximal planar graphs on 11 vertices with maximum degree 10.
After another 230 days of CPU time, our program had filtered out 17,533 of the 293,114,696 abstract order types (obtained in Phase 1) which allow a simultaneous embedding of the 11 stacked triangulations from G.
Phase 5: As the reader might already guess, we proceed as in Phase 3: we tested for each of the 434 stacked triangulations and each of the 17,533 order types from Phase 4, whether an embedding is possible (only 2 CPU days). Using the Gurobi solver, we managed to find a collection H of 12 stacked triangulations, which cannot be simultaneously embedded on those order types; see Listing 1 and Figure 2.
Together with the 11 stacked triangulations from G we obtain a conflict collection of size 23, and the first part of Theorem 2 follows.
Phase 6: As the solution of the integer programming instance from Phase 5 found by Gurobi was optimal, any conflict collection of stacked triangulations must have size at least 12. To further improve this lower bound, we have repeated our computations for the union of the two sets of point sets obtained in Phase 3 and Phase 5, respectively. Using Gurobi, we could optimally solve the instance and hence any conflict collection consisting of 11-vertex stacked triangulations has size at least 17.
Surprisingly, when replacing the 434 stacked triangulations by the collection of all 1,249 triangulations (cf. OEIS/A109), the Gurobi solver also showed that any conflict collection of (arbitrary) 11-vertex triangulations has size at least 17. The computation took about 1 day using 20 threads in parallel.
For means of redundancy, we have verified all lower bounds obtained by Gurobi also using CPLEX (version 12.8.0.0) [IBM18], which performed similar to Gurobi (with 20 threads in parallel).
This completes the proof of the second part of Theorem 2.
3 Indeed it was a funny coincidence that this set has cardinality 11, which is also the number of vertices.

How to Verify our Results?
To verify the computational results which are essential for the proof of the first part of Theorem 2, one can enumerate all order types on 11 points and test the conflict collection of 23 triangulations (data/triangulations/n11_conflicting23.txt). Starting with the unique order type on 3 points (data/order_types/n3_order_types.bin), it takes about 1 CPU day to enumerate all order types on 11 points. By falsifying simultaneous embeddability of the 23 graphs (this computation takes about 200 CPU days, but can be run parallelized), the first part of Theorem 2 is then verified.
For the second part of the Theorem 2, one can filter the order types, which allow a simultaneous embedding of the triangulations from Phase 2 and 4, and then -using CPLEX or Gurobi -compute the minimum size of a conflicting collection among all 11-vertex triangulations and 11-vertex stacked triangulations, respectively. To save some computation time, we provide the filtered list in the files data/triangulations/n11_after_phase2.bin.zip and n11_after_phase4.bin.zip. The list of all (stacked) triangulations is provided in the files n11_all_triangulations.txt and n11_all_stacked_triangulations.txt.
A more detailed description is provided in Appendix A. The source codes of our programs and relevant data are available on the companion website [Sch].

Universal Sets for 4-Connected Graphs
For n ≤ 10, examples of n-universal sets of n points for planar n-vertex graphs were already given in [CHK15]. To provide n-universal sets for 4-connected planar graphs for n = 11, . . . , 17, we slightly adopted our framework. Again, we enumerated 4-connected planar triangulations using the plantri graph generator, and using our C++ implementation, tested for universality. Our idea to find the proposed point sets for n = 11, . . . , 17 was to start with an (n − 1)-universal set of n − 1 points and insert an n-th point in all possible ways (cf. Section 4.1). The abstract order types obtained in this way -if they turned out to be universal -were then realized as point sets using the framework pyotlib 4 . The obtained sets are given in Listing 3.
It is also worth to note that the numbers of 4-connected triangulations for n = 11, . . . , 20 are 25; 87; 313; 1,357; 6,244; 30,926; 158,428; 836,749; 4,504,607; 24,649,284 (cf. OEIS/A7021). Hence, even if a universal point set is known, it is getting more and more time consuming to verify n-universality as n gets larger (at least using our SAT solver approach).

Discussion
In Section 3, we provided an improved lower bound for f p (n) and f s (n). However, the best known general upper bounds remain far from linear.
In Section 4, we have applied the ideas from Phases 2 and 3 twice (cf. Phases 4 and 5) to reduce the size of a conflict collection. One could further proceed with this strategy to find even smaller conflict collections (if such exist). Also one could simply test whether all elements from the conflict collection are indeed necessary, or whether certain elements can be removed. Note that, to compute a minimal conflict collection for n = 11, one could theoretically check which graphs admit an embedding on which point set and then find a minimal set cover as described in Phase 3 (Section 4). In practice, however, formulating such a minimal set cover instance (as integer program) is not reasonable because testing the embeddability of every graph in every point set would be an extremely time consuming task. (Recall that we used a priority queue to speed up our computation, so only a few pairs were actually tested. Also recall that, to generate the set cover instances, we only looked at a comparably small number of order types.) And even if such an instance was formulated, due to its size, the IP/set cover might not be solvable optimally in reasonable time.
Besides the computations for n = 11 points, we also adopted our program to find all nuniversal order types on n points for every n ≤ 10, and hence could verify the results from [CHK15, Table 1]. To be precise, we found 5,956 9-universal abstract order types on n = 9 points, whereas only 5,955 are realizable as point sets. It is worth to note that there is exactly one non-realizable abstract order type on 9 points in the projective plane, which is dual to the simple non-Pappus arrangement, and that all abstract order types on n ≤ 8 points are realizable. Besides the already known 2,072 realizable order types on 10 points, no further nonrealizable 10-universal abstract order types were found. For more details on realizability see for example [Kra03] or [FG18].
Unfortunately, we do not have an argument for subsets/supersets of n-universal point sets, and thus the question for n = 12, 13, 14 remains open. However, based on computational evidence (see also [CHK15, Table 1]), we strongly conjecture that no n-universal set of n points exists for n ≥ 11.

A Detailed Description of Tools
In following we give a detailed description of the tools which are required to verify the proof of Theorem 2. Moreover, we exemplify how the tools can be used. Even though our C++ code is platform-independent, we assume that the reader uses a Unix/Linux operating system and only give usage examples for this particular setup. (We ran our experiments in Fedora 27 and openSUSE 15.) A.1 Enumerating Abstract Order Types extend order type We provide a C++ program extend_order_type which reads all abstract order types on a fixed number of points n from the input file, extends it in all possible ways, and writes all so-obtained abstract order types on n + 1 points to an output file (without duplicates). The program (see the folder cprogram/scripts/extend_order_type/) can be built using qmake 5 and make. The following bash command builds the program: $ qmake && make The File Format Concerning the file format, we have to explain a little more theory: An abstract order type can be encoded by its triple orientations Λ i,j,k ∈ {−1, 0, +1} for each 1 ≤ i, j, k ≤ n.
Since encoding this "big lambda matrix" uses a cubic amount of bits, it is more efficient to encode the "small lambda matrix", which has the following entries: Diagonal elements λ i,i are omitted (or can be set to zero). This data structure was first introduced by Goodman and Pollack [GP83]. Small lambda matrices of (non-degenerated) abstract order types fulfill λ i,j + λ j,i = n − 2 (i.e., for each two fixed points i, j, any other point either lies on the left or on the right side of the directed line through i and j), hence only entries λ i,j with 1 ≤ i < j ≤ n need to be stored. Moreover, the first point can be assumed to lie on the boundary of the convex hull, and other points can be assumed to be sorted around the first point. Such a labeling of points is called "natural labeling" and yields Λ 1,i,j = + for 1 < i < j ≤ n and λ 1,j = j − 1 for all 1 < j ≤ n. Consequently, elements from the first row of the small lambda matrix need not to be stored.
Note that the lexicographically minimal small lambda matrix (over all labelings) -which we compute to distinguish different order types -is also naturally labeled.
For more information we again refer to the articles by Aurenhammer, Aichholzer, and Krasser [AAK02,AK06], and the dissertation of Krasser [Kra03].
Usage of the Program The program extend_order_type can be used as follows: .

/extend_order_type [n] [order types file] [parts] [from part] [to part]
The following describes the parameters.
• "n" is the number of points in the abstract order types from the input file, • "order types file" is the path to the input file, • "parts" is the number of threads in total, • "from part" is the id of the first thread to be run, and • "to part" is the id of the first thread not to be run.
The difference "to part"-"from part" is precisely the number of threads to be started on the local machine. As an example, to start a computation on 4 machines with 4 threads each (16 threads in total), one can simply run one of the following commands on each of the machines: . We also provide our python script create_jobs.py, which we used to automatically create job files for the parallel computations on the cluster.

Complete Enumeration
To generate all abstract order types, we start with a binary file n3_order_types.bin with content "0x00" (one byte) -this encodes the unique order type on 3 points, which is described by the small lambda matrix -0 1 1 -0* 0 1 -The entry λ 23 = 0, which is marked with a star (*), is the one entry which is actually encoded as "0x00" in the file. This file is also available in the folder data/order_types/.
The following command now enumerates all abstract order types on 4 points: Note that the command xxd displays a hex dump of the given file. The generated output file n3_order_types.bin.ext0_1.bin contains 6 bytes in total, encoding the two order types on 4 points (with 3 bytes each). The first three bytes encode the order type of 4 points in convex position, which has the following small lambda matrix: -0 1 2 2 -0* 1* 1 2 -0* 0 1 2 - The remaining three bytes encode the other order type of 4 points, which has a triangular convex hull and one interior point. Its small lambda matrix is the following: -0 1 2 2 -1* 0* 1 1 -1* 0 2 1 -When renaming the file n3_order_types.bin.ext0_1.bin to n4_order_types.bin, one can now analogously enumerate all order types of 5, 6, . . . points with ./extend_order_type 4 n4_order_types.bin 1 0 1 ./extend_order_type 5 n4_order_types.bin 1 0 1 ...
The script filter_3tree_relabel.sage is a slight modification of filter_3tree.sage, which relabels the vertices of the given graph in a way, such that the vertices 0, 1, and 2 span the initial triangle, and the k-th vertex is stacked into a triangular face of the subgraph induced by the vertices 0, 1, . . . , k − 1.
Note that the triangulations enumerated by plantri do not necessarily fulfill this property. The triangulations shown in Figures 2 and 3 (see also Listings 1 and 2) were relabed using filter_3tree_relabel.sage. The respective files are available in data/triangulations/.
Drawing Graphs Last but not least, we provide the script draw.sage which we used to automatically generate drawings for stacked triangulations; see Figures 2 and 3. The idea is to start with a Tutte embedding and then use global optimization heuristics (see https:// docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html) to optimize a certain quality function, which simultaneously maximizes edge lengths and vertex-edge distances.
A.3 Testing n-Universality test universal sets We provide a C++ program test_universal_sets to find n-universal point sets. The program (see the folder cprogram/scripts/test_universal_sets/) can be built analogously to extend_order_type (using qmake and make), except that Minisat is required to be build as a library first.
Building the Minisat Library As described in the README file delivered with Minisat (cf. cprogram/minisat-2.2.0, can also be downloaded from http://minisat.se/MiniSat. html), one needs to set the MROOT variable. This can be done for example with the following command:

$ export MROOT=$PWD
In the simp folder from Minisat, one then can run $ make lib_release.a How To Load Realizations from the Order Type Database To load files from the order type database [Aic], which provide point set realizations of all order types, one simply needs to change the line // #define REALIZATIONS to #define REALIZATIONS in the source file test_universal_sets.cpp. Note that in the binary files otypes04.b08, . . . , otypes08.b08 (available at [Aic]) each order type of n = 4, . . . , 8 points is encoded by one of its realizing point sets: the points (x 1 , y 1 ), . . . , (x n , y n ) are encoded as "x 1 y 1 . . . x n y n " using 1 byte per coordinate (values inbetween 0 and 255). For n = 9, n = 10, and n = 11, each coordinate is encoded using 2 bytes (values inbetween 0 and 65536).

A.4 Integer Programming
Gurobi Having Gurobi/Gurobipy installed (see Section 12 "Python Interface" from http: //www.gurobi.com/documentation/8.1/quickstart_linux.pdf), we have used the Python script test_min_cover.py to create a (Mixed) Integer Linear Programming instance from a stat-file (created from our C++ program). The script parses the input file, writes the instance to an "lp" file, and then starts the Gurobi solver to find an (optimal) solution. An instance, which is stored in an lp-file, can also be read and solved on a different machine for example via the following command: It is worth to note that, when solving an instance using Gurobi (also with CPLEX), the current upper and lower bound on the optimal value is printed to the console every few seconds. Moreover, when aborting the solving process (CTRL+C), the currently best solution is printed.
CPLEX An instance, which is stored in an lp-file, can be read and solved via the CPLEX Interactive Optimizer as exemplified in the following: For more information on free academic CPLEX versions, checkout http://www.ibm.com/ developerworks/community/blogs/jfp/entry/CPLEX_Is_Free_For_Students