Date 1315 Oct. 1980
Filter Results

[Front cover]
Page(s): C1 
Table of contents
Page(s): iv  vi 
Foreword
Page(s): iii 
On linear characterizations of combinatorial optimization problems
Page(s): 1  9We show that there can be no computationally tractable description by linear inequalities of the polyhedron associated with any NPcomplete combinatorial optimization problem unless NP = coNP  a very unlikely event. We also apply the ellipsoid method for linear programming to show that a combinatorial optimization problem is solvable in polynomial time if and only if it admits a small generator of violated inequalities. View full abstract»

On a class of totally unimodular matrices
Page(s): 10  16We examine the class of matrices that satisfy Commoner's sufficient condition for total unimodularity [C], which we call restricted totally unimodular (RTUM). We show that a matrix is RTUM if and only if it can be decomposed in a very simple way into the incidence matrices (or their transposes) of bipartite graphs or directed graphs, and give a linear time algorithm to perform this task. Based on this decomposition, we show that the 0,1 Integer Programming Problem with an RTUM matrix of constraints has the same time complexity as the bmatching and the max flow problems. View full abstract»

An O(vv c E) algoithm for finding maximum matching in general graphs
Page(s): 17  27In this paper we present an 0(√VÃ‚Â¿E) algorithm for finding a maximum matching in general graphs. This algorithm works in 'phases'. In each phase a maximal set of disjoint minimum length augmenting paths is found, and the existing matching is increased along these paths. Our contribution consists in devising a special way of handling blossoms, which enables an O(E) implementation of a phase. In each phase, the algorithm grows Breadth First Search trees at all unmatched vertices. When it detects the presence of a blossom, it does not 'shrink' the blossom immediately. Instead, it delays the shrinking in such a way that the first augmenting path found is of minimum length. Furthermore, it achieves the effect of shrinking a blossom by a special labeling procedure which enables it to find an augmenting path through a blossom quickly. View full abstract»

Some theorems about matrix multiplication
Page(s): 28  35This paper considers the computation of matrix chain products of the form M1 × M2 ×...× Mn1. If the matrices are of different dimensions, the order in which the matrices are computed affects the number of operations. An optimum order is an order which minimizes the total number of operations. We present some theorems about an optimum order of computing the matrices. Based on these theorems, an O(n log n) algorithm for finding the optimum order is presented. View full abstract»

Polynomialtime algorithms for permutation groups
Page(s): 36  41A permutation group on n letters may always be represented by a small set of generators, even though its size may be exponential in n. We show that it is practical to use such a representation since many problems such as membership testing, equality testing, and inclusion testing are decidable in polynomial time. In addition, we demonstrate that the normal closure of a subgroup can be computed in polynomial time, and that this proceaure can be used to test a group for solvability. We also describe an approach to computing the intersection of two groups. The procedures and techniques have wide applicability and have recently been used to improve many graph isomorphism algorithms. View full abstract»

Isomorphism of graphs of bounded valence can be tested in polynomial time
Page(s): 42  49Suppose we are given a set of generators for a group G of permutations of a colored set A. The color automorphism problem for G involves finding generators for the subgroup of G which stabilizes the color classes. Testing isomorphism of graphs of valence ≤ t is polynomialtime reducible to the color automorphism problem for groups with small simple sections. The algorithm for the latter problem involves several divideandconquer tricks. The problem is solved sequentially on the Gorbits. An orbit is broken into a minimal set of blocks permuted by G. The hypothesis on G guarantees the existence of a 'large' subgroup P which acts as a pgroup on the blocks. A similar process is repeated for each coset of P on G. Some results on primitive permutation groups are used to show that the algorithm runs in polynomial time. View full abstract»

A fast algorithm for multiprocessor scheduling
Page(s): 50  53First Page of the ArticleView full abstract» 
Sparse complete sets for NP: Solution of a conjecture of Berman and Hartmanis
Page(s): 54  60A set S ⊂ {0,1}* is sparse if there is a polynomial p such that the number of strings in S of size at most n is at most p(n). All known NPcomplete sets, such as SAT, are not sparse. The main result of this paper is that if there is a sparse NPcomplete set under manyone reductions, then P = NP. We also show that if there is a sparse NPcomplete set under Turing reductions, then the polynomial time hierarchy collapses to Δ2P. View full abstract»

Efficient algorithms for path system problems and applications to alternating and timespace complexity classes
Page(s): 62  73Let SPS(f(n)) denote the solvable path system problem for path systems of bandwidth f(n) and SPS (f(n)) the corresponding problem for monotone systems. Let DTISP (poly, f(n)) denote the polynomial time and simultaneous f(n) space class and SC = UkDTISP (poly, logkn). Let ASPACE (f(n)) denote the sets accepted by f(n) space bounded alternating TMs and ASPACE (f(n)) the corresponding oneway TM family. Then, for "wellbehaved" functions fεO(n)o(log n), (1) SPS (f(n)) is ≤logcomplete for DTISP (poly, f(n)), (2) {SPS(f(n)k)}k≥1 is ≤logcomplete for ASPACE (logf(n)), (3) {SPS (f(n)k)}k≥1 is ≤logcomplete for ASPACE (log f(n)), (4) SPS(f(n)) ε DSPACE(f(n) × log n), (5) ASPACE(log f(n)) ⊆ UkDSPACE(f(n)k), and (6) SC = CLOSURE ≤log(ASPACE(log log n)). View full abstract»

Upper and lower bounds for first order expressibility
Page(s): 74  82We continue the study of first order expressibility as a measure of complexity, introducing the new class Var &Sz[v(n),z(n)] of languages expressible with v(n) variables in sentences of size z(n). We show that when the variables are restricted to boolean values: BVar &Sz[v(n),z(n)] = ASPACE&TIME[v(n),t(n)] That is variables and size correspond precisely to alternating space and time respectively. Returning to variables ranging over an n element universe, it follows that: Var[O(1)] = ASPACE[log n] = PTIME That is the family of properties uniformly expressible with a constant number of variables is just PTIME. These results hold for languages with an ordering on the objects in question, e.g. for graphs a successor relation on the vertices. We introduce an "alternating pebbling game" to prove lower bounds on the number of variables and size needed to express properties without successor. We show, for example, that k variables are needed to express Clique(k), suggesting that this problem requires DTIME[nk]. View full abstract»

The equivalence problem for deterministic twoway sequential transducers is decidable
Page(s): 83  85The equivalence problem for deterministic twoway sequential transducers is a long time open problem which is known to be decidable for some restricted cases. Here, the problem is shown to be decidable also for the general case. This even when the devices are allowed to make some finite number of nondeterministic moves. View full abstract»

Succinct representation random strings, and complexity classes
Page(s): 86  95A general paradigm for relating measures of succinctness of representation and complexity theory is presented. The measures are based on the new Private and Blindfold Alternation machines. These measures are used to indicate the inherent information (or "randomness") of a string, but with respect to time and space complexity classes. These measures are then used to show that the existence of strings which are random with respect to one measure but not to another can show the relationship between the corresponding complexity classes. The basic hierarchy theorems given allow different and possibly more powerful approaches to these problems. View full abstract»

Proofs by induction in equational theories with constructors
Page(s): 96  107We show how to prove (and disprove) theorems in the initial algebra of an equational variety by a simple extension of the KnuthBendix completion algorithm. This allows us to prove by purely equational reasoning theorems whose proof usually requires induction. We show applications of this method to proofs of programs computing over data structures, and to proofs of algebraic summation identities. This work extends and simplifies recent results of Musser15 and Goguen6. View full abstract»

An improved algorithm for computing with equations
Page(s): 108  117Implementation of programming language interpreters, proving theorems of the form A=B, and implementation of abstract data types are all problems that can be reduced to the problem of finding a normal form for an expression with respect to a finite set of equation (axiom) schemata The definition of a nonoverlapping s set of axiom schemata is given and the directed congruence closure algorithm is presented; an algorithm that efficiently solves this kind of problem provided the axiom schemata are nonoverlapping. The algorithm is a variation on the congruence closure algorithm? and, like the congruence closure algorithm, it has the advantage of remembering which expressions have already been proved to be equivalent. However, unlike the congruence closure algorithm, which can use only a finite set of axioms, the directed congruence closure algorithm allows a possibly infinite set of axioms generated by a finite set of axiom schemata. View full abstract»

Programs and types
Page(s): 118  128The first two sections of this paper motivate and outline a constructive theory of (data) types which we developed for formal program verification. The executable component of the theory provides a very high level programming language with a rich type structure. A theory of this generality appears necessary to manage complex programming and formal reasoning about it. The logical component, influencea by AUTOMATH and LCF and based on MartinLöf's ITT, appears strong enough to formalize constructive mathematics; hence a theory or this generality is probably sufficient for program development and verification. The last two sections of the paper illustrate the richness of the theory and the benefits of generality by describing with it different "denotational" semantics for programs. Because the theory is constructive, these abstract semantics are also computational. View full abstract»

Process logic: Expressiveness, decidability, completeness
Page(s): 129  142We define a process logic PL that subsumes Pratt's process logic, Parikh's SOAPL, Nishimura's process logic, and Pnueli's Temporal Logic in expressiveness. The language of PL is an extension of the language of Propositional Dynamic Logic (PDL). We give a deductive system for PL which includes the Segerberg axioms for PDL and prove that it is complete. We also show that PL is decidable. View full abstract»

A linear history semantics for distributed languages extended abstract
Page(s): 143  151A denotational semantics is given for a distributed language based on communication (CSP). The semantics uses linear sequences of communications to record computations; for any well formed program segment the semantics is a relation between attainable states and the communication sequences needed to attain these states. In binding two or more processes we match and merge the communication sequences assumed by each process to obtain a sequence and State of the combined process. The approach taken here is distinguished by relatively simple semantic domains and ordering. View full abstract»

The complexity of recursion schemes and recursive programming languages
Page(s): 152  160Deterministic exponential lower time bounds are obtained for analyzing monadic recursion schemes, multivariable recursion schemes, and recursive programs. The lower bound for multivariable recursion schemes holds for any domain of interpretation with at least two elements. The lower bound for recursive programs holds for any recursive programming language with a nontrivial predicate test (i.e. a predicate test that is neither identically true nor identically false). Exponential lower bounds on depth of nesting of recursive function calls play an important role in the proofs of these bounds. In contrast, polynomial upper bounds on depth of nesting are obtained for total and linear monadic recursion schemes. As corollaries, several decision problems for these scheme classes are shown to have nondeterministic polynomially timebounded algorithms. View full abstract»

On the expressive power of attribute grammars
Page(s): 161  172We examine the possibility of translating an attribute system into a recursive program scheme taking derivation trees as arguments. This is possible if and only if the attribute system is strongly noncircular. The strong non circularity is decidable in polynomial time. Our recursive program schemes allow us to attack the equivalence problem for attribute systems and solve it in a special case properly including the case of purely synthesized systems. View full abstract»

Loop elimination and loop reduction A modeltheoretic analysis of programs
Page(s): 173  184First Page of the ArticleView full abstract» 
Complexity of flow analysis, inductive assertion synthesis and a language due to Dijkstra
Page(s): 185  190Two different methods of flow analysis are discussed, one a significant generalization of the other. It is shown that the two methods have significantly different intrinsic computational complexities. As an outgrowth of our observations it is shown that a feature of the programming language used by Dijkstra in A Discipline of Programming makes it unsuitable for compiletime type checking, thus suggesting that flow analysis is applicable to the design of programming languages, as well as to their implementation. It is also shown that program verification by the method of inductive assertions is very likely to lead to assertions whose lengths and proofs are not polynomially bounded in the size of the program being verified, even for very simple programs. This last observation casts further doubt on the practicality and relevance of mechanized verification of arbitrary programs. View full abstract»

The inherent complexity of dynamic data structures which accommodate range queries
Page(s): 191  199A formal framework is presented in which to explore the complexity issues of data structures which accommodate various types of range queries. Within this framework, a systematic and reasonably tractable method for assessing inherent complexity is developed. Included among the interesting results are the following: the fact that nonlinear lower bounds are readily accessible, and the existence of a complexity gap between linear time and n log n time. View full abstract»