1174606
Optimal covering tours with turn costs
We give the first algorithmic study of a class of “covering tour” problems related to the geometric Traveling Salesman Problem: Find a polygonal tour for a cutter so that it sweeps out a specified region (“pocket”), in order to minimize a cost that depends not only on the length of the tour but also on the number of turns. These problems arise naturally in manufacturing applications of computational geometry to automatic tool path generation and automatic inspection systems, as well as arc routing (“postman”) problems with turn penalties. We prove lower bounds (NP-completeness of minimum-turn milling) and give efficient approximation algorithms for several natural versions of the problem, including a polynomial-time approximation scheme based on a novel adaptation of the m-guillotine method.
11557966
An algorithmic study of manufacturing paperclips and other folded structures
We study algorithmic aspects of bending wires and sheet metal into a specified structure. Problems of this type are closely related to the question of deciding whether a simple non-self-intersecting wire structure (a carpenter's ruler) can be straightened, a problem that was open for several years and has only recently been solved in the affirmative. If we impose some of the constraints that are imposed by the manufacturing process, we obtain quite different results. In particular, we study the variant of the carpenter's ruler problem in which there is a restriction that only one joint can be modified at a time. For a linkage that does not self-intersect or self-touch, the recent results of Connelly et al. and Streinu imply that it can always be straightened, modifying one joint at a time. However, we show that for a linkage with even a single vertex degeneracy, it becomes NP-hard to decide if it can be straightened while altering only one joint at a time. If we add the restriction that each joint can be altered at most once, we show that the problem is NP-complete even without vertex degeneracies. In the special case, arising in wire forming manufacturing, that each joint can be altered at most once, and must be done sequentially from one or both ends of the linkage, we give an efficient algorithm to determine if a linkage can be straightened.
7753820
Approximate Geometric Pattern Matching Under Rigid Motions
We present techniques for matching point-sets in two and three dimensions under rigid-body transformations. We prove bounds on the worst-case performance of these algorithms to be within a small constant factor of optimal and conduct experiments to show that the average performance of these matching algorithms is often better than that predicted by the worst-case bounds.
57900050
Computational Geometry Column 42
A compendium of thirty previously published open problems in computational geometry is presented.
207132060
Terrain Decomposition and Layered Manufacturing
We consider a problem that arises in generating three-dimensional models by methods of layered manufacturing: How does one decompose a given model P into a small number of sub-models each of which is a terrain polyhedron? Terrain polyhedra have a base facet such that, for each point of the polyhedron, the line segment joining the point to its orthogonal projection on the base facet lies within the polyhedron. Terrain polyhedra are exactly the class of polyhedral models for which it is possible to construct the model using layered manufacturing (with layers parallel to the base facet), without the need for constructing "supports" (which must later be removed). In order to maximize the integrity of a prototype, one wants to minimize the number of individual sub-models that are manufactured and then glued together. We show that it is NP-hard to decide if a three-dimensional model P of genus 0 can be decomposed into k terrain polyhedra. We also prove a two-dimensional version of this theorem, for the case in which P is a polygonal region with holes. Both results still hold if we are restricted to isothetic objects and/or axis-parallel layering directions.
11133086
Query-sensitive ray shooting
Ray shooting is the problem of determining the first intersection of a ray with a set of obstacies. We assume that obstacles are modeled as polygons in the plane, or generally polyhedra in higher dimensions. Since many ray shooting queries may be applied to a given set of obstacles, it is desirable to preprocess the obstacles so that query processing is as efficient as possible. The problem of ray shooting in a simple polygon with n vertices haa been studied by [7, 6, 10]. In all cases, with linear space, ray shooting queries can be answered in O(log n) time. Ray shooting amidst a set of polygonal obstacles has been considered by [1, 6, 8, 10, 15]. In all these cases, space is within a polylogarithmic factor of linear, and the best query time is O(fi log n) query time. One of the shortcomings of these approaches is that they fail to account for the geometric structure of the obstacle set and query ray. Analyses based solely upon input size cannot account for the fact that, for a fixed in-
6372262
Algorithmic aspects of type inference with subtypes
We study the complexity of type inference for programming languages with subtypes. There are three language variations that effect the problem: (i) basic functions may have polymorphic or more limited types, (ii) the subtype hierarchy may be fixed or vary as a result of subtype declarations within a program, and (iii) the subtype hierarchy may be an arbitrary partial order or may have a more restricted form, such as a tree or lattice. The naive algorithm for infering a most general polymorphic type, undervariable subtype hypotheses, requires deterministic exponential time. If we fix the subtype ordering, this upper bound grows to nondeterministic exponential time. We show that it is NP-hard to decide whether a lambda term has a type with respect to a fixed subtype hierarchy (involving only atomic type names). This lower bound applies to monomorphic or polymorphic languages. We give PSPACE upper bounds for deciding polymorphic typability if the subtype hierarchy has a lattice structure or the subtype hierarchy varies arbitrarily. We also give a polynomial time algorithm for the limited case where there are of no function constants and the type hierarchy is either variable or any fixed lattice.
10944537
The Complexity of Local Proof Search in Linear Logic
Abstract Proof search in linear logic is known to be difficult: the provability of propositional linear logic formulas is undecidable. Even without the modalities, multiplicative-additive fragment of propositional linear logic, mall , is known to be PSPACE-complete, and the pure multiplicative fragment, mll , is known to be np -complete. However, this still leaves open the possibility that there might be proof search heuristics (perhaps involving randomization) that often lead to a proof if there is one, or always lead to something close to a proof. One approach to these problems is to study strategies for proof games. A class of linear logic proof games is developed, each with a numeric score that depends on the number of certain preferred axioms used in a complete or partial proof tree. Using recent techniques for proving lower bounds on optimization problems, the complexity of these games is analyzed for the fragment mll extended with additive constants and for the fragment MALL. It is shown that no efficient heuristics exist unless there is an unexpected collapse in the complexity hierarchy.
3062362
Managing Digital Rights using Linear Logic
Digital music players protect songs by enforcing licenses that convey specific rights for individual songs or groups of songs. For licenses specified in industry, we show that deciding whether a license authorizes a sequence of actions is NP-complete, with a restricted version of the problem solvable efficiently using a reduction to maximum network flow. The authorization algorithm used in industry is online, deciding which rights to exercise as actions occur, but we show that all online algorithms are necessarily non-monotonic: each allows actions under one license that it does not allow under a more flexible license. In one approach to achieving monotonicity, we exhibit the unique maximal set of licenses on which there exists a monotonic online algorithm. This set of well-behaved licenses induces an approximation algorithm by replacing each license with a well-behaved license. In a second approach, we consider allowing the player to revise its past decisions about which rights to exercise while still ensuring compliance with the license. We propose an efficient algorithm based on linear logic, with linear negation used to revise past decisions. We prove our algorithm monotonic, live, and sound with respect to the semantics of licenses
2148906
Type Inference With Simple Subtypes
ion clause, we use A -{x: σ} to denote the set difference, i.e., the type assignment defined by removing x: σ from A. G(x) = { s⊆t }, { x:s} ⊃ x:t G(MN) = let C1, A1 ⊃ M:σ = G(M) C2, A2 ⊃ N:τ = G(N), with type variables renamed to be disjoint from those in G(M) S = UNIFY({ α=β | x:α∈A1 and x:β∈A2} ∪ { σ=τ→t}) where t is a fresh type variable in SC1∪SC2∪{St⊆u}, SA1∪SA2 ⊃ MN:u where u is a fresh type variable G(λx.M) = let C, A ⊃ M:τ = G(M) in if x:σ∈A for someσ then C∪{ σ→τ⊆u}, (A -{x: σ}) ⊃ λx.M:u else C∪{s→τ⊆u}, A ⊃ λx.M:u, where s, u are fresh type variables The algorithm could concei vably fail in the application case if the call to UNIFY fails. Howev er, we will see that this does not happen. It is not to hard to pro ve that if G(M) succeeds, then it produces a pro vable typing for M. THEOREM 13. If G(M) = C,A ⊃ M:σ, then− C,A⊃ M:σ. It follows, by Lemma 11, that e v ry instance of G(M) is a pro vable typing for M. Conversely, every provable typing for M is an instance of G(M). THEOREM 14. Suppose− C,A ⊃ M:σ. Then G(M) succeeds and produces a typing with C,A⊃ M:σ as an instance. Both theorems are pro ved below. From Lemma 2, we kno w that every term has a pro vable CC typing. Therefore, Theorem 14 implies G(M) al ways succeeds.
15188207
RT: a Role-based Trust-management framework
The RT Role-based Trust-management framework provides policy language, semantics, deduction engine, and pragmatic features such as application domain specification documents that help distributed users maintain consistent use of policy terms. This paper provides a general overview of the framework, combining some aspects described in previous publications with recent improvements and explanation of motivating applications.