Exact Gift Wrapping to Prune the Tree of Edges of Newton Polytopes to Compute Pretropisms

Transcription

1 Exact Gift Wrapping to Prune the Tree of Edges of Newton Polytopes to Compute Pretropisms Jeff Sommars Jan Verschelde University of Illinois at Chicago Department of Mathematics, Statistics, and Computer Science 851 South Morgan (M/C 249), Chicago, IL , USA Abstract Pretropisms are candidates for the leading exponents of Puiseux series that represent solutions of polynomial systems. To find pretropisms, we propose an exact gift wrapping algorithm to prune the tree of edges of a tuple of Newton polytopes. We prefer exact arithmetic not only because of the exact input and the degrees of the output, but because of the often unpredictable growth of the coordinates in the face normals, even for polytopes in generic position. We provide experimental results with our preliminary implementation in Sage that compare favorably with the pruning method that relies only on cone intersections. Key words and phrases. exact, gift wrapping, Newton polytope, pretropism, tree pruning. 1 Introduction The input to our problem is a tuple of polytopes spanned by points with integer coordinates. Such polytopes occur regularly in algebraic geometry as Newton polytopes. The Newton polytope of a polynomial in several variables is the convex hull of the exponent tuples of those monomials that appear in the polynomial with a nonzero coefficient. Tuples of Newton polytopes arise from systems of polynomial equations in several variables. Given a tuple of Newton polytopes, our problem is to compute all pretropisms. A pretropism for a tuple of polytopes is a vector that makes the minimal inner product with at least an edge of every polytope. In particular, every pretropism defines a perpendicular hyperplane that touches all polytopes in the tuple at an edge or at a higher dimensional face of each polytope. In the special case where all polytopes in the tuple are the same, the pretropisms are recovered from the output of a convex hull algorithm. Therefore, we assume that the polytopes in the input tuple are all distinct from each other. Our motivation for the calculation of all pretropisms stems from the application of concepts of tropical algebraic geometry [23] to develop polyhedral methods to solve polynomial systems. This material is based upon work supported by the National Science Foundation under Grant No sommars1@uic.edu, URL: sommars janv@uic.edu, URL: jan 1

2 A tropism is the vector of leading exponents in a Puiseux series expansion [34] for an algebraic curve. Every tropism is a pretropism, but whether a pretropism is a tropism may depend on the particular choices of the coefficients of the polynomial system. A straightforward algorithm to compute all pretropisms is to consider the product of all edges of the polytopes in the tuple. For each tuple in the product of all edges, we can compute the normal perpendicular to all edges and check whether this normal when oriented properly makes the minimal inner product at the edges in the tuple. The enumeration of all products is naturally organized as a tree, where the leaves of the first level are the edges of the first polytope in the tuple. The nodes at the next level are pairs of edges, the first edge from the first polytope and the second edge of the second polytope. The leaves of this tree are tuples of edges, where the i-th element of the tuple is an edge of the i-th polytope. Traversing the entire tree will give all pretropisms; however, the ratio of the number of pretropisms over the number of leaves in this tree tends to become very small as the number of polytopes in the input of our problem increases. Therefore, we propose to prune the tree of all edge-edge combinations using the geometric tools provided by the gift wrapping algorithm [9, 12, 28, 31] to compute the convex hulls of polytopes. In [4], the gift wrapping algorithm is classified as a graph traversal algorithm. Because the growth of the coefficients in the output vectors may grow unpredictably larger than what is available in hardware floating-point arithmetic and our input problem is defined by exact data, we perform our computations with exact arithmetic. Our practical experimentations are done in Sage [30], using its modules for lattice polytopes [10] and polyhedral cones [27]. Cone intersections in Sage are computed by PPL [6]. 1.1 Related Work The problem considered in this paper is a generalization of the problem to compute the mixed volume of a tuple of Newton polytopes, for which pruning methods were first proposed in [14]. Further developments can be found in [19] and [26], with corresponding free software packages MixedVol [20] and DEMiCS [25]. A recent parallel implementation along with a complexity study appears in [24]. The relationship between triangulations and the mixed subdivisions is explained and nicely illustrated in [13]. The main difference between mixed volume computation and the computation of the tropical prevariety is that in a mixed volume computation the vertices of the polytopes are lifted at randomly, thus removing all degeneracies. This lifting gives the powers of an artificial parameter. In contrast, in a Puiseux series development of a space curve, the first variable is typically identified as the parameter and the powers of the first variable in the given polynomials cannot be considered as random. A practical study on various software packages for exact volume computation of a polytope is described in [11]. Exact algorithms on Newton polytopes are discussed in [17]. The authors of [15] present an experimental study of approximate polytope volume computation. In [16], a polynomial-time algorithm is presented to compute the edge skeleton of a polytope. Computing integer hulls of convex polytopes can be done with polymake [3]. A tropical prevariety was introduced in [8] and Gfan [22] is software to compute the common refinement of the normal fans of the Newton polytopes [35]. Gfan relies on the reverse search algorithms [5] and calls cddlib [18]. 2

3 1.2 Organization and Contribution of the Paper To gain a geometric intuition, the next section starts with a description of the algorithm in three dimensions. Section three considers the case of a space curve in n-space defined by n 1 Laurent polynomial equations, where variables may occur with negative exponents. Sections two and three define our new algorithms, and provide cost estimates on the effectiveness of the pruning. Computational experiments are in sections four and five, in particular at the end of section five where we compare our implementation with Gfan. Another contribution, in addition to the new algorithms, is our Sage code on github. 2 A Pair of Three Dimensional Polytopes in Generic Position To introduce our algorithm, we start with the case of looking for a space curve in three dimensions. The space curve is defined by two polynomials in three variables and the input to our problem is a tuple of two Newton polytopes. Excluding trivial cases, each polytope must have at least one edge. We say that the two polytopes are in generic position with each other if there is no pair of edges, one from each polytope, where the edges are parallel to each other. This generic position excludes the existence of a common two dimensional factor of the two given polynomials. We assume two polytopes and not three, because three polytopes in generic position can only have isolated solutions and no solution curves. Our algorithm takes as input a modified version of the data structure output by the gift wrapping algorithm. It conceptually exploits the connectivity between vertices, edges, and facets, but really only requires the edge skeleton of the polytope. To accomplish this, we used edge objects that had vertices, references to their neighboring edges, and the set of inner normals of all of the facets on which the edge rests. Algorithm 2 sketches the outline of the algorithm to compute all pretropisms of two polytopes in three dimensions. Along the lines of the gift wrapping algorithm, for every edge of the first polytope we take the plane that contains this edge and consider where this plane touches the second polytope. Algorithm 1 starts exploring the edge skeleton defined by the edges connected to the vertices in this touching plane. 3

4 Algorithm 1 Traverses the skeleton of edges of a polytope with respect to a cone. 1: function TraverseEdgeSkeleton(Polytope P, Cone C) 2: r := a random ray inside C 3: in r (P ) := vertices of P with minimal inner product with r 4: EdgesToTest := all edges of P that have vertices in in r (P ) 5: Edges := 6: EdgesToDiscard := 7: while EdgesToTest do 8: E := pop an edge from EdgesToTest 9: C E := normal cone to E 10: if C C E {0} then 11: Edges := Edges E 12: for each edge e that is a neighbor of E do 13: if e Edges and e EdgesToDiscard then 14: EdgesToTest := EdgesToTest e 15: end if 16: end for 17: else 18: EdgesToDiscard := EdgesToDiscard E 19: end if 20: end while 21: return Edges 22: end function The exploration of the neighboring edges corresponds to tilting the ray r, as in rotating a hyperplane in the gift wrapping method. For every edge E for which C C E {0}, the intersection C C E defines a pretropism. One may wonder why the exploration of the edge skeleton in Algorithm 1 could not stop after the statement on line 4. Figure 1 illustrates the justification for the length of Algorithm 1 with a simple Minkowski sum. Our problem is to compute those facets of the Minkowski sum that are spanned by one edge of each polytope. Because the emphasis in the description of Algorithm 1 is on the explanation of the control flow, the return type is kept simple. In the three dimensional case, the result of the cone intersection C C E is the same as C e1 C e2 in Algorithm 2. An optimization is for Algorithm 1 to return C C E as well. For three dimensional polytopes P 1 and P 2 in generic position, any pair of edges (e 1, e 2 ), e 1 of P 1 and e 2 of P 2 that defines a unique ray r C e1 C e2, r 0, we have that: if r would be normal to a hyperplane through a facet of P 1 or P 2, the extra point that spans the facet jointly with e 1 and/or e 2 would not have generic coordinates. In the Newton-Puiseux algorithm to compute series expansions, we are interested only in the edges on the lower hull of the Newton polytope, i.e. those edges that have an upward pointing inner normal. For Puiseux for space curves, the expansions are normalized so that the first exponent in the tropism is positive. Algorithm 2 is then easily adjusted so that calls to the edge 4

5 P2 P1 P 1 + P 2 Figure 1: The lower hull of a Minkowski sum P 1 + P 2 of P 1 and P 2. Consider P 1 in the plane, but P 2 in 3-space so the plot at the right is a projection of the lower hull of P 1 + P 2. With a ray in the normal cone to the edge P 2 we either pick up the leftmost or the rightmost point of P 1. In both cases, we miss the middle lower edge on P 1 which jointly with P 2 also spans a facet of the sum. Algorithm 2 3d generic pretropism algorithm. 1: function Pretropisms(Polytope P 1, Polytope P 2 ) 2: Pretropisms := 3: for each edge e 1 of P 1 do 4: C e1 := cone of inner normals to e 1 5: EdgeSet := TraverseEdgeSkeleton(P 2, C e1 ) 6: for every e 2 in EdgeSet do 7: C e2 := cone of inner normals to e 2 8: Pretropisms := Pretropisms (C e1 C e2 ) 9: end for 10: end for 11: return Pretropisms 12: end function skeleton computation of Algorithm 1 are made with rays that have a first component that is positive. 2.1 Correctness To see that the three dimensional generic algorithm is correct, we must define an additional term. A pretropism graph is the set of edges for a given polytope that have normal cones intersecting a given cone. We will now prove that this is the output of Algorithm 1. Lemma 2.1 Let P 1 and P 2 be three dimensional polytopes with e 1 an edge in P 1 and e 2, e 3 edges in P 2. Let C 2 be the cone of the intersection of the normal cones of e 1 and e 2, and let C 3 be the cone of the intersection of the normal cones of e 1 and e 3. Let dim(c 2 ) > 0 and dim(c 3 ) > 0. There exists a path between e 2 and e 3 that remains in the pretropism graph. Proof. Let n 2 be a normal to e 2 that is also in C 2 and let n 3 be a normal to e 3 that is also in C 3. Set n = tn 2 + (1 t)n 3 where 0 t 1. Consider varying t from 0 to 1; this creates the cone C n, a cone which must lie within the normal cone to e 1, as both n 1 and n 2 lie in that cone. If 5

6 we gift wrap around P 2, starting with the supporting hyperplane with normal n at t = 0, there will be some value of n that will represent the next time that the rotating hyperplane becomes a supporting hyperplane of P 2. This new hyperplane will either: 1. rest on an edge that shares a vertex with e 3 or 2. rest on a facet that has e 3 as an edge. In either case, e 3 is connected to the new face and every edge in the new face is also in the pretropism graph. By this method, we can iteratively construct a path. Every time we rotate the hyperplane, we find a new face that rests in the pretropism graph that is also connected to e 3. After some finite number of iterations, we will eventually rotate all the way to e 2. This constructs the path from e 2 to e 3. Theorem 2.2 Three dimensional pretropism graphs are connected graphs. Proof. From Lemma 2.1, we can conclude that from any edge in the pretropism graph we can create a path to any other edge in the pretropism graph where every element in the path is also in the pretropism graph. This demonstrates that the pretropism graph is connected. Once we find every pretropism graph of P 2 that corresponds to a ray from the normal cone to an edge e in P 1, we can intersect the normal cone to e with every normal cone in the pretropism graph. Each resulting cone is a pretropism. If we iterate over all edges in P 1, we will find all pretropisms. 2.2 Cost In estimating the cost of our algorithm to compute all pretropisms, we consider the following primitive operation. Given a pair of edges, decide whether the pair defines a pretropism and if so, compute the vector perpendicular to this pair of edges. For a polytope P, denote by n e (P ) its number of edges. The upper bound on the number of primitive operations for two polytopes P 1 and P 2 is the product n e (P 1 ) n e (P 2 ), while the lower bound equals the number of pretropisms. Denote by E P,e the pretropism graph resting on polytope P corresponding to the ray determined by edge e. Let n e (E P,e ) denote the number of edges in E P,e. Proposition 2.3 The number of primitive operations in Algorithm 2 on two polytopes P 1 and P 2 is bounded by n e(p 1 ) i=1 n e (E P2,e i ), where e i is the i-th edge of P 1. (1) As E P,e is a subset of the edges of P : n e (E P,e ) n e (P ). Therefore, the bound in (1) is smaller than n e (P 1 ) n e (P 2 ). To interpret (1), recall that Algorithm 2 takes a ray from inside a normal cone to a edge of the first polytope for the exploration of the edge graph of the second polytope. If we take a simplified 6

7 view on the second polytopes as a ball, then shining a ray on that ball will illuminate at most half of its surface. If we use the estimate: n e (E P2,e i ) n e (P 2 )/2, then Algorithm 2 cuts the the upper bound on the number of primitive operations in half. 3 An (n 1)-tuple of n Dimensional Polytopes in Generic Position Algorithm 3 outlines the computation of all pretropisms in dimension n, for a tuple of n 1 polytopes in generic position. The primitive operation in Algorithm 3 is the update C := C C e of the polyhedral cone C with the normal cone to an edge C e. The number of times this primitive is invoked is determined by the edge skeletons of the polytopes. Algorithm 3 n dimensional generic pretropism algorithm 1: function Pretropisms(Polytope P 1, Polytope P 2,..., Polytope P n 1 ) 2: Pretropisms := 3: procedure IntersectCones(i, n, Cone C) 4: if i = n then 5: Pretropisms := Pretropisms C 6: else 7: EdgeSet := TraverseEdgeSkeleton(P i, C) 8: for every e in EdgeSet do 9: C e := cone of the inner normals to e 10: C := C C e 11: if C {0} then 12: IntersectCones(i + 1, n, C) 13: end if 14: end for 15: end if 16: end procedure 17: for every edge e of P 1 do 18: C e := cone of the inner normals to e 19: IntersectCones(2, n, C e ) 20: end for 21: return Pretropisms 22: end function 3.1 Correctness Lemma 3.1 Let P 1 and P 2 be n dimensional polytopes with e 1 an edge in P 1 and e 2, e 3 edges in P 2. Let C 2 be the cone of the intersection of the normal cones of e 1 and e 2, and let C 3 be the cone of the intersection of the normal cones of e 1 and e 3. Let dim(c 2 ) > 0 and dim(c 3 ) > 0. There exists a path between e 2 and e 3 that remains in the pretropism graph. Proof. In Lemma 2.1, when we wrapped around P 2, we had only the possibilities of wrapping onto either an edge or a two dimensional face. In the n dimensional case, we wrap onto a n k 7

8 face where k {1, 2,..., n 1}. Whatever dimensional face that we wrap onto, we can continue to iterate the algorithm and construct a path just as in the style of Lemma 2.1. Theorem 3.2 Pretropism graphs are connected graphs. Proof. This follows from Lemma 3.1 in conjunction with the concept of Theorem Cost Estimating the cost of the n dimensional case follows naturally from the cost analysis of the 3 dimensional case. For n 1 polytopes, the upper bound on the number of primitive operations required is the product n e (P 1 ) n e (P 2 )... n e (P n 1 ). Proposition 3.3 The number of primitive operations in Algorithm 3 on n 1 polytopes P 1, P 2,..., P n 1 is bounded by n e(p 1 ) n 1 n e (E Pj,e i ), where e i is the i-th edge of P 1. (2) i=1 j=2 Again, if we use the estimate that n e (E Pj,e i ) n e (P j )/2, then Algorithm 2 reduces the upper bound on the number of primitive operations by 1 2 n 2. 4 Implementations and Computations We have written a prototype implementation of our algorithms in Sage [30], a computer algebra package which facilitates exact computations with lattice polytopes [10], [27]. Sage provides a module to work with rational polyhedral fans. In particular, the intersection of two cones given by their rays happens with a single command. In addition, Sage provides an interface to Gfan [22], which proved helpful in our testing. In this section we outline the methods that were implemented (experimental code available at Minkowski Sum and Cayley Embedding Given any convex hull method, we can extract all pretropisms from the facets of the Minkowski sum of the polytopes, or alternatively via the convex hull of the Cayley embedding. The main disadvantage of those two methods is that not all facets are of interest: only those facets spanned by at least two points of each polytope are pretropisms. While the Cayley embedding is conceptually nicer, the embedding in a higher dimensional space is an additional burden on the complexity and we observed that the Cayley embedding method is slower than the Minkowski sum method. The convex hulls computed for these versions were also computed using the gift wrapping algorithm. 8

9 4.2 Pruning with Plain Cone Intersections The intersection of cones is the main ingredient in the description of the algorithms to compute the tropical prevariety [8]. In this section we briefly describe our Sage implementation of this cone intersection algorithm to prune the tree of edge-edge combinations. Instead of considering all possible tuples of edges and intersection their normal cones, the pruning method proceeds as follows. For example, given three Newton polytopes P 1, P 2, and P 3 (of polynomials in four variables), if for a pair of edges of P 1 and P 2, the intersection of their normal comes is empty, then it is no longer necessary to intersect that pair with all cones normal to all the edges of P 3. This progressive way of pruning reduces drastically the number of cone intersections. 4.3 Gift Wrap Implementation The implementation of the gift wrapping algorithm to compute convex hull follows the text book description [28]. Because of concerns for possible numerical roundoff errors that would occur with wide ranges of values of the coordinates, all computations were performed in exact arithmetic in Sage, using Hermite normal forms for the coordinate transformations in the recursive dimension reductions. When the hyperplane rotates to wrap around the point set in the n-dimensional algorithm, the calculations leave Q and move to Q[ α 1, α 2,..., α i ] where α j N for some finite i Z. These calculations slow down the program, but they are a straightforward way to guarantee the correctness for any input. We begin the gift wrap pretropism algorithm implementation by first calling the aforementioned gift wrapping code on the support set of every input polynomial. We input the resulting convex hulls into the gift wrap pretropism algorithm and we compute the pretropisms as previously described. The algorithm outputs a list of lists where each sublist corresponds to a pretropism. 5 Computational Experiments To test the algorithms, we generate n 1 simplices spanned by integer points with coordinates uniformly generated within the range of 0 to 30. This input corresponds to considering systems of n 1 sparse Laurent polynomials in n variables with n + 1 monomials per equation. We can compare with the mixed volume computation if we add one extra linear equation to the Laurent polynomial system. Then the mixed volume of the n-tuple will give the sum of the degrees of all the curves represented by the Puiseux series. Assuming generic choices for the coefficients, the degrees of the curves can be computed directly from the tropisms, as used in [33] and applied in [1, 2]. Denoting by MV(P ) the mixed volume of an n-tuple P of Newton polytopes: MV(P ) = ( ( )) n n max v i min min v i, 0 i=1 i=1 v (3) 9

10 where the sum ranges over all tropisms v. All computations were done on a 3.5 GHz Intel Core i5 processor in a imac Retina 5K, running version of Mac OS X, with 16 GB RAM. 5.1 Benchmarking Different Approaches Table 1 shows the comparisons between various methods of computing pretropisms. The Cayley trick is most expensive not only because of the embedding in a (2n 1)-dimensional space, but also because of the costly exact implementation of the gift wrapping algorithm. n Hulls Cayley Minkowski Cone New , , Table 1: Comparing the Cayley trick, Minkowski sum, pruning with plain cone intersections (Cone), and the new pruning method (New) for dimensions 3, 4, and 5. Times are in seconds. Observe that computing the convex hull (Hulls) takes more time than either pruning method. For dimensions five and larger, neither the Minkowski sum nor the Cayley embedding can compete with the pruning methods. Table 2 continues the comparisons in higher dimensions. The mixed volume was computed with the version of MixedVol [20], available in PHCpack [32] since version For systems with generic coefficients, the mixed volume equals the number of isolated solutions [7]. While a fast multicore workstation can compute millions of solutions, a true supercomputer will be needed in the case of billions of solutions. For larger dimensions, the new pruning method dominates the plain cone intersection method. 5.2 Output Size versus Input Size In this section we provide some experimental data on the relationship between the number of pretropisms (the size of the output) and the product of the number of edges (the size of the n Hulls Cone New #Pretropisms Mixed Volume , , ,305, , ,381, , ,878 2,097,221,068 Table 2: Comparisons between the cone and the new pruning methods, for dimensions 3 till 8. Timings are listed in seconds. 10

11 input). Unlike in the previous section, we generate random polytopes spanned by an variable number of edges. In three dimensions, the relation between the input and the output size seems linear, as can be seen from the top left of Figure 2. However, as can be seen in the rest of Figure 2, the relationship between the sizes of the input and the output no longer appears linear. Figure 2: The number of pretropisms versus the product of the number of edges on random samples in dimensions 3 and 4. While in three dimensions the output size seems linear in the input size, this is no longer the case in higher dimensions. Although the range of axes differs for each plot, it is the shape of the data that matters most. 5.3 Number of Cone Intersections Another way that the cone intersection algorithm can be compared to our new algorithm is through comparing the number of cone intersections required for each. Table 3 contains a comparison of these numbers. The cone intersection algorithm column contains precisely how many intersections are required in the simplicial case, while the new algorithm column contains the average number of cone intersections for a large number of trials. A large number of trials were performed at each dimension so we could conclude statistically if our mean number of intersections differed from the number of intersections required by the cone 11

12 intersection algorithm. To test this hypothesis, we performed t-tests using the statistical software package R [29]. At every dimension from 3 to 8, we were able to reject the null hypothesis that they had the same mean and we were able to conclude that the new algorithm has a lower mean number of intersections (p < for every test). We had estimated the cost to be an 1 improvement by a factor of, but experimentally we found a greater improvement as can be 2 n 1 seen in Table 3. n Cone New Predicted Ratio Actual Ratio , ,625 2, ,084,101 18, ,890, , ,364,164,096 1,150, Table 3: Average number of cone intersections required for each algorithm, comparing the pruning method that only does cone intersections (Cone) with our new algorithm. The second to last column contains the ratio predicted by our cost estimate (Proposition 6) and the actual ratio. 5.4 Comparison with Gfan Our new algorithm conceptually relies on the giftwrapping algorithm, but practically, any convex hull algorithm could be used. Because of this, we also implemented a version that used Sage s polyhedra module [10] instead of our own gift wrapping implementation. Using this compiled convex hull code led to large speed improvements for finding the convex hulls, which led to better overall performance. With this implementation, our code is competitive with Gfan. Table 4 contains timing comparisons, with input polynomials determined as they were previously determined; the timings in the Gfan column were obtained by running the current version 0.5 of Gfan [21]. n Gfan New , Table 4: Comparisons between Gfan and our implementation, for dimensions 3 through 8. Timings are listed in seconds. 12

13 6 Conclusion To compute all pretropisms of a Laurent polynomial system, we propose to exploit the connectivity of edge skeletons to prune the tree of combinations of edges of the tuple of Newton polytopes of the polynomials in the system. A first high level implementation in Sage provides practical evidence that shows that our new pruning method is better than the pruning method that only relies on cone intersections. References [1] D. Adrovic and J. Verschelde. Computing Puiseux series for algebraic surfaces. In J. van der Hoeven and M. van Hoeij, editors, Proceedings of the 37th International Symposium on Symbolic and Algebraic Computation (ISSAC 2012), pages ACM, [2] D. Adrovic and J. Verschelde. Polyhedral methods for space curves exploiting symmetry applied to the cyclic n-roots problem. In V.P. Gerdt, W. Koepf, E.W. Mayr, and E.V. Vorozhtsov, editors, Computer Algebra in Scientific Computing, 15th International Workshop, CASC 2013, Berlin, Germany, volume 8136 of Lecture Notes in Computer Science, pages 10 29, [3] B. Assarf, E. Gawrilow, K. Herr, M. Joswig, B. Lorenz, A. Paffenholz, and T. Rehn. Computing convex hulls and counting integer points with polymake. arxiv: v2. [4] D. Avis, D. Bremner, and R. Seidel. How good are convex hull algorithms? Computational Geometry, 7(5-6): , [5] D. Avis and K. Fukuda. A pivoting algorithm for convex hulls and vertex enumeration of arrangements and polyhedra. Discrete Comput. Geom., 8(3): , [6] R. Bagnara, P.M. Hill, and E. Zaffanella. The Parma Polyhedral Library: Toward a complete set of numerical abstractions for the analysis and verification of hardware and software systems. Science of Computer Programming, 72(1 2):3 21, [7] D.N. Bernshteǐn. The number of roots of a system of equations. Functional Anal. Appl., 9(3): , [8] T. Bogart, A.N. Jensen, D. Speyer, B. Sturmfels, and R.R. Thomas. Computing tropical varieties. Journal of Symbolic Computation, 42(1):54 73, [9] K.H. Borgwardt. Average complexity of a gift-wrapping algorithm for determining the convex hull of randomly given points. Discrete Comput. Geom., 17(1):79 109, [10] V. Braun and M. Hampton. polyhedra module of Sage. The Sage Development Team, [11] B. Büeler, A. Enge, and K. Fukuda. Exact volume computation for polytopes: a practical study. In G. Kalai and G.M. Ziegler, editors, Polytopes Combinatorics and Computation, volume 29 of DMV Seminar, pages Springer-Verlag,

14 [12] D.R. Chand and S.S. Kapur. An algorithm for convex polytopes. Journal of the Association for Computing Machinery, 17(1):78 86, [13] J.A. De Loera, J. Rambau, and F. Santos. Triangulations. Structures for Algorithms and Applications, volume 25 of Algorithms and Computation in Mathematics. Springer-Verlag, [14] I.Z. Emiris and J.F. Canny. Efficient incremental algorithms for the sparse resultant and the mixed volume. Journal of Symbolic Computation, 20(2): , [15] I.Z. Emiris and V. Fisikopoulos. Efficient random-walk methods for approximating polytope volume. In Proceedings of the thirtieth annual symposium on computational geometry (SoCG 14), pages ACM, [16] I.Z. Emiris, V. Fisikopoulos, and B. Gärtner. Efficient edge-skeleton computation for polytopes defined by oracles. Journal of Symbolic Computation, 73: , [17] I.Z. Emiris, V. Fisikopoulos, and C. Konaxis. Exact and approximate algorithms for resultant polytopes. In Proceedings of the 28th European Workshop on Computational Geometry (EuroCG12), [18] K. Fukuda and A. Prodon. Double description method revisited. In Selected papers from the 8th Franco-Japanese and 4th Franco-Chinese Conference on Combinatorics and Computer Science, volume 1120 of Lecture Notes in Computer Science, pages Springer-Verlag, [19] T. Gao and T.Y. Li. Mixed volume computation for semi-mixed systems. Discrete Comput. Geom., 29(2): , [20] T. Gao, T.Y. Li, and M. Wu. Algorithm 846: MixedVol: a software package for mixed-volume computation. ACM Trans. Math. Softw., 31(4): , [21] A.N. Jensen. Gfan, a software system for Gröbner fans and tropical varieties. Available at [22] A.N. Jensen. Computing Gröbner fans and tropical varieties in Gfan. In M.E. Stillman, N. Takayama, and J. Verschelde, editors, Software for Algebraic Geometry, volume 148 of The IMA Volumes in Mathematics and its Applications, pages Springer-Verlag, [23] D. Maclagan and B. Sturmfels. Introduction to Tropical Geometry, volume 161 of Graduate Studies in Mathematics. American Mathematical Society, [24] G. Malajovich. Computing mixed volume and all mixed cells in quermassintegral time. arxiv: v2. [25] T. Mizutani and A. Takeda. DEMiCs: a software package for computing the mixed volume via dynamic enumeration of all mixed cells. In M.E. Stillman, N. Takayama, and J. Verschelde, editors, Software for Algebraic Geometry, volume 148 of The IMA Volumes in Mathematics and Its Applications, pages Springer-Verlag,

15 [26] T. Mizutani, A. Takeda, and M. Kojima. Dynamic enumeration of all mixed cells. Discrete Comput. Geom., 37(3): , [27] A.Y. Novoseltsev. lattice polytope module of Sage. The Sage Development Team, [28] F. Preparata and M. Shamos. Computational Geometry. Texts and Monographs in Computer Science. Springer-Verlag, [29] R Development Core Team. R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria, ISBN [30] W. A. Stein et al. Sage Mathematics Software (Version 6.9). The Sage Development Team, [31] G. Swart. Finding the convex hull facet by facet. Journal of Algorithms, 6:17 48, [32] J. Verschelde. Algorithm 795: PHCpack: A general-purpose solver for polynomial systems by homotopy continuation. ACM Trans. Math. Softw., 25(2): , [33] J. Verschelde. Polyhedral methods in numerical algebraic geometry. In D.J. Bates, G. Besana, S. Di Rocco, and C.W. Wampler, editors, Interactions of Classical and Numerical Algebraic Geometry, volume 496 of Contemporary Mathematics, pages AMS, [34] R.J. Walker. Algebraic Curves. Princeton University Press, [35] G.M. Ziegler. Lectures on Polytopes, volume 152 of Graduate Texts in Mathematics. Springer- Verlag,