Showing papers in "Information & Computation in 1986"
TL;DR: The rotary ball valve includes a generally annular seal which is held in place by an edge anchored annular retainer which is oversized for the valve housing and on installation resides in a state of compression.
Abstract: We characterize the polynomial time computable queries as those expressible in relational calculus plus a least fixed point operator and a total ordering on the universe. We also show that even without the ordering one application of fixed point suffices to express any query expressible with several alternations of fixed point and negation. This proves that the fixed point query hierarchy suggested by Chandra and Harel collapses at the first fixed point level. It is also a general result showing that in finite model theory one application of fixed point suffices.
721 citations
TL;DR: It is shown that under the same representation, graph properties that are ordinarily NP-complete become complete for non-deterministic exponential time.
Abstract: Galperin and Wigderson (Inform. and Control 56 (1983), 183–198) showed that certain trivial graph properties become NP-complete when the graph is represented in a particular exponentially succinct way. We show that under the same representation, graph properties that are ordinarily NP-complete become complete for non-deterministic exponential time.
203 citations
TL;DR: In the pure lambda calculus, run-time errors can occur if constants are used improperly, for example, if an at tempt is made to apply a natural number as if it were a function or if the first argument of a conditional is not a truth value as mentioned in this paper.
Abstract: When constants are added to the pure lambda calculus, run-time errors can occur if the constants are used improperly, for example, if an at tempt is made to apply a natural number as if it were a function or if the first argument of a conditional is not a truth value. We consider "types" as somehow being or generating constraints on expressions. A consistent type discipline ensures that any expression satisfying the constraints will not produce a "run-time error."
196 citations
TL;DR: The boundary NLC (BNLC) grammars as discussed by the authors are a generalization of node label controlled (NLC) graphs, which define languages of undirected node labeled graphs (or, if we just omit the labels, languages of unlabeled graphs).
Abstract: Node label controlled (NLC) grammars are graph grammars (operating on node labeled undirected graphs) which rewrite single nodes only and establish connections between the embedded graph and the neighbors of the rewritten node on the basis of the labels of the involved nodes only. They define (possibly infinite) languages of undirected node labeled graphs (or, if we just omit the labels, languages of unlabeled graphs). Here we consider a restriction of NLC grammars, so-called boundary NLC (BNLC) grammars , distinguished by the property that whenever in a graph already generated two nodes may be rewritten, then these nodes are not adjacent. The graph languages generated by this type of grammars are called BNLC languages . Although we show that this restriction leads to a smaller class of languages, still enough generative power remains to define interesting graph languages. For example, trees, complete bipartite graphs, maximal outerplanar graphs, k -trees, graphs of bandwidth ⩽ k , graphs of cyclic bandwidth ⩽ k , graphs of binary tree bandwidth ⩽ k , graphs of cutwidth ⩽ k (always for a fixed positive integer k ) turn out all to be BNLC languages. We prove a number of normal forms for BNLC grammars and then we indicate their usefulness by various applications. In particular, we show that for connected graphs of bounded degree the membership problem for BNLC languages is solvable in deterministic polynomial time.
151 citations
TL;DR: This paper describes an O(n)-time algorithm for recognizing and sorting Jordan sequences that uses level-linked search trees and a reduction of the recognition and sorting problem to a list-splitting problem.
Abstract: For a Jordan curve C in the plane nowhere tangent to the x axis, let x1, x2,…, xn be the abscissas of the intersection points of C with the x axis, listed in the order the points occur on C. We call x1, x2,…, xn a Jordan sequence. In this paper we describe an O(n)-time algorithm for recognizing and sorting Jordan sequences. The problem of sorting such sequences arises in computational geometry and computational geography. Our algorithm is based on a reduction of the recognition and sorting problem to a list-splitting problem. To solve the list-splitting problem we use level-linked search trees.
129 citations
TL;DR: Every infinite sequence is Turing-reducible to an infinite sequence which is random in the sense of Martin-Lof.
Abstract: Every infinite sequence is Turing-reducible to an infinite sequence which is random in the sense of Martin-Lof.
120 citations
TL;DR: The no-information interpretation of null values is adopted, and three types of constraints on null values are taken into account, and the interaction of each of them with functional dependencies is studied.
Abstract: Database relations with incomplete information are considered. The no-information interpretation of null values is adopted, due to its characteristics of generality and naturalness. Coherently with the framework and its motivation, two meaningful classes of integrity constraints are studied: (a) functional dependencies, which have been widely investigated in the classical relational theory and (b) constraints on null values, which control the presence of nulls in the relations. Specifically, three types of constraints on null values are taken into account (nullfree subschemes, existence constraints, disjunctive existence constraints), and the interaction of each of them with functional dependencies is studied. In each of the three cases, the inference problem is solved, the complexity of the algorithms for its solution analyzed, and the existence of a complete axiomatization discussed.
101 citations
TL;DR: Families of parallel algorithms that solve the string matching problem with inputs of size n and have the following performance in terms of p, t and n are designed.
Abstract: Let WRAM [PRAM]be a parallel computer with p processors (RAMs) which share a common memory and are allowed simultaneous reads and writes [only simultaneous reads]. The only type of simultaneous writes allowed is a simultaneous AND: a subset of the processors may write 0 simultaneously into the same memory cell. Let t be the time bound of the computer. We design below families of parallel algorithms that solve the string matching problem with inputs of size n ( n is the sum of lengths of the pattern and the text) and have the following performance in terms of p, t and n : (1) For WRAM: pt = O ( n ) for p ⩽ n /log n (i.e., t ⩾ log n ). † (2) for PRAM: pt = O ( n ) for p ⩽ n /log 2 n (i.e., t ⩾ log 2 n ). (3) For WRAM: t = constant for p = n 1 + e and any e > 0. (4) For WRAM: t = O (log n /log log n ) for p = n . Similar families are also obtained for the problem of finding all initial palindromes of a given string.
101 citations
TL;DR: An oracle X is constructed such that the exponential complexity class Δ EP, X 2 equals the probabilistic class R(R( X )), which shows that it will be difficult to prove that Δ EP 2 is different from R( R), although it seems very unlikely that these two classes are equal.
Abstract: An oracle X is constructed such that the exponential complexity class Δ EP, X 2 equals the probabilistic class R(R( X )). This shows that it will be difficult to prove that Δ EP 2 is different from R(R), although it seems very unlikely that these two classes are equal. The result subsumes several known results about relativized computations: (i) the existence of relativized polynomial hierarchies extending two levels (Long, T., 1978, Dissertation, Purdue Univ., Lafayette, Ind.; Heller, H., 1984(a), SIAM J. Comput. 13 , 717–725; Heller, H., 1984(b), Math. Systems Theory 17 , 71–84); (ii) the existence of an oracle X such that BPP( X ) ⊄ Δ P,X 2 (Stockmeyer, L., 1983, “Proc. 15th STOC” pp. 118–126), (iii) the existence of an oracle X such that NP( X ) is polynomially Turing reducible to a sparse set (Wilson, C., 1983, “Proc. 24th FOCS,”, pp. 329–334; Immerman, N., and Mahaney, S., 1983, “Conference on Computational Complexity Theory,” Santa Barbara, March 21–25). The result shows possible inclusion relations for nonrelativized complexity classes and points out that certain results about probabilistic complexity classes and about polynomial size circuits cannot be improved unless methods are applied which do not relativize.
91 citations
TL;DR: It is shown that the presence of formulae expressing the future perfect enables one to prove that the expressiveness of the logic can be characterised by a notion of bisimulation on the generalised transition systems.
Abstract: The expressiveness of branching time tense (temporal) logics whose eventually operators are relativised to general paths into the future is investigated. These logics are interpreted in models obtained by generalising the usual notion of transition system to allow infinite transitions. It is shown that the presence of formulae expressing the future perfect enables one to prove that the expressiveness of the logic can be characterised by a notion of bisimulation on the generalised transition systems. The future perfect is obtained by adding a past tense operator to the language. Finally the power of various tense languages from the literature are investigated in this framework.
87 citations
TL;DR: A translation method of finite terms of CCS into formulas of a modal language representing their class of observational congruence is proposed, a first step towards the definition of amodal language with modalities expressing both possibility and inevitability and which is compatible with observational Congruence.
Abstract: We propose a translation method of finite terms of CCS into formulas of a modal language representing their class of observational congruence. For this purpose, we define a modal language and a function associating with any finite term of CCS a formula of the language, satisfied by the term. Furthermore, this function is such that two terms are congruent if and only if the corresponding formulas are equivalent. The translation method consists in associating with operations on terms (action, +) operations on the corresponding formulas. This work is a first step towards the definition of a modal language with modalities expressing both possibility and inevitability and which is compatible with observational congruence.
TL;DR: The logic obtained by adding the least-fixed-point operator to first-order logic is extended and the zero-one law proved, showing that the problem of deciding whether this proportion of models of φ approaches 1 is complete for exponential time and complete for double-exponential time if φ is unrestricted.
Abstract: The logic obtained by adding the least-fixed-point operator to first-order logic was proposed as a query language by Aho and Ullman (in “Proc. 6th ACM Sympos. on Principles of Programming Languages,” 1979, pp. 110–120) and has been studied, particularly in connection with finite models, by numerous authors. We extend to this logic, and to the logic containing the more powerful iterative-fixed-point operator, the zero-one law proved for first-order logic in ( Glebskii, Kogan, Liogonki, and Talanov (1969) , Kibernetika 2, 31–42; Fagin (1976) , J. Symbolic Logic 41, 50–58). For any sentence φ of the extend logic, the proportion of models of φ among all structures with universe {1,2,…, n} approaches 0 or 1 as n tends to infinity. We also show that the problem of deciding, for any φ, whether this proportion approaches 1 is complete for exponential time, if we consider only φ's with a fixed finite vocabulary (or vocabularies of bounded arity) and complete for double-exponential time if φ is unrestricted. In addition, we establish some related results.
TL;DR: By viewing level- n grammars as modeling recursive procedures on higher types the iterated pushdown automation thus provides an operational model for the run-time behavior of procedures defined by recursion on higher type which makes the results of this paper interesting not only from a language theoretical point of view.
Abstract: This paper gives an automata-theoretical characterization of the OI-hierarchy ( Damm (1982) , Engelfriet and Schmidt (1977) , Wand (1975) ). This hierarchy is generated by so-called level- n grammars which are natural generalizations from context free and macro grammars in that their nonterminals are treated as functionals of higher type, i.e., they are allowed to carry up to n levels of parameters. The automata model used for this characterization is the n -iterated pushdown automaton. Its characteristic feature is the storage structure which consists of a nesting of pushdowns up to nesting depth n . The equivalence proof is given constructively, its method is illustrated using examples. By viewing level- n grammars as modeling recursive procedures on higher types the iterated pushdown automation thus provides an operational model for the run-time behavior of procedures defined by recursion on higher types which makes the results of this paper interesting not only from a language theoretical point of view.
TL;DR: The following problem concerning any two finite state machines M and N that exchange messages via two 1-directional channels is considered, and some sufficient conditions for the problem to have a positive answer are discussed.
Abstract: We consider the following problem concerning any two finite state machines M and N that exchange messages via two 1-directional channels. “Is there a positive integer K such that the communication between M and N over K -capacity channels is guaranteed to progress indefinitely?” The problem is shown to be undecidable in general. For a practical class of communicating machines, the problem is shown to be decidable, and the decidability algorithm is polynomial. We also discuss some sufficient conditions for the problem to have a positive answer; these sufficient conditions can be checked for the given M and N in polynomial time. We apply the results to some practical protocols to show that their communications will progress indefinitely.
TL;DR: This paper presents techniques that result in O(√n) time algorithms for computing many properties and functions of an n-node forest stored in an √n × √ n mesh of processors.
Abstract: In this paper we present techniques that result in O ( n ) time algorithms for computing many properties and functions of an n -node forest stored in an n × n mesh of processors. Our algorithms include computing simple properties like the depth, the height, the number of descendents, the preorder (resp. postorder, inorder) number of every node, and a solution to the more complex problem of computing the Minimax value of a game tree. Our algorithms are asymptotically optimal since any nontrivial computation will require Ω ( n ) time on the mesh. All of our algorithms generalize to higher dimensional meshes.
TL;DR: An axiomatization of the notion of the complexity of inductive inference is developed and several results are presented which both resemble and contrast with results obtainable for the axiomatic computational complexity of recursive functions.
Abstract: The notion of the complexity of performing an inductive inference is defined. Some examples of the tradeoffs between the complexity of performing an inference and the accuracy of the inferred result are presented. An axiomatization of the notion of the complexity of inductive inference is developed and several results are presented which both resemble and contrast with results obtainable for the axiomatic computational complexity of recursive functions.
TL;DR: A circuit model with precisely the power of first- order logic is developed: a class of structures is first-order definable if and only if it can be recognized by a constant-depth polynomial-time sequence of such circuits.
Abstract: A function of boolean arguments is symmetric if its value depends solely on the number of l's among its arguments. In the first part of this paper we partially characterize those symmetric functions that can be computed by constant-depth polynomial-size sequences of boolean circuits, and discuss the complete characterization. (We treat both uniform and non-uniform sequences of circuits.) Our results imply that these circuits can compute functions that are not definable in first-order logic. In the second part of the paper we generalize from circuits computing symmetric functions to circuits recognizing first-order structures. By imposing fairly natural restrictions we develop a circuit model with precisely the power of first-order logic: a class of structures is first-order definable if and only if it can be recognized by a constant-depth polynomial-time sequence of such circuits. © 1986 Academic Press, Inc.
TL;DR: This work investigates “intensional” and extensional models (the distinction is similar to that between λ -algebras and (λ)-models) and proves completeness of higher type theories with regard to intensified models as well as existence of free intensional models.
Abstract: We discuss the mathematical foundations of specifications, theories, and models with higher types Higher type theories are presented by specifications either using the language of cartesian closure or a typed λ -calculus We prove equivalence of both the specification methods, the main result being the equivalence of cartesian closure and a typed λ -calculus Then we investigate “intensional” and extensional” models (the distinction is similar to that between λ -algebras and (λ)-models) We prove completeness of higher type theories with regard to intensional models as well as existence of free intensional models For extensional models we prove that completeness and existence of an initial models implies that the theory itself already is the initial model As a consequence intensional models seem to be better suited for the purposes of data type specification
TL;DR: It is shown that for k = Θ(n), Ω(n log n) is a lower bound to the running time of any algorithm for this problem, and exhibit two algorithms of distinctly different flavors.
Abstract: In this paper we study the problem of polygonal separation in the plane, ie, finding a convex polygon with minimum number k of sides separating two given finite point sets (k-separator), if it exists We show that for k = Θ(n), Ω(n log n) is a lower bound to the running time of any algorithm for this problem, and exhibit two algorithms of distinctly different flavors The first relies on an O(n log n)-time preprocessing task, which constructs the convex hull of the internal set and a nested star-shaped polygon determined by the external set; the k-separator is contained in the annulus between the boundaries of these two polygons and is constructed in additional linear time The second algorithm adapts the prune-and-search approach, and constructs, in each iteration, one side of the separator; its running time is O(kn), but the separator may have one more side than the minimum
TL;DR: A method utilizing families of hash functions is developed which permits priority queue operations to be implemented in constant worst case time provided that a size constraint is satisfied.
Abstract: The complexity of priority queue operations is analyzed with respect to the cell probe computational model of A. Yao ( J. Assoc. Comput. Mach. 28 , No. 3 (1981), 615–628). A method utilizing families of hash functions is developed which permits priority queue operations to be implemented in constant worst-case time provided that a size constraint is satisfied. The minimum necessary size of a family of hash functions for computing the rank function is estimated and contrasted with the minimum size required for perfect hashing.
TL;DR: In this article, the worst-case space-time complexity of a large class of geometric retrieval problems has been shown to be O(n2 + e/log n, log n log(1/e) for arbitrary small e.
Abstract: A large class of geometric retrieval problems has the following form. Given a set X of geometric objects, preprocess to obtain a data structure D(X). Now use D(X) to rapidly answer queries on X. We say an algorithm for such a problem has (worst-case) space-time complexity O(f(n), g(n)) if the space requirement for D(X) is O(f) and the “locate run-time” required for each retrieval is O(g). We show three techniques which can consistently be exploited in solving such problems. For instance, using our techniques, we obtain an O(n2 + e/log n, log n log(1/e)) space-time algorithm for the polygon retrieval problem, for arbitrarily small e, improving on the previous solution having complexity O(n7, log n).
TL;DR: A new and simple characterization of BPP is given, which allows a simple proof that BPP ⊆ ZPP NP, which strengthens the result of (Lautemann, Inform.
Abstract: The complexity class BPP (defined by Gill) contains problems that can be solved in polynomial time with bounded error probability. A new and simple characterization of BPP is given. It is shown that a language L is in BPP iff ( x ∈ L → ∃ + y ∀ zP ( x , y , z )) ∧ ( x ∉ L → ∀ y ∃ + z ¬ P ( x , y , z )) for a polynomial-time predicate P and for | y |, | z | ⩽ poly (| x |). The formula ∃ + yP ( y ) with the random quantifier ∃ + means that the probability Pr({ y | P ( y )}) ⩾+ ɛ for a fixed ɛ. This characterization allows a simple proof that BPP ⊆ ZPP NP , which strengthens the result of (Lautemann, Inform. Process. Lett. 17 (1983), 215–217; Sipser, in “Proceedings, 15th Annu. ACM Sympos. Theory of Comput.,” 1983, pp. 330–335) that BPP ⊆ Σ 2 p ∩ Π 2 p . Several other results about probabilistic classes can be proved using similar techniques, e.g., NP R ⊆ ZPP NP and Σ 2 p ,BPP = Σ 2 p .
TL;DR: A sound and under some conditions complete deductive system for synchronization tree logics and their relation with modal logics used for the specification of programs is proposed.
Abstract: We present a logic, called Synchronization Tree Logic (STL), for the specification and proof of programs described in a simple term language obtained from a constant Nil by using a set A of unary operators, a binary operator + and recursion . The elements of A represent names of actions, + represents non-deterministic choice, and Nil is the program preforming no action. The language of formulas of the logic proposed, contains the term language used for the description of programs, i.e., programs are formulas of the logic. This provides a uniform frame to deal with programs and their properties as the verification of anassertion t ⊨ f ( t is a program, f is a formula) is reduced to the proof of the validity of the formula t ⊃ f . We propose a sound and under some conditions complete deductive system for synchronization tree logics and discuss their relation with modal logics used for the specification of programs.
TL;DR: A double-exponential lower bound is derived for the production length and cardinality of Church-Rosser commutative Thue systems, and the degree and Cardinality of Grobner bases.
Abstract: The complexity of the normal form algorithms which transform a given polynomial ideal basis into a Grobner basis or a given commutative Thue system into a Church-Rosser system is presently unknown. In this paper we derive a double-exponential lower bound (2 2 n C ) for the production length and cardinality of Church-Rosser commutative Thue systems, and the degree and cardinality of Grobner bases.
TL;DR: Two (closely-related) propositional probabilistic temporallogics based on temporal logics of branching time as introduced by Ben-Ari, Pnueli, and Manna are presented.
Abstract: We present two (closely-related) propositional probabilistic temporal logics based on temporal logics of branching time as introduced by Ben-Ari, Pnueli, and Manna (Acta Inform. 20 (1983), 207–226), Emerson and Halpern (“Proceedings, 14th ACM Sympos. Theory of Comput.,” 1982, pp. 169–179, and Emerson and Clarke (Sci. Comput. Program. 2 (1982), 241–266). The first logic, PTLf, is interpreted over finite models, while the second logic, PTLb, which is an extension of the first one, is interpreted over infinite models with transition probabilities bounded away from 0. The logic PTLf allows us to reason about finite-state sequential probabilistic programs, and the logic PTLb allows us to reason about (finite-state) concurrent probabilistic programs, without any explicit reference to the actual values of their state-transition probabilities. A generalization of the tableau method yields deterministic single-exponential time decision procedures for our logics, and complete axiomatizations of them are given. Several meta-results, including the absence of a finite-model property for PTLb, and the connection between satisfiable formulae of PTLb and finite state concurrent probabilistic programs, are also discussed.
TL;DR: This work gives an O(v2) algorithm for constructing a minimum rectangle cover, when the polygon is vertically convex, and gives a new proof of the minimum basis-maximum independent set duality theorem.
Abstract: Decomposing a polygon into simple shapes is a basic problem in computational geometry, with applications in pattern recognition and integrated circuit manufacture. Here we examine the special case of covering a rectilinear polygon (or polyomino) with the minimum number of rectangles, with overlapping allowed. The problem is NP-hard. However, we give here an O(v2) algorithm for constructing a minimum rectangle cover, when the polygon is vertically convex. (Here v is the number of vertices.) The problem is first reduced to a 1-dimensional interval “basis” problem. In showing our algorithm produces an optimal cover we give a new proof of a minimum basis-maximum independent set duality theorem first proved by E. Gyori (J. Combin Theory Ser. B 37, No. 1, 1–9).
TL;DR: It is proved that every language accepted by a two-way nondeterministic pushdown automaton can be recognized on a random access machine in O ( n 3 /log n ) time.
Abstract: We prove: 1) every language accepted by two-way nondeterministic pushdown automaton can be recognized on RAM in O(n3/log n) time; 2) every language accepted by two-way loop-free pushdown automaton can be recognized in O(n3/log2n) time; 3) every context-free language can be recognized on-line in O(n3/log2n) time. We improve the results of [1,7,4].
TL;DR: This paper investigates the circular retrieval problem and the k-nearest neighbor problem, for sets of n points in the Euclidean plane, and finds two similar data structures each solve both problems.
Abstract: This paper investigates the circular retrieval problem and the k-nearest neighbor problem, for sets of n points in the Euclidean plane. Two similar data structures each solve both problems. A deterministic structure uses space O(n(log n log log n)2), and a probabilistic structure uses space O(n log2 n). For both problems, these two structures answer a query that returns k points in O(k + log n) time.
TL;DR: The main results are that if P ≠ NP, then NP-complete problems have polynomially nonsparse cores recognizable in subexponential time, and that EXPTIME- complete problems have cores of exponential density recognizable in exponential time.
Abstract: Let A be a recursive problem not in P. Lynch has shown that A then has an infinite recursive polynomial complexity core. This is a collection C of instances of A such that every algorithm deciding A needs more than polynomial time almost everywhere on C. We investigate the complexity of recognizing the instances in such a core, and show that every recursive problem A not in P has an infinite core recognizable in subexponential time. We further study how dense the core sets for A can be, under various assumptions about the structure of A. Our main results in this direction are that if P ≠ NP, then NP-complete problems have polynomially nonsparse cores recognizable in subexponential time, and that EXPTIME-complete problems have cores of exponential density recognizable in exponential time.
TL;DR: A programming language IND that generalizes alternating Turing machines to arbitrary first-order structures and provides a natural query language for the set of fixpoint queries over a relational database is introduced.
Abstract: We introduce a programming language IND that generalizes alternating Turing machines to arbitrary first-order structures. We show that IND programs (respectively, everywhere-halting IND programs, loop-free IND programs) accept precisely the inductively definable (respectively, hyperelementary, elementary) relations. We give several examples showing how the language provides a robust and computational approach to the theory of first-order inductive definability. We then show: (1) on all acceptable structures (in the sense of Moschovakis [Mo]), r.e. Dynamic Logic is more expressive than finite-test Dynamic Logic. This refines a separation result of Meyer and Parikh [MP]; (2) IND provides a natural query language for the set of fixpoint queries over a relational database, answering a question of Chandra and Harel [CH2].