Showing papers in "Information & Computation in 1989"
TL;DR: In this article, it was shown that for self-reducible structures, almost uniform generation is possible in polynomial time provided only that randomised approximate counting to within some arbitrary polynomial factor is possible.
Abstract: The paper studies effective approximate solutions to combinatorial counting and uniform generation problems. Using a technique based on the simulation of ergodic Markov chains, it is shown that, for self-reducible structures, almost uniform generation is possible in polynomial time provided only that randomised approximate counting to within some arbitrary polynomial factor is possible in polynomial time. It follows that, for self-reducible structures, polynomial time randomised algorithms for counting to within factors of the form (1 +n-@) are available either for all fl E R or for no fi E R. A substantial part of the paper is devoted to investigating the rate of convergence of finite ergodic Markov chains, and a simple but powerful characterisation of rapid convergence for a broad class of chains based on a structural property of the underlying graph is established. Finally, the general techniques of the paper are used to derive an almost uniform generation procedure for labelled graphs with a given degree sequence which is valid over a much wider range of degrees than previous methods: this in turn leads to randomised approximate counting algorithms for these graphs with very good
767 citations
TL;DR: The use of Rissanen's minimum description length principle for the construction of decision trees is explored and empirical results comparing this approach to other methods are given.
Abstract: We explore the use of Rissanen's minimum description length principle for the construction of decision trees. Empirical results comparing this approach to other methods are given.
741 citations
TL;DR: In this paper, a lower bound of Ω ((1/∆)ln(1/δ)+VCdim(C )/ε) was shown for distribution-free learning of a concept class C, where VCdim( C ) is the Vapnik-Chervonenkis dimension and ǫ and à are the accuracy and confidence parameters.
Abstract: We prove a lower bound of Ω ((1/ɛ)ln(1/δ)+VCdim( C )/ɛ) on the number of random examples required for distribution-free learning of a concept class C , where VCdim( C ) is the Vapnik-Chervonenkis dimension and ɛ and δ are the accuracy and confidence parameters. This improves the previous best lower bound of Ω ((1/ɛ)ln(1/δ)+VCdim( C )) and comes close to the known general upper bound of O ((1/ɛ)ln(1/δ)+(VCdim( C )/ɛ)ln(1/ɛ)) for consistent algorithms. We show that for many interesting concept classes, including k CNF and k DNF, our bound is actually tight to within a constant factor.
410 citations
TL;DR: An elementary time decision procedure is given, using a reduction to the emptiness problem for automata on infinite trees, and a small model theorem is obtained as a corollary.
Abstract: The propositional mu-calculus is a propositional logic of programs which incorporates a least fixpoint operator and subsumes the propositional dynamic logic of Fischer and Ladner, the infinite looping construct of Streett, and the game logic of Parikh. We give an elementary time decision procedure, using a reduction to the emptiness problem for automata on infinite trees. A small model theorem is obtained as a corollary.
249 citations
TL;DR: A configuration of parallel multipliers for GF (2 m) based on irreducible AOPs and ESPs based on canonical bases is presented and it is shown a necessary and sufficient condition for ESPs to be irReducible over GF ( 2) and the uniqueness of the irredUCible ESPs overGF (2).
Abstract: This paper presents a configuration of parallel multipliers for GF (2 m ) based on canonical bases. The possible parallel multipliers by the proposed configuration are limited to a class of fields GF (2 m ). However they can be constructed by O(m 2 ) AND-gates and O(m 2 ) EOR-gates with the structural modularity (this is a desirable feature for the hardware implementation), and their operation time is about (log m ) T , where m is the dimension of GF (2 m ) and T is the delay time of an EOR-gate. In order to construct such parallel multipliers, we define two types of polynomials of special form over GF (2), one is called all one polynomial (denoted by AOP) and the other is called equally spaced polynomial (denoted by ESP). Furthermore, we show a necessary and sufficient condition for ESPs to be irreducible over GF (2) and the uniqueness of the irreducible ESPs over GF (2). Finally, we propose the configuration of parallel multipliers for a class of fields GF (2 m ) based on irreducible AOPs and ESPs over GF (2).
215 citations
199 citations
TL;DR: A complete axiomatisation for this congruence relation based upon the notion of weak bisimulation or observational equivalence due to Park and Milner is presented.
Abstract: Finite state automata, with non-determinism and silent transitions, can be interpreted not as subsets of the free monoid as in classical automata theory, but as congruence classes under a congruence relation based upon the notion of weak bisimulation or observational equivalence due to Park and Milner. In this paper a complete axiomatisation for this congruence is presented. It extends the previously known complete axiomatisation by Hennessy and Milner for the case when all computations are finite; the extension consists of five simple rules for recursion.
189 citations
TL;DR: In this article, the authors define the rank of a decision tree and show that for any fixed r, the class of all decision trees of rank at most r on n Boolean variables is learnable from random examples in time polynomial in n and linear in 1/ɛ and log(1/δ), where ɛ is the accuracy parameter and δ is the confidence parameter.
Abstract: We define the rank of a decision tree and show that for any fixed r , the class of all decision trees of rank at most r on n Boolean variables is learnable from random examples in time polynomial in n and linear in 1/ɛ and log(1/δ), where ɛ is the accuracy parameter and δ is the confidence parameter. Using a suitable encoding of variables, Rivest's polynomial learnability result for decision lists can be interpreted as a special case of this result for rank 1. As another corollary, we show that decision trees on n Boolean variables of size polynomial in n are learnable from random examples in time linear in n O (log n ) , 1/ɛ, and log(1/δ). As a third corollary, we show that Boolean functions that have polynomial size DNF expressions for both their positive and their negative instances are learnable from random examples in time linear in n O ((log n ) 2 ) , 1/ɛ, and log(1/δ).
177 citations
TL;DR: This work describes several approximation algorithms that produce solutions that are always within a factor of two of optimum with respect to the overlap measure of the shortest common superstring problem (SCS).
Abstract: The object of the shortest common superstring problem (SCS) is to find the shortest possible string that contains every string in a given set as substrings. As the problem is NP-complete, approximation algorithms are of interest. The value of an aproximate solution to SCS is normally taken to be its length, and we seek algorithms that make the length as small as possible. A different measure is given by the sum of the overlaps between consecutive strings in a candidate solution. When considering this measure, the object is to find solutions that make it as large as possible. These two measures offer different ways of viewing the problem. While the two viewpoints are equivalent with respect to optimal solutions, they differ with respect to approximate solutions. We describe several approximation algorithms that produce solutions that are always within a factor of two of optimum with respect to the overlap measure. We also describe an efficient implementation of one of these, using McCreight's compact suffix tree construction algorithm. The worstcase running time is O ( m log n ) for small alphabets, where m is the sum of the lengths of all the strings in the set and n is the number of strings. For large alphabets, the algorithm can be implemented in O ( m log m ) time by using Sleator and Tarjan's lexicographic splay tree data structure.
139 citations
TL;DR: Inductionless induction is adapted for proving the consistency property of an enrichment of a specification by new operators and new equations and an algorithm for deciding inductive reducibility is given for left linear term rewriting systems.
Abstract: Inductionless induction consists of using pure equational reasoning for proving the validity of an equation in the initial algebra of a set of equational axioms, which would normally require some kind of induction. Under given hypotheses, the equation is valid iff adding it to the set of axioms does not result in an inconsistency. This inconsistency can be found by the Knuth-Bendix completion algorithm, provided that the signature of the algebra is split into free constructors and defined symbols, which must be completely defined in terms of constructors. This is the base of the so-called inductive completion algorithm of Huet and Hullot. Two key concepts, inductive reducibility and inductive co-reducibility , allow us to extend these techniques in various directions: incomplete specifications, nonfree constructors, no constructors specified, equational term rewriting systems. The method is adapted for proving the consistency property of an enrichment of a specification by new operators and new equations. In addition, we get also a simple algorithm to exhibit a set of constructors of a specification. Finally, inductive co-reducibility is reduced to inductive reducibility and an algorithm for deciding inductive reducibility is given for left linear term rewriting systems.
125 citations
TL;DR: The authors use input/output automata to define a simple and general model of networks of concurrently executing, nondeterministic processes that communicate through undirectional, named ports, and it is shown that determinate processes compute continuous functions, and that networks of determinates obey Kahn's fixed-point principle.
Abstract: : The authors use input/output automata to define a simple and general model of networks of concurrently executing, nondeterministic processes that communicate through undirectional, named ports. A notion of the input/output relation computed by a process is defined, and determinate processes are defined to be processes whose input/output relations are single-valued. It is shown that determinate processes compute continuous functions, and that networks of determinate processes obey Kahn's fixed-point principle. Although these results are already known, our contribution lies in the fact that the input/output automata model yields extremely simple proofs of them (the simplest we have seen), in spite of its generality.
TL;DR: It is shown that the problem of computing the number of perfect matchings in K3,3-free graphs is in NC, and this opens up the possibility of obtaining an NC algorithm for finding a perfect matching in K2,2- free graphs.
Abstract: We show that the problem of computing the number of perfect matchings in K3,3-free graphs is in NC. This contrasts with the #P-completeness of counting the number of perfect matchings in arbitrary graphs. As corollaries we obtain NC algorithms for checking if a given K3,3-free graph has a perfect matching and if it has an EXACT MATCHING. Our result also opens up the possibility of obtaining an NC algorithm for finding a perfect matching in K3,3-free graphs.
TL;DR: A model-theoretic method is given for establishing the k -variable property, involving a restricted Ehrenfeucht-Fraisse game in which each player has only k pebbles, and it is shown that this gives the first finite basis theorems for branching-time models of temporal logic.
Abstract: A theory satisfies the k-variable property if every first-order formula is equivalent to a formula with at most k bound variables (possibly reused). Gabbay has shown that a model of temporal logic satisfies the k -variable property for some k if and only if there exists a finite basis for the temporal connectives over that model. We give a model-theoretic method for establishing the k -variable property, involving a restricted Ehrenfeucht-Fraisse game in which each player has only k pebbles. We use the method to unify and simplify results in the literature for linear orders. We also establish new k -variable properties for various theories of bounded-degree trees, and in each case obtain tight upper and lower bounds on k . This gives the first finite basis theorems for branching-time models of temporal logic.
TL;DR: It is hoped that by pin-pointing a key construction used in producing and describing models of Girard and Reynolds' polymorphic λ-calculus will help towards a deeper understanding of models for the polymorphic €calculus and the relations between them.
Abstract: We give an illustration of a construction useful in producing and describing models of Girard and Reynolds' polymorphic λ-calculus. The key unifying ideas are that of a Grothendieck fibration and the category of continuous sections associated with it, constructions used in indexed category theory; the universal types of the calculus are interpreted as the category of continuous sections of the fibration. As a major example a new model for the polymorphic λ-calculus is presented. In it a type is interpreted as a Scott domain. In fact, understanding universal types of the polymorphic λ-calculus as categories of continuous sections appears to be useful generally. For example, the technique also applies to the finitary projection model of Bruce and Longo, and a recent model of Girard. (Indeed the work here was inspired by Girard's and arose through trying to extend the construction of his model to Scott domains). It is hoped that by pin-pointing a key construction this paper will help towards a deeper understanding of models for the polymorphic λ-calculus and the relations between them.
TL;DR: A denotational model is presented for the language POOL, a parallel object-oriented language that is actually used to write programs for a parallel machine, and a new technique is developed to solve a wide class of such equations, including function space constructions.
Abstract: A denotational model is presented for the language POOL, a parallel object-oriented language. It is a syntactically simplified version of POOL-T, a language that is actually used to write programs for a parallel machine. The most important aspect of this language is that it describes a system as a collection of communicating objects that all have internal activities which are executed in parallel. To describe the semantics of this language we construct a mathematical domain of processes. This domain is obtained as a solution of a reflexive domain equation over a category of complete metric spaces. A new technique is developed to solve a wide class of such equations, including function space constructions. The desired domain is obtained as the fixed point of a contracting functor implicit in the equation. The domain is sufficiently rich to allow a fully compositional definition of the language constructs in POOL, including concepts such as object creation and method invocation by messages. The semantic equations give a meaning to each syntactic construct depending on the POOL object executing the construct, the environment constituted by the declarations, and a continuation, representing the actions to be performed after the execution of the current construct. After the process representing the execution of an entire program is constructed, a yield function can extract the set of possible execution sequences from it. A preliminary discussion is provided on how to deal with fairness. Full mathematical details are supplied, with the exception of the general domain construction, which is described elsewhere.
TL;DR: It is proved that if there is a good polynomial-time enumerator for #P (i.e., one where for every Boolean formula f, the small set has at most O(|f|1−e) numbers), then P = NP = P# P and probabilisticPolynomial time equals polynometric time.
Abstract: An n-variable Boolean formula may have anywhere from 0 to 2n satisfying assignments. Can a polynomial-time machine, given such a formula, reduce this exponential number of possibilities to a small number of possibilities? We call such a machine an enumerator and prove that if there is a good polynomial-time enumerator for #P (i.e., one where for every Boolean formula f, the small set has at most O(|f|1−e) numbers), then P = NP = P# P and probabilistic polynomial time equals polynomial time. Furthermore, we show that #P polynomial-time Turing reduces to enumerating #P.
TL;DR: This is the most basic quantity (the storage capacity) of a WEM ( X n, ϕn)n = 1∞ and a characterization of this and related quantities is given.
Abstract: We introduce write-efficient memories (WEM) as a new model for storing and updating information on a rewritable medium. There is a cost ϕ: X × X → R ∞ assigned to changes of letters. A collection of subsets C = {Ci: 1 ≤ i ≤ M} of X n is an (n, M, D) WEM code, if C i ∩ C j = ⊘ for all i ≠ j and if D max = max l⩽i,j⩽Mx n ϵC j Y n ϵC 1 max min ∑ j=1 n ϕ(x t , y t )⩽D . Dmax is called the maximal correction cost with respect to the given cost function. The performance of a code C can also be measured by two parameters, namely, the maximal cost per letter d C = n−1Dmax and the rate of the size r C = n−1 log M. The rate achievable with a maximal per letter cost d is thus R(d)= sup c:d c ⩽d r c . This is the most basic quantity (the storage capacity) of a WEM ( X n, ϕn)n = 1∞. We give a characterization of this and related quantities.
TL;DR: This work considers the problem of finding a polygon nested between two given convex polygons that has a minimal number of vertices, and presents an O(n log k) algorithm for solving the problem, where n is the total number of Vertices of the given polygons.
Abstract: We consider the problem of finding a polygon nested between two given convex polygons that has a minimal number of vertices. Our main result is an O(n log k) algorithm for solving the problem, where n is the total number of vertices of the given polygons, and k is the number of vertices of a minimal nested polygon. We also present an O(n) sub-optimal algorithm, and a simple O(nk) optimal algorithm.
TL;DR: These results are shown for graph Grammars with neighbourhood controlled embedding and with dynamic edge relabeling (eNCE grammars).
Abstract: A graph grammar is linear if it generates graphs with at most one nonterminal node. Linear graph grammars can simulate nonterminal bounded graph grammars (which generate graphs with a bounded number of nonterminal nodes) and derivation bounded graph grammars. If a linear graph language contains connected graphs of bounded degree only, then it is in NSPACE(log n ). These results are shown for graph grammars with neighbourhood controlled embedding and with dynamic edge relabeling (eNCE grammars).
TL;DR: A deterministic parallel algorithm to evaluate algebraic expressions in O(log n) time using n log (n) processors on a parallel random access machine without write conflicts (P-RAM) and with no free preprocessing.
Abstract: We describe a deterministic parallel algorithm to evaluate algebraic expressions in O(log n) time using n log (n) processors on a parallel random access machine without write conflicts (P-RAM) and with no free preprocessing. The input to the algorithm is a string (of the symbols making up the expression) store in an array. Such a form for the input enables a consecutive numbering of the operands in the expression in O(log(n)) time with n log (n) processors. This corresponds to a consecutive numbering of the leaves of the expression tree. This then further permits us to partition the leaves into small segments. We improve the result of Miller and Reif (1985, in “26th IEEE Sympos. on Found. of Comput. Sci.,” pp. 478–489), who described an optimal parallel randomized algorithm. (Strictly speaking, the input to their algorithm is different being the parse tree of the expression. The input to the innovative part of our algorithm (step 2) is this parse tree which, in addition, has its leaves numbered consecutively from left to right. These two orms are equivalent if we note that such a numbering can be obtained by an optimal parallel algorithm which employs the Euler tour technique and optimal list ranking). Our algorithm can be used to construct optimal parallel algorithms for the recognition of two nontrival subclasses of context-free languages: bracket and input-driven languages. These languages are the most complicated context-free languages known to be recognizable in deterministic logarithmic space. This strengthens the result of Matheyses and Fiduccia (1982 in “20th Allerton Conf. on Commun. Control and Comput.”) who constructed an almost optimal parallel algorithm for Dyck languages, since Dyck languages are a proper subclass of input-driven languages. Our algorithm includes a new simple method for tree contraction which we call the leaves-cutting method. Its correctness is trival (compared with the method of Miller and Reif) and it can be implemented on a P-RAM without write and without read conflicts.
TL;DR: Simultaneous relationships from aggregate hardware and time to sequential space and reversal are shown and these are used as evidence for an “extended parallel computation thesis” and new characterizations for the simultaneous parallel complexity class NC and for the complementary class SC.
Abstract: The parallel resources time and hardware and the complexity classes defined by them are studied using the aggregate model. The equivalence of complexity classes defined by sequential space and uniform aggregate hardware is established. Aggregate time is related to (bounded fanin) circuit depth and, similarly, aggregate hardware is related to circuit width. Interelationships between aggregate time and hardware follow as corollaries. Aggregate time is related to the sequential resource reversal. Simultaneous relationships from aggregate hardware and time to sequential space and reversal are shown (and conversely), and these are used as evidence for an “extended parallel computation thesis.” These simultaneous relationships provide new characterizations for the simultaneous parallel complexity class NC and for the complementary class SC . The evaluation of monotone planar circuits is shown to be in NC , in fact in LOGCFL .
TL;DR: It is proved that the membership problem for context free trace languages can be solved in time O ( BM ( n α )), where α is the dimension of the greatest clique of the concurrency relation C and BM is the time required for multiplying two arbitrary n × n boolean matrices.
Abstract: Trace languages have been introduced in order to describe the behaviour of concurrent systems in the same way as usual formal languages do for sequential system. They can be defined as subsets of a free partially commutative monoid and a theory of trace languages can be developed, generalizing the usual formal languages theory. In this paper, the time complexity of membership problems for regular and context-free trace languages is investigated. It is proved that the membership problem for context free trace languages can be solved in time O ( BM ( n α )), where α is the dimension of the greatest clique of the concurrency relation C and BM ( n ) is the time required for multiplying two arbitrary n × n boolean matrices. For regular trace languages, our method gives an algorithm which requires O ( n α ) time. Finally, the uniform membership problem is shown to be NP-complete.
TL;DR: Two reduction systems yielding the equality of λπ are introduced; the first is not confluent and, for the second, confluence is an open problem.
Abstract: We consider the equational theory λπ of λ-calculus extended with constants π, π0, π1 and axioms for surjective pairing: π0(πXY) = X, π1(πXY) = Y, π(π0X)(π1X) = X. Two reduction systems yielding the equality of λπ are introduced; the first is not confluent and, for the second, confluence is an open problem. It is shown, however, that in both systems each term possessing a normal form has a unique normal form. Some additional properties and problems in the syntactical analysis of λπ and the corresponding reduction systems are discussed.
TL;DR: Presentation equationnelle des categories de morphismes partiels avec etablissement systematique des rapports entre ces structures and les classiques structures totales.
Abstract: Presentation equationnelle des categories de morphismes partiels avec etablissement systematique des rapports entre ces structures et les classiques structures totales
TL;DR: It is proved that a new measure of presortedness is presented which is distinct from other common measures of presortingness and it is proven that this is Par-optimal in a comparison-based model of computation.
Abstract: A new measure of presortedness is presented which we call Par. We prove that it is distinct from other common measures of presortedness and we design sorting algorithms that sort a sequence X in O(|X| log Par(X)) comparisons. Moreover, we prove that this is Par-optimal in a comparison-based model of computation.
TL;DR: This paper makes significant progress toward a complete solution to the question of the relationship of three parameters that effect inferribility: the number of experimental trials, the plurality of approaches to the particular learning problem, and the accuracy of the final result.
Abstract: This paper is concerned with the algorithmic learning, by example in the limit, of programs that compute recursive functions. The particular focus is on the relationship of three parameters that effect inferribility: the number of experimental trials, the plurality of approaches to the particular learning problem, and the accuracy of the final result. Each of these parameters has been examined extensively before. However, the precise characterization of the three-way interaction between these parameters is still not known. This paper makes significant progress toward a complete solution.
TL;DR: Various polynomial-time truth-table reducibilities are compared by their ability of using sparse oracles to answer queries, and it is shown that the two associated reduction classes are incomparable, unless a trivial inclusive relation holds.
Abstract: Various polynomial-time truth-table reducibilities are compared by their ability of using sparse oracles to answer queries. The reducibilities studied here include conjunctive reducibility, bounded conjunctive reducibility, disjunctive reducibility, bounded disjunctive reducibility, truth-table reducibility, and bounded truth-table reducibility. For any two reducibilities ≤ r P and ≤ s P , we compare the class of sets ≤ r P -reducible to sparse sets with the class of sets ≤ s P -reducible to sparse sets. For most pairs of reducibilities ≤ r P and ≤ s P , it is shown that the two associated reduction classes are incomparable, unless a trivial inclusive relation holds.
TL;DR: This result can be interpreted as an evidence that with one exchange of messages, the proof-system is stronger when Arthur starts the communication, and at most two new complexity classes survive at the constant levels of this new hierarchy: AM and MA, depending on who starts the Communication.
Abstract: Arthur-Merlin games were introduced recently by Babai in order to capture the intuitive notion of efficient, probabilistic proof-systems. Considered as complexity classes, they are extensions of NP. It turned out, that one exchange of messages between the two players is sufficient to simulate a constant number of interactions. Thus at most two new complexity classes survive at the constant levels of this new hierarchy: AM and MA, depending on who starts the communication. It is known that \(MA \subseteq AM\). In this paper we answer an open problem of Babai: we construct an oracle C such that \(AM^C - \Sigma _2^{P,C}
e \emptyset\). Since \(MA^C \subseteq \Sigma _2^{P,C}\), it follows that for some oracle C, MAC≠AMC. Our prooftechnique is a modification of the technique used by Baker and Selman to show that ∑ 2 P and ∏ 2 P can be separated by some oracle. This result can be interpreted as an evidence that with one exchange of messages, the proof-system is stronger when Arthur starts the communication.
TL;DR: This paper applies the method to prove M. Hennessy and C. Stirling's result that “Future Perfect” logic characterizes observation equivalence of generalized transition systems, i.e., systems whose infinite behaviours are restricted by arbitrary fairness constraints.
Abstract: I. Castellani (1987 , J. Comput. System Sci. 34, 210–235) has shown that observation equivalence of transition systems could be characterized by particular reductions: systems are equivalent if, and only if, they can be reduced to the same form. Moreover, every transition system has a minimal reduced form. We extend these results to logical equivalence, by an algebraic interpretation of temporal logics: we characterize logical equivalence of transition systems by particular reductions (saturating quasi-homomorphisms) or their power algebras of sets of states and paths and prove that every power algebra has a minimal reduced form. We then offer alternative proofs for logical characterizations of observation equivalence: in particular we apply our method to prove M. Hennessy and C. Stirling's (1984 , “Lecture Notes in Comput. Sci. Vol. 176,” pp. 301–311, Springer-Verlag, New York/Berlin) result that “Future Perfect” logic characterizes observation equivalence of generalized transition systems, i.e., systems whose infinite behaviours are restricted by arbitrary fairness constraints.
TL;DR: The details of the proof that the axiom system is relatively complete in the sense of Cook may be of independent interest, because it introduces results about expressiveness for programs with higher types that are useful beyond the immediate problem of the language L4.
Abstract: We provide a sound and relatively complete axiom system for partial correctness assertions in an Algol-like language with procedures passed as parameters, but with no global variables (traditionally known as the language L4). The axiom system allows us to reason syntactically about programs and to construct proofs for assertions about complicated programs from proofs of assertions about their components. Such an axiom system for a language with these features had been sought by a number of researchers, but no previously published solution has been entirely satisfactory. Our axiom system extends the natural style of reasoning used in previous Hoare axiom systems to programs with procedures of higher type. The details of the proof that our axiom system is relatively complete in the sense of Cook may be of independent interest, because we introduce results about expressiveness for programs with higher types that are useful beyond the immediate problem of the language L4. We also prove a new incompleteness result that applies to our logic and to similar Hoare logics.