10071461
Separation and approximation of polyhedral objects
Given a family of disjoint polygons P<subscrpt>1</subscrpt>, P<subscrpt>2</subscrpt>,…, P<subscrpt><italic>k</italic></subscrpt> in the plane, and an integer parameter <italic>m</italic>, it is <italic>NP</italic>-complete to decide if the <italic>P<subscrpt>i</subscrpt></italic>'s can be <italic>separated</italic> by a polygonal family consisting of <italic>m</italic> edges, that is, if there exist polygons <italic>R</italic><subscrpt>1</subscrpt>, <italic>R</italic><subscrpt>2</subscrpt>,…, <italic>R<subscrpt>k</subscrpt></italic> with pairwise-disjoint boundaries such that <italic>P<subscrpt>i</subscrpt></italic> *** <italic>R<subscrpt>i</subscrpt></italic> and &Sgr;|<italic>R<subscrpt>i</subscrpt></italic>| ≤ <italic>m</italic>. In three dimensions, the problem  of separating even two <italic>nested convex</italic> polyhedra by a <italic>k</italic>-facet polyhedron is <italic>NP</italic>-complete. Many other extensions and generalizations of the polyhedral separation problem, either to families of polyhedra or to higher dimensions, are also intractable.
In this paper, we present efficient approximation algorithms for constructing separating families of near-optimal size. Our main results are as follows. In two dimensions, we give an <italic>O</italic>(<italic>n</italic> log <italic>n</italic>) time algorithm for constructing a separating family whose size is within a constant factor of an optimal separating family; <italic>n</italic> is the number of edges in the input family of polygons. In three dimensions, we can separate a convex   polyhedron from a nonconvex polyhedron with a convex polyhedral surface whose <italic>facet-complexity</italic> is <italic>O</italic>(log <italic>n</italic>, times the optimal, where <italic>n</italic> = |<italic>P</italic>|+|<italic>Q</italic>| is the complexity of the input polyhedra. Our algorithm runs in <italic>O</italic>(<italic>n</italic><supscrpt>4</supscrpt>) time, but improves to <italic>O</italic> (<italic>n</italic><supscrpt>3</supscrpt>) time if the two polyhedra are nested and convex.
Our algorithm for separating a convex polyhedron from a nonconvex polyhedron extends to higher dimensions. In <italic>d</italic> dimensions, for <italic>d</italic> ≥ 4, the facet-complexity of the approximation polyhedron is <italic>O</italic>(<italic>d</italic> log   <italic>n</italic>) times the optimal, and the algorithm runs in <italic>O</italic>(<italic>n<supscrpt>d+1</subscrpt></italic>)time. Finally, we also obtain results on separating sets of points, a family of convex polyhedra, and separation by non-polyhedral surfaces, such as spherical patches.
57900050
Computational Geometry Column 42
A compendium of thirty previously published open problems in computational geometry is presented.
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.
16007270
Point Probe Decision Trees for Geometric Concept Classes
A fundamental problem in model-based computer vision is that of identifying to which of a given set of concept classes of geometric models an observed model belongs. Considering a “probe” to be an oracle that tells whether or not the observed model is present at a given point in an image, we study the problem of computing efficient strategies (“decision trees”) for probing an image, with the goal to minimize the number of probes necessary (in the worst case) to determine in which class the observed model belongs. We prove a hardness result and give strategies that obtain decision trees whose height is within a log factor of optimal.
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.
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.
17116402
Distributed credential chain discovery in trust management: extended abstract
We give goal-oriented algorithms for discovering credential chains in RTo, a role-based trust-management language introduced in this paper. The algorithms search credential graphs, a representation of RTo credentials. We prove that evaluation based on reachability in credential graphs is sound and complete with respect to the set-theoretic semantics of RTo . RTo is more expressive than SDSI 2.0, so our algorithms can perform chain discovery in SDSI 2.0, for which existing algorithms in the literature either are not goal-oriented or require using specialized logic-programming inferencing engines. Being goal-oriented enables our algorithms to be used when credential storage is distributed. We introduce a type system for credential storage that guarantees well-typed, distributed credential chains can be discovered.
10533033
On the Sequential Nature of Unification
Abstract The problem of unification of terms is log-space complete for P. In deriving this lower bound no use is made of the potentially concise representation of terms by directed acyclic graphs. In addition, the problem remains complete even if infinite substitutions are allowed. A consequence of this result is that parallelism cannot significantly improve on the best sequential solutions for unification. However, we show that for the problem of term matching, an important subcase of unification, there is a good parallel algorithm using O ( log 2 n ) time and n O(1) processors on a PRAM. For the O ( log 2 n ) parallel time upper bound we assume that the terms are represented by directed acyclic graphs; if the longer string representation is used we obtain an O ( log n ) parallel time bound.
42803318
File Servers
This chapter discusses file servers that are accessible via some form of local network or internetwork. It characterizes file services from the client point of view along a number of dimensions; distributivity of the service itself, the network environment of the service, the file model supported by the service, the kind(s) of atomic update provided by the service, the techniques used for controlling the allocation of files. It then describes the client interfaces to three existing file services. Finally, the impact of these features on design and implementation is discussed. An appendix contains characterizations of a variety of existing network-based file services using the criteria developed in the chapter.
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.
10705506
Linear logic proof games and optimization
§ 1. Introduction . Perhaps the most surprising recent development in complexity theory is the discovery that the class NP can be characterized using a form of randomized proof checker that only examines a constant number of bits of the “proof” that a string is in a language [6, 5, 31, 3, 4]. More specifically, writing ∣ x ∣ for the length of a string x , a language L in the class NP of languages recognizable in Nondeterministic polynomial time is traditionally given by a polynomial p and a polynomial-time predicate P such that a string x is in L iff there is some string y satisfying P (x, y), where ∣ y ∣ ≤ p (∣ x ∣). Intuitively, we can think of a string y as a possible proof that x ϵ L , with the predicate P some kind of proof checker that distinguishes good proofs from bad ones. A string x is therefore in a language L ϵ NP if there is a short proof that x ϵ L , and not in L otherwise. The surprising discovery is that the deterministic proof checker that reads the entire input and proof can be replaced by a probabilistic verifier that on input x and possible proof y , where y is presented in a certain way, flips at most O (log ∣ x ∣) coins and reads at most a constant number of bits of x and y . Obviously, a probabilistic verifier that does not read the whole proof will sometimes make mistakes. However, the surprising and essentially non-intuitive mathematical fact is that for each language L in NP, it is possible to find a polynomial q and verifier V flipping a logarithmic number of coins and reading a constant number of bits such that, for any x ϵ L , there exists y with ∣ y ∣ ≤ q(∣ x ∣) and with V (x, y) accepting with probability 1 and, for x ∉ L , there is no y with ∣ y ∣ ≤ q (∣ x ∣) and with V (x, y) accepting with probability ≥ 1/4. This idea canalsobeextended to PSPACE [10, 9], using a game that alternates between two players instead of a proof presented by a “single player.”