Search

Deterministic and nondeterministic finite automata (DFAs and NFAs) are abstract models of computation commonly taught in introductory computing theory courses. These models have important applications (such as fast regular expression matching), and are used to introduce formal language theory. Undergraduate students often struggle with understanding these models at first, due to the level of abstraction. As a result, various pedagogical tools have been developed to allow students to practice with these models. We introduce the FSM Builder, a new pedagogical tool enabling students to practice constructing DFAs and NFAs with a graphical editor, giving personalized feedback and partial credit. The algorithms used for generating these are heavily inspired by previous works. The key advantages to its competitors are greater flexibility and scalability. This is because the FSM Builder is implemented using efficient algorithms from an open source package, allowing for easy extension and question creation. We discuss the implementation of the tool, how it stands out from previous tools, and takeaways from experiences of using the tool in multiple large courses. Survey results indicate the interface and feedback provided by the tool were useful to students., Comment: 7 pages

We introduce a new model of indeterminacy in graphs: instead of specifying all the edges of the graph, the input contains all triples of vertices that form a connected subgraph. In general, different (labelled) graphs may have the same set of connected triples, making unique reconstruction of the original graph from the triples impossible. We identify some families of graphs (including triangle-free graphs) for which all graphs have a different set of connected triples. We also give algorithms that reconstruct a graph from a set of triples, and for testing if this reconstruction is unique. Finally, we study a possible extension of the model in which the subsets of size $k$ that induce a connected graph are given for larger (fixed) values of $k$., Comment: 20 pages including appendices

We present simpler algorithms for two closely related morphing problems, both based on the barycentric interpolation paradigm introduced by Floater and Gotsman, which is in turn based on Floater's asymmetric extension of Tutte's classical spring-embedding theorem. First, we give a much simpler algorithm to construct piecewise-linear morphs between planar straight-line graphs. Specifically, given isomorphic straight-line drawings $\Gamma_0$ and $\Gamma_1$ of the same 3-connected planar graph $G$, with the same convex outer face, we construct a morph from $\Gamma_0$ to $\Gamma_1$ that consists of $O(n)$ unidirectional morphing steps, in $O(n^{1+\omega/2})$ time. Our algorithm entirely avoids the classical edge-collapsing strategy dating back to Cairns; instead, in each morphing step, we interpolate the pair of weights associated with a single edge. Second, we describe a natural extension of barycentric interpolation to geodesic graphs on the flat torus. Barycentric interpolation cannot be applied directly in this setting, because the linear systems defining intermediate vertex positions are not necessarily solvable. We describe a simple scaling strategy that circumvents this issue. Computing the appropriate scaling requires $O(n^{\omega/2})$ time, after which we can can compute the drawing at any point in the morph in $O(n^{\omega/2})$ time. Our algorithm is considerably simpler than the recent algorithm of Chambers et al. (arXiv:2007.07927) and produces more natural morphs. Our techniques also yield a simple proof of a conjecture of Connelly et al. for geodesic torus triangulations., Comment: 19 pages, 5 figures. Previous version appeared in Proc. Graph Drawing 2021

We solve an open problem posed by Michael Biro at CCCG 2013 that was inspired by his and others' work on beacon-based routing. Consider a human and a puppy on a simple closed curve in the plane. The human can walk along the curve at bounded speed and change direction as desired. The puppy runs with unbounded speed along the curve as long as the Euclidean straight-line distance to the human is decreasing, so that it is always at a point on the curve where the distance is locally minimal. Assuming that the curve is smooth (with some mild genericity constraints) or a simple polygon, we prove that the human can always catch the puppy in finite time., Comment: Full version of a SOCG 2021 paper, 28 pages, 27 figures

We present the first algorithm to morph graphs on the torus. Given two isotopic essentially 3-connected embeddings of the same graph on the Euclidean flat torus, where the edges in both drawings are geodesics, our algorithm computes a continuous deformation from one drawing to the other, such that all edges are geodesics at all times. Previously even the existence of such a morph was not known. Our algorithm runs in $O(n^{1+\omega/2})$ time, where $\omega$ is the matrix multiplication exponent, and the computed morph consists of $O(n)$ parallel linear morphing steps. Existing techniques for morphing planar straight-line graphs do not immediately generalize to graphs on the torus; in particular, Cairns' original 1944 proof and its more recent improvements rely on the fact that every planar graph contains a vertex of degree at most 5. Our proof relies on a subtle geometric analysis of 6-regular triangulations of the torus. We also make heavy use of a natural extension of Tutte's spring embedding theorem to torus graphs., Comment: 30 pages, 18 figures

Inspired by a mathematical riddle involving fuses, we define the "fusible numbers" as follows: $0$ is fusible, and whenever $x,y$ are fusible with $|y-x|<1$, the number $(x+y+1)/2$ is also fusible. We prove that the set of fusible numbers, ordered by the usual order on $\mathbb R$, is well-ordered, with order type $\varepsilon_0$. Furthermore, we prove that the density of the fusible numbers along the real line grows at an incredibly fast rate: Letting $g(n)$ be the largest gap between consecutive fusible numbers in the interval $[n,\infty)$, we have $g(n)^{-1} \ge F_{\varepsilon_0}(n-c)$ for some constant $c$, where $F_\alpha$ denotes the fast-growing hierarchy. Finally, we derive some true statements that can be formulated but not proven in Peano Arithmetic, of a different flavor than previously known such statements: PA cannot prove the true statement "For every natural number $n$ there exists a smallest fusible number larger than $n$." Also, consider the algorithm "$M(x)$: if $x<0$ return $-x$, else return $M(x-M(x-1))/2$." Then $M$ terminates on real inputs, although PA cannot prove the statement "$M$ terminates on all natural inputs."

We consider three classes of geodesic embeddings of graphs on Euclidean flat tori: (1) A toroidal graph embedding $\Gamma$ is positive equilibrium if it is possible to place positive weights on the edges, such that the weighted edge vectors incident to each vertex of $\Gamma$ sum to zero. (2) A toroidal graph embedding $\Gamma$ is reciprocal if there is a geodesic embedding $\Gamma^*$ of its dual on the same flat torus, where each edge of $\Gamma$ is orthogonal to the corresponding dual edge in $\Gamma^*$. (3) A toroidal graph embedding $\Gamma$ is coherent if it is possible to assign weights to the vertices, so that $\Gamma$ is the (intrinsic) weighted Delaunay graph of its vertices. The classical Maxwell-Cremona correspondence and the well-known correspondence between convex hulls and weighted Delaunay triangulations imply that the analogous concepts for planar graph embeddings (with convex outer faces) are equivalent. Indeed, all three conditions are equivalent to $\Gamma$ being the projection of the 1-skeleton of the lower convex hull of points in $\mathbb{R}^3$. However, this three-way equivalence does not extend directly to geodesic graph embeddings on flat tori. On any flat torus, reciprocal and coherent embeddings are equivalent, and every reciprocal embedding is in positive equilibrium, but not every positive equilibrium embedding is reciprocal. We establish a weaker correspondence: Every positive equilibrium embedding on any flat torus is affinely equivalent to a reciprocal/coherent embedding on some flat torus., Comment: 25 pages, 6 figures. The correct title uses en-dashes (which arXiv does not support) instead of hyphens. Accepted to the Journal of Computational Geometry. Preliminary version appeared at SoCG 2020

We study algorithmic problems that belong to the complexity class of the existential theory of the reals (ER). A problem is ER-complete if it is as hard as the problem ETR and if it can be written as an ETR formula. Traditionally, these problems are studied in the real RAM, a model of computation that assumes that the storage and comparison of real-valued numbers can be done in constant space and time, with infinite precision. The complexity class ER is often called a real RAM analogue of NP, since the problem ETR can be viewed as the real-valued variant of SAT. In this paper we prove a real RAM analogue to the Cook-Levin theorem which shows that ER membership is equivalent to having a verification algorithm that runs in polynomial-time on a real RAM. This gives an easy proof of ER-membership, as verification algorithms on a real RAM are much more versatile than ETR-formulas. We use this result to construct a framework to study ER-complete problems under smoothed analysis. We show that for a wide class of ER-complete problems, its witness can be represented with logarithmic input-precision by using smoothed analysis on its real RAM verification algorithm. This shows in a formal way that the boundary between NP and ER (formed by inputs whose solution witness needs high input-precision) consists of contrived input. We apply our framework to well-studied ER-complete recognition problems which have the exponential bit phenomenon such as the recognition of realizable order types or the Steinitz problem in fixed dimension., Comment: 31 pages, 11 figures, FOCS 2020, SICOMP 2022

We describe algorithms to efficiently compute minimum $(s,t)$-cuts and global minimum cuts of undirected surface-embedded graphs. Given an edge-weighted undirected graph $G$ with $n$ vertices embedded on an orientable surface of genus $g$, our algorithms can solve either problem in $g^{O(g)} n \log \log n$ or $2^{O(g)} n \log n$ time, whichever is better. When $g$ is a constant, our $g^{O(g)} n \log \log n$ time algorithms match the best running times known for computing minimum cuts in planar graphs. Our algorithms for minimum cuts rely on reductions to the problem of finding a minimum-weight subgraph in a given $\mathbb{Z}_2$-homology class, and we give efficient algorithms for this latter problem as well. If $G$ is embedded on a surface with $b$ boundary components, these algorithms run in $(g + b)^{O(g + b)} n \log \log n$ and $2^{O(g + b)} n \log n$ time. We also prove that finding a minimum-weight subgraph homologous to a single input cycle is NP-hard, showing it is likely impossible to improve upon the exponential dependencies on $g$ for this latter problem., Comment: Unifies and improves upon contributions by different subsets of the authors that appeared in SoCG 2009, SODA 2011, and SODA 2012

We prove that the following problem has the same computational complexity as the existential theory of the reals: Given a generic self-intersecting closed curve $\gamma$ in the plane and an integer $m$, is there a polygon with $m$ vertices that is isotopic to $\gamma$? Our reduction implies implies two stronger results, as corollaries of similar results for pseudoline arrangements. First, there are isotopy classes in which every $m$-gon with integer coordinates requires $2^{\Omega(m)}$ bits of precision. Second, for any semi-algebraic set $V$, there is an integer $m$ and a closed curve $\gamma$ such that the space of all $m$-gons isotopic to $\gamma$ is homotopy equivalent to $V$., Comment: 17 pages, 10 figures (v2 fixes a utf8 encoding issue)

Let $G$ be a directed graph with $n$ vertices and $m$ edges, embedded on a surface $S$, possibly with boundary, with first Betti number $\beta$. We consider the complexity of finding closed directed walks in $G$ that are either contractible (trivial in homotopy) or bounding (trivial in integer homology) in $S$. Specifically, we describe algorithms to determine whether $G$ contains a simple contractible cycle in $O(n+m)$ time, or a contractible closed walk in $O(n+m)$ time, or a bounding closed walk in $O(\beta (n+m))$ time. Our algorithms rely on subtle relationships between strong connectivity in $G$ and in the dual graph $G^*$; our contractible-closed-walk algorithm also relies on a seminal topological result of Hass and Scott. We also prove that detecting simple bounding cycles is NP-hard. We also describe three polynomial-time algorithms to compute shortest contractible closed walks, depending on whether the fundamental group of the surface is free, abelian, or hyperbolic. A key step in our algorithm for hyperbolic surfaces is the construction of a context-free grammar with $O(g^2L^2)$ non-terminals that generates all contractible closed walks of length at most L, and only contractible closed walks, in a system of quads of genus $g\ge2$. Finally, we show that computing shortest simple contractible cycles, shortest simple bounding cycles, and shortest bounding closed walks are all NP-hard., Comment: 30 pages, 18 figures; fixed several minor bugs and added one figure. An extended abstraction of this paper will appear at SOCG 2019

Let $G$ be an edge-weighted directed graph with $n$ vertices embedded on an orientable surface of genus $g$. We describe a simple deterministic lexicographic perturbation scheme that guarantees uniqueness of minimum-cost flows and shortest paths in $G$. The perturbations take $O(gn)$ time to compute. We use our perturbation scheme in a black box manner to derive a deterministic $O(n \log \log n)$ time algorithm for minimum cut in \emph{directed} edge-weighted planar graphs and a deterministic $O(g^2 n \log n)$ time proprocessing scheme for the multiple-source shortest paths problem of computing a shortest path oracle for all vertices lying on a common face of a surface embedded graph. The latter result yields faster deterministic near-linear time algorithms for a variety of problems in constant genus surface embedded graphs. Finally, we open the black box in order to generalize a recent linear-time algorithm for multiple-source shortest paths in unweighted undirected planar graphs to work in arbitrary orientable surfaces. Our algorithm runs in $O(g^2 n \log g)$ time in this setting, and it can be used to give improved linear time algorithms for several problems in unweighted undirected surface embedded graphs of constant genus including the computation of minimum cuts, shortest topologically non-trivial cycles, and minimum homology bases., Comment: 29 pages, 2 figures, to appear at STOC 2018

We strengthen the connections between electrical transformations and homotopy from the planar setting---observed and studied since Steinitz---to arbitrary surfaces with punctures. As a result, we improve our earlier lower bound on the number of electrical transformations required to reduce an $n$-vertex graph on surface in the worst case [SOCG 2016] in two different directions. Our previous $\Omega(n^{3/2})$ lower bound applies only to facial electrical transformations on plane graphs with no terminals. First we provide a stronger $\Omega(n^2)$ lower bound when the planar graph has two or more terminals, which follows from a quadratic lower bound on the number of homotopy moves in the annulus. Our second result extends our earlier $\Omega(n^{3/2})$ lower bound to the wider class of planar electrical transformations, which preserve the planarity of the graph but may delete cycles that are not faces of the given embedding. This new lower bound follows from the observation that the defect of the medial graph of a planar graph is the same for all its planar embeddings., Comment: 23 pages, 11 figures. Conference version appears in SOCG 2019

We define a special case of tree decompositions for planar graphs that respect a given embedding of the graph. We study the analogous width of the resulting decomposition we call the embedded-width of a plane graph. We show both upper bounds and lower bounds for the embedded-width of a graph in terms of its treewidth and describe a fixed parameter tractable algorithm to calculate the embedded-width of a plane graph. To do so, we give novel bounds on the size of matchings in planar graphs.

Any generic closed curve in the plane can be transformed into a simple closed curve by a finite sequence of local transformations called homotopy moves. We prove that simplifying a planar closed curve with $n$ self-crossings requires $\Theta(n^{3/2})$ homotopy moves in the worst case. Our algorithm improves the best previous upper bound $O(n^2)$, which is already implicit in the classical work of Steinitz; the matching lower bound follows from the construction of closed curves with large defect, a topological invariant of generic closed curves introduced by Aicardi and Arnold. Our lower bound also implies that $\Omega(n^{3/2})$ facial electrical transformations are required to reduce any plane graph with treewidth $\Omega(\sqrt{n})$ to a single vertex, matching known upper bounds for rectangular and cylindrical grid graphs. More generally, we prove that transforming one immersion of $k$ circles with at most $n$ self-crossings into another requires $\Theta(n^{3/2} + nk + k^2)$ homotopy moves in the worst case. Finally, we prove that transforming one noncontractible closed curve to another on any orientable surface requires $\Omega(n^2)$ homotopy moves in the worst case; this lower bound is tight if the curve is homotopic to a simple closed curve., Comment: 29 pages, 26 figures. This paper improves and extends over some of the results from our earlier preprint "Electrical Reduction, Homotopy Moves, and Defect" (arXiv:1510.00571), as well as the preliminary version appeared in SoCG 2016

We present an $O(n\log n)$-time algorithm that determines whether a given planar $n$-gon is weakly simple. This improves upon an $O(n^2\log n)$-time algorithm by Chang, Erickson, and Xu (2015). Weakly simple polygons are required as input for several geometric algorithms. As such, how to recognize simple or weakly simple polygons is a fundamental question., Comment: 35 pages, 28 figures. A 15-page extended abstract has appeared in the Proceeding of the 32nd International Symposium on Computational Geometry (Boston, MA, 2016)

We prove the first nontrivial worst-case lower bounds for two closely related problems. First, $\Omega(n^{3/2})$ degree-1 reductions, series-parallel reductions, and $\Delta$Y transformations are required in the worst case to reduce an $n$-vertex plane graph to a single vertex or edge. The lower bound is achieved by any planar graph with treewidth $\Theta(\sqrt{n})$. Second, $\Omega(n^{3/2})$ homotopy moves are required in the worst case to reduce a closed curve in the plane with $n$ self-intersection points to a simple closed curve. For both problems, the best upper bound known is $O(n^2)$, and the only lower bound previously known was the trivial $\Omega(n)$. The first lower bound follows from the second using medial graph techniques ultimately due to Steinitz, together with more recent arguments of Noble and Welsh [J. Graph Theory 2000]. The lower bound on homotopy moves follows from an observation by Haiyashi et al. [J. Knot Theory Ramif. 2012] that the standard projections of certain torus knots have large defect, a topological invariant of generic closed curves introduced by Aicardi and Arnold. Finally, we prove that every closed curve in the plane with $n$ crossings has defect $O(n^{3/2})$, which implies that better lower bounds for our algorithmic problems will require different techniques., Comment: 27 pages, 15 figures

A closed curve in the plane is weakly simple if it is the limit (in the Fr\'echet metric) of a sequence of simple closed curves. We describe an algorithm to determine whether a closed walk of length n in a simple plane graph is weakly simple in O(n log n) time, improving an earlier O(n^3)-time algorithm of Cortese et al. [Discrete Math. 2009]. As an immediate corollary, we obtain the first efficient algorithm to determine whether an arbitrary n-vertex polygon is weakly simple; our algorithm runs in O(n^2 log n) time. We also describe algorithms that detect weak simplicity in O(n log n) time for two interesting classes of polygons. Finally, we discuss subtle errors in several previously published definitions of weak simplicity., Comment: 25 pages and 13 figures, submitted to SODA 2015

We present a near-optimal polynomial-time approximation algorithm for the asymmetric traveling salesman problem for graphs of bounded orientable or non-orientable genus. Our algorithm achieves an approximation factor of O(f(g)) on graphs with genus g, where f(n) is the best approximation factor achievable in polynomial time on arbitrary n-vertex graphs. In particular, the O(log(n)/loglog(n))-approximation algorithm for general graphs by Asadpour et al. [SODA 2010] immediately implies an O(log(g)/loglog(g))-approximation algorithm for genus-g graphs. Our result improves the O(sqrt(g)*log(g))-approximation algorithm of Oveis Gharan and Saberi [SODA 2011], which applies only to graphs with orientable genus g; ours is the first approximation algorithm for graphs with bounded non-orientable genus. Moreover, using recent progress on approximating the genus of a graph, our O(log(g) / loglog(g))-approximation can be implemented even without an embedding when the input graph has bounded degree. In contrast, the O(sqrt(g)*log(g))-approximation algorithm of Oveis Gharan and Saberi requires a genus-g embedding as part of the input. Finally, our techniques lead to a O(1)-approximation algorithm for ATSP on graphs of genus g, with running time 2^O(g)*n^O(1).

We give subquadratic algorithms that, given two necklaces each with n beads at arbitrary positions, compute the optimal rotation of the necklaces to best align the beads. Here alignment is measured according to the p norm of the vector of distances between pairs of beads from opposite necklaces in the best perfect matching. We show surprisingly different results for p = 1, p even, and p = \infty. For p even, we reduce the problem to standard convolution, while for p = \infty and p = 1, we reduce the problem to (min, +) convolution and (median, +) convolution. Then we solve the latter two convolution problems in subquadratic time, which are interesting results in their own right. These results shed some light on the classic sorting X + Y problem, because the convolutions can be viewed as computing order statistics on the antidiagonals of the X + Y matrix. All of our algorithms run in o(n^2) time, whereas the obvious algorithms for these problems run in \Theta(n^2) time.

Let G be a directed graph with n vertices and non-negative weights in its directed edges, embedded on a surface of genus g, and let f be an arbitrary face of G. We describe a randomized algorithm to preprocess the graph in O(gn log n) time with high probability, so that the shortest-path distance from any vertex on the boundary of f to any other vertex in G can be retrieved in O(log n) time. Our result directly generalizes the O(n log n)-time algorithm of Klein [SODA 2005] for multiple-source shortest paths in planar graphs. Intuitively, our preprocessing algorithm maintains a shortest-path tree as its source point moves continuously around the boundary of f. As an application of our algorithm, we describe algorithms to compute a shortest non-contractible or non-separating cycle in embedded, undirected graphs in O(g^2 n log n) time with high probability. Our high-probability time bounds hold in the worst-case for generic edge weights, or with an additional O(log n) factor for arbitrary edge weights., Comment: 31 pages, 3 figures. Accepted to SIAM Journal on Computing. Preliminary version, without the third author's contributions, in Proceedings of the 18th Annual ACM-SIAM Symposium on Discrete Algorithms, 89-97, 2007. In this revision we provide a careful treatment of non-generic weights

Fix a finite set of points in Euclidean $n$-space $\euc^n$, thought of as a point-cloud sampling of a certain domain $D\subset\euc^n$. The Rips complex is a combinatorial simplicial complex based on proximity of neighbors that serves as an easily-computed but high-dimensional approximation to the homotopy type of $D$. There is a natural ``shadow'' projection map from the Rips complex to $\euc^n$ that has as its image a more accurate $n$-dimensional approximation to the homotopy type of $D$. We demonstrate that this projection map is 1-connected for the planar case $n=2$. That is, for planar domains, the Rips complex accurately captures connectivity and fundamental group data. This implies that the fundamental group of a Rips complex for a planar point set is a free group. We show that, in contrast, introducing even a small amount of uncertainty in proximity detection leads to `quasi'-Rips complexes with nearly arbitrary fundamental groups. This topological noise can be mitigated by examining a pair of quasi-Rips complexes and using ideas from persistent topology. Finally, we show that the projection map does not preserve higher-order topological data for planar sets, nor does it preserve fundamental group data for point sets in dimension larger than three., Comment: 16 pages, 8 figures

We consider a class of geometric facility location problems in which the goal is to determine a set X of disks given by their centers (t_j) and radii (r_j) that cover a given set of demand points Y in the plane at the smallest possible cost. We consider cost functions of the form sum_j f(r_j), where f(r)=r^alpha is the cost of transmission to radius r. Special cases arise for alpha=1 (sum of radii) and alpha=2 (total area); power consumption models in wireless network design often use an exponent alpha>2. Different scenarios arise according to possible restrictions on the transmission centers t_j, which may be constrained to belong to a given discrete set or to lie on a line, etc. We obtain several new results, including (a) exact and approximation algorithms for selecting transmission points t_j on a given line in order to cover demand points Y in the plane; (b) approximation algorithms (and an algebraic intractability result) for selecting an optimal line on which to place transmission points to cover Y; (c) a proof of NP-hardness for a discrete set of transmission points in the plane and any fixed alpha>1; and (d) a polynomial-time approximation scheme for the problem of computing a minimum cost covering tour (MCCT), in which the total cost is a linear combination of the transmission cost for the set of disks and the length of a tour/path that connects the centers of the disks., Comment: 10 pages, 4 figures, Latex, to appear in ACM Symposium on Computational Geometry 2006

We prove that it is NP-complete to determine whether there exists a distance-2 edge coloring (strong edge coloring) with 5 colors of a bipartite 2-inductive graph with girth 6 and maximum degree 3., Comment: 3 pages, 1 figure in color

We consider the problem of cutting a set of edges on a polyhedral manifold surface, possibly with boundary, to obtain a single topological disk, minimizing either the total number of cut edges or their total length. We show that this problem is NP-hard, even for manifolds without boundary and for punctured spheres. We also describe an algorithm with running time n^{O(g+k)}, where n is the combinatorial complexity, g is the genus, and k is the number of boundary components of the input surface. Finally, we describe a greedy algorithm that outputs a O(log^2 g)-approximation of the minimum cut graph in O(g^2 n log n) time., Comment: 24 pages, 6 figures; full version of SOCG 2002 paper; see also http://www.cs.uiuc.edu/~jeffe/pubs/schema.html

We present an algorithm to construct meshes suitable for space-time discontinuous Galerkin finite-element methods. Our method generalizes and improves the `Tent Pitcher' algorithm of \"Ung\"or and Sheffer. Given an arbitrary simplicially meshed domain M of any dimension and a time interval [0,T], our algorithm builds a simplicial mesh of the space-time domain Mx[0,T], in constant time per element. Our algorithm avoids the limitations of previous methods by carefully adapting the durations of space-time elements to the local quality and feature size of the underlying space mesh., Comment: 12 pages, 14 figures; see also http://www.cs.uiuc.edu/~jeffe/pubs/slowpitch.html

We examine a computational geometric problem concerning the structure of polymers. We model a polymer as a polygonal chain in three dimensions. Each edge splits the polymer into two subchains, and a dihedral rotation rotates one of these chains rigidly about this edge. The problem is to determine, given a chain, an edge, and an angle of rotation, if the motion can be performed without causing the chain to self-intersect. An Omega(n log n) lower bound on the time complexity of this problem is known. We prove that preprocessing a chain of n edges and answering n dihedral rotation queries is 3SUM-hard, giving strong evidence that solving n queries requires Omega(n^2) time in the worst case. For dynamic queries, which also modify the chain if the requested dihedral rotation is feasible, we show that answering n queries is by itself 3SUM-hard, suggesting that sublinear query time is impossible after any amount of preprocessing., Comment: 11 pages, 9 figures, see also http://www.cs.uiuc.edu/~jeffe/pubs/dihedral.html

We present an algorithm to unfold any triangulated 2-manifold (in particular, any simplicial polyhedron) into a non-overlapping, connected planar layout in linear time. The manifold is cut only along its edges. The resulting layout is connected, but it may have a disconnected interior; the triangles are connected at vertices, but not necessarily joined along edges. We extend our algorithm to establish a similar result for simplicial manifolds of arbitrary dimension., Comment: 12 pages, 7 figures, 10 references. Significant improvement of arXive cs.CG/0107023

The spread of a finite set of points is the ratio between the longest and shortest pairwise distances. We prove that the Delaunay triangulation of any set of n points in R^3 with spread D has complexity O(D^3). This bound is tight in the worst case for all D = O(sqrt{n}). In particular, the Delaunay triangulation of any dense point set has linear complexity. We also generalize this upper bound to regular triangulations of k-ply systems of balls, unions of several dense point sets, and uniform samples of smooth surfaces. On the other hand, for any n and D=O(n), we construct a regular triangulation of complexity Omega(nD) whose n vertices have spread D., Comment: 31 pages, 11 figures. Full version of SODA 2002 paper. Also available at http://www.cs.uiuc.edu/~jeffe/pubs/screw.html

We define and examine flip operations for quadrilateral and hexahedral meshes, similar to the flipping transformations previously used in triangular and tetrahedral mesh generation., Comment: 20 pages, 24 figures. Expanded journal version of paper from 10th International Meshing Roundtable. This version removes some unwanted paragraph breaks from the previous version; the text is unchanged

We present two algorithms for unfolding the surface of any polyhedron, all of whose faces are triangles, to a nonoverlapping, connected planar layout. The surface is cut only along polyhedron edges. The layout is connected, but it may have a disconnected interior: the triangles are connected at vertices, but not necessarily joined along edges., Comment: 10 pages; 7 figures; 8 references

We construct, for any positive integer n, a family of n congruent convex polyhedra in R^3, such that every pair intersects in a common facet. Previously, the largest such family contained only eight polytopes. Our polyhedra are Voronoi regions of evenly distributed points on the helix (t, cos t, sin t). With a simple modification, we can ensure that each polyhedron in the family has a point, a line, and a plane of symmetry. We also generalize our construction to higher dimensions and introduce a new family of cyclic polytopes., Comment: 9 pages, 5 figures

We consider the complexity of Delaunay triangulations of sets of points in R^3 under certain practical geometric constraints. The spread of a set of points is the ratio between the longest and shortest pairwise distances. We show that in the worst case, the Delaunay triangulation of n points in R^3 with spread D has complexity Omega(min{D^3, nD, n^2}) and O(min{D^4, n^2}). For the case D = Theta(sqrt{n}), our lower bound construction consists of a uniform sample of a smooth convex surface with bounded curvature. We also construct a family of smooth connected surfaces such that the Delaunay triangulation of any good point sample has near-quadratic complexity., Comment: 11 pages, 8 figures, to appear in Proc. SCG '01

A flipturn is an operation that transforms a nonconvex simple polygon into another simple polygon, by rotating a concavity 180 degrees around the midpoint of its bounding convex hull edge. Joss and Shannon proved in 1973 that a sequence of flipturns eventually transforms any simple polygon into a convex polygon. This paper describes several new results about such flipturn sequences. We show that any orthogonal polygon is convexified after at most n-5 arbitrary flipturns, or at most 5(n-4)/6 well-chosen flipturns, improving the previously best upper bound of (n-1)!/2. We also show that any simple polygon can be convexified by at most n^2-4n+1 flipturns, generalizing earlier results of Ahn et al. These bounds depend critically on how degenerate cases are handled; we carefully explore several possibilities. We describe how to maintain both a simple polygon and its convex hull in O(log^4 n) time per flipturn, using a data structure of size O(n). We show that although flipturn sequences for the same polygon can have very different lengths, the shape and position of the final convex polygon is the same for all sequences and can be computed in O(n log n) time. Finally, we demonstrate that finding the longest convexifying flipturn sequence of a simple polygon is NP-hard., Comment: 26 pages, 32 figures, see also http://www.uiuc.edu/~jeffe/pubs/flipturn.html

We propose a hybrid image-space/object-space solution to the classical hidden surface removal problem: Given n disjoint triangles in Real^3 and p sample points (``pixels'') in the xy-plane, determine the first triangle directly behind each pixel. Our algorithm constructs the sampled visibility map of the triangles with respect to the pixels, which is the subset of the trapezoids in a trapezoidal decomposition of the analytic visibility map that contain at least one pixel. The sampled visibility map adapts to local changes in image complexity, and its complexity is bounded both by the number of pixels and by the complexity of the analytic visibility map. Our algorithm runs in time O(n^{1+e} + n^{2/3+e}t^{2/3} + p), where t is the output size and e is any positive constant. This is nearly optimal in the worst case and compares favorably with the best output-sensitive algorithms for both ray casting and analytic hidden surface removal. In the special case where the pixels form a regular grid, a sweepline variant of our algorithm runs in time O(n^{1+e} + n^{2/3+e}t^{2/3} + t log p), which is usually sublinear in the number of pixels., Comment: 10 pages, many figures; To appear in Proceedings of the 11th Annual ACM-SIAM Symposium on Discrete Algorithms, 2000; See also http://www.uiuc.edu/~jeffe/pubs/gridvis.html

We develop a class of new kinetic data structures for collision detection between moving convex polytopes; the performance of these structures is sensitive to the separation of the polytopes during their motion. For two convex polygons in the plane, let $D$ be the maximum diameter of the polygons, and let $s$ be the minimum distance between them during their motion. Our separation certificate changes $O(\log(D/s))$ times when the relative motion of the two polygons is a translation along a straight line or convex curve, $O(\sqrt{D/s})$ for translation along an algebraic trajectory, and $O(D/s)$ for algebraic rigid motion (translation and rotation). Each certificate update is performed in $O(\log(D/s))$ time. Variants of these data structures are also shown that exhibit \emph{hysteresis}---after a separation certificate fails, the new certificate cannot fail again until the objects have moved by some constant fraction of their current separation. We can then bound the number of events by the combinatorial size of a certain cover of the motion path by balls., Comment: 10 pages, 8 figures; to appear in Proc. 10th Annual ACM-SIAM Symposium on Discrete Algorithms, 1999; see also http://www.uiuc.edu/ph/www/jeffe/pubs/kollide.html ; v2 replaces submission with camera-ready version