Showing papers in "SIAM Journal on Computing in 1972"

Depth-First Search and Linear Graph Algorithms

Abstract: The value of depth-first search or “backtracking” as a technique for solving problems is illustrated by two examples. An improved version of an algorithm for finding the strongly connected componen...

The Transitive Reduction of a Directed Graph

Abstract: We consider economical representations for the path information in a directed graph. A directed graph $G^t $ is said to be a transitive reduction of the directed graph G provided that (i) $G^t $ has a directed path from vertex u to vertex v if and only if G has a directed path from vertex u to vertex v, and (ii) there is no graph with fewer arcs than $G^t $ satisfying condition (i). Though directed graphs with cycles may have more than one such representation, we select a natural canonical representative as the transitive reduction for such graphs. It is shown that the time complexity of the best algorithm for finding the transitive reduction of a graph is the same as the time to compute the transitive closure of a graph or to perform Boolean matrix multiplication.

Algorithms for Minimum Coloring, Maximum Clique, Minimum Covering by Cliques, and Maximum Independent Set of a Chordal Graph

Abstract: A finite undirected graph is called chordal if every simple circuit has a chord. Given a chordal graph, we present, ways for constructing efficient algorithms for finding a minimum coloring, a minimum covering by cliques, a maximum clique, and a maximum independent set. The proofs are based on a theorem of D. Rose [3] that a finite graph is chordal if and only if it has some special orientation called an R-orientation. In the last part of this paper we prove that an infinite graph is chordal if and only if it has an R-orientation.

Enumeration of the Elementary Circuits of a Directed Graph

Abstract: An algorithm to enumerate all the elementary circuits of a directed graph is presented. The algorithm uses back-tracking with lookahead to avoid unnecessary work, and it has a time bound of $O ((V+E)(C+1))$ when applied to a graph with $V$ vertices, $E$ edges, and $C$ elementary circuits. Keywords: Algorithm, circuit, cycle, graph

A Minimum Distance Error-Correcting Parser for Context-Free Languages

Abstract: We assume three types of syntax errors can debase the sentences of a language generated by a context-free grammar: the replacement of a symbol by an incorrect symbol, the insertion of an extraneous symbol, or the deletion of a symbol. We present an algorithm that will parse any input string to completion finding the fewest possible number of errors. On a random access computer the algorithm requires time proportional to the cube of the length of the input.

Flow Graph Reducibility

Abstract: The structure of , programs can often be described by a technique called “interval analysis” on their flow graphs. Here, we characterize the set of flow graphs that can be analyzed in this way in terms of two very simple transformations on graphs. We then give a necessary and sufficient condition for analyzability and apply it to “goto-less programs,” showing that they all meet the criterion.

A Simple Algorithm for Merging Two Disjoint Linearly Ordered Sets

Abstract: In this paper we present a new algorithm for merging two linearly ordered sets which requires substantially fewer comparisons than the commonly used tape merge or binary insertion algorithms. Bounds on the difference between the number of comparisons required by this algorithm and the information theory lower bounds are derived. Results from a computer implementation of the new algorithm are given and compared with a similar implementation of the tape merge algorithm.

Locality in Page Reference Strings

Abstract: A probabilistic model is presented of program material in a paging machine. The sequences of page references in the model are associated with certain sequences of LRU stack distances and have reference patterns formalizing a notion of “locality” of reference. Values for parameters of the model can be chosen to make the page-exception characteristics of the generated sequences of page references consistent with those of actual program traces.The statistical properties of the execution intervals (times between page-exception) for sequences of references in the model are derived, and an application of these results is made to a queuing analysis of a simple multiprogrammed paging system. Some numerical results pertaining to the program model and the queuing analysis are given.

On Classes of Program Schemata

Abstract: We define the following classes of program schemata: ${\text{P}} = $ class of schemes using a finite number of simple variables; ${\text{P}}_{\text{A}} = $ class of schemes using simple and subscripted variables (arrays); ${\text{P}}_{{\text{Ae}}} = $ class of schemes in ${\text{P}}_{\text{A}} = $, with the addition of an equality test on subscript values; ${\text{P}}_{\text{R}} = $ class of schemes allowing recursive functions; ${\text{P}}_{\text{L}} = $ class of schemes allowing labels as values; ${\text{P}}_{\text{M}} = $ class of schemes allowing a finite number of special markers as values; ${\text{P}}_{{\text{pds}}} = $ class of schemes using pushdown stores. With these, we can also discuss, for example, ${\text{P}}_{{\text{AM}}} $, the class of schemes allowing arrays, and special markers as values ; and ${\text{P}}_{{\text{AL}}} $, the class of schemes allowing arrays, and labels as values.We argue that ${\text{P}}_{\text{A}}$, ${\text{P}}_{\text{R}}$, and ${\text{P}}_{\text{L}}$ faithfully repres...

Analysis of Scanning Policies for Reducing Disk Seek Times

Abstract: A number of recent studies have examined techniques for sequencing disk accesses to minimize or reduce seek times. The principal methods proposed have been called scanning policies. In this paper we formulate and analyze simple mathematical models of head motion in disk systems in which two different scanning policies are implemented. Expressions for response times are derived, and the properties they imply are discussed.

On Languages Accepted in Polynomial Time

Abstract: The family NP (P) of languages accepted by nondeterministic (deterministic) Turing machines operating in polynomial time is distinct from many well-known families of languages defined by tape-bounded or time-bounded Turing machines. In particular, it is shown that NP (P) is not equal to the family of context-sensitive languages, the family of languages accepted by deterministic linear bounded automata, or the family of languages accepted by deterministic Turing machines operating within exponential time.

Real-Time Strict Deterministic Languages

Abstract: The family of strict deterministic languages has been studied for its theoretical properties and applications to parsing. In particular, these languages have been shown to be precisely the prefix-free deterministic languages. Deterministic pushdown automata are called (quasi-)real time if they have no (only a bounded number of consecutive) null moves. It is shown that for strict deterministic languages, the quasi-real-time and real-time constraints are equivalent (except for $\{ \Lambda \} $). A grammatical characterization of these languages is also given. For quasi-real-time strict deterministic languages, an easy and elegant decision method is given for testing regularity. For all known methods of accepting deterministic languages, it is shown that the families of real-time languages are a proper subset of the full families. A relation is established among these sets, the simple deterministic languages, and some hierarchies.

Optimization of Straight Line Programs

Abstract: We provide a set of transformations capable of transforming a straight line program into any other equivalent one assuming no algebraic laws hold. We then show that optimization of straight line code under “reasonable” cost criteria can always be accomplished by applying sequences of these transformations in a prescribed order.

Program Schemes with Pushdown Stores

Abstract: We attempt to characterize classes of schemes allowing pushdown stores, building on an earlier work by Constable and Gries [1]. We study the effect (on the computational power) of allowing one, two, or more pushdown stores, both with and without the ability to detect when a pds is empty. A main result is that using one pds is computationally equivalent to allowing recursive functions.We also study the effect of adding the ability to do integer arithmetic, and multidimensional arrays.

Computational Complexity of Iterative Processes

Abstract: The theory of optimal algorithmic processes is part of computational complexity. This paper deals with analytic computational complexity. The relation between the goodness of an iteration algorithm and its new function evaluation and memory requirements are analyzed. A new conjecture is stated.

Terminal Context in Context-Sensitive Grammars

Abstract: If every non-context-free rewriting rule of a context-sensitive (with erasing) grammar has as left context a string of terminal symbols and the left context is at least as long as the right context, then the language generated is context-free If every non-context-free rewriting rule of a context-sensitive (with erasing) grammar has as left and right context strings of terminal symbols, then the language generated is context-free

Symmetries in Data Graphs

Abstract: Data graphs were introduced as a vehicle for studying uniformities in the structure of graphs underlying data structures. This paper is devoted to investigating symmetries in data graphs. Such symmetries are of no little significance in every phase of the computational process. They can often be exploited to formulate more efficient algorithms, to simplify the specification of these algorithms, and to facilitate analysis of the resulting programs. The main thrust of this paper is to investigate the influence of various structural features of data graphs on the types of symmetries the data graphs enjoy what features ensure the presence of symmetries of various types, and what features limit the possible types of symmetries. These questions are studied first on the class of all data graphs, and then on the class of addressable (= realizable by relative addressing) data graphs.

Some Undecidability Results for Parallel Program Schemata

Abstract: Some theorems showing undecidability for computational commutativity, boundedness, termination and determinacy of parallel program schemata are proved. These results are then compared with contrasting decidability results in [1] showing that the deletion of the hypothesis of repetition-freeness from the decidability theorems produces undecidability.

A Note on Merging

Abstract: This paper studies the merging operation when data is stored on the surfaces of a disk. The data consists of q lists (each of n numbers) stored on a disk. Each list is stored on one surface of a disk. The time needed to merge into a single (sorted) list, T, is a function of the required motion of the reading head. In this paper we calculate the expected value of T.

Analysis and Synthesis of Sorting Algorithms

Abstract: The problem of analyzing and synthesizing sorting algorithms is studied. That is, given a sorting algorithm we want to investigate how it works in a step-by-step manner and consequently to assert that it indeed arranges the objects according to a certain ordering relationship, and conversely, given an ordering relationship according to which a set of objects are to be arranged, we want to determine an algorithm that will yield the desired result.

Infix to Prefix Translation: The Insufficiency of a Pushdown Stack

Abstract: The permutations of the input string achievable by an algorithm which uses a single pushdown stack and M random access storage locations are characterized, and the characterization is used to show that no such algorithm can translate arithmetic expressions from infix to prefix.

Asymptotic Service System Output, with Application to Multiprogramming

Abstract: In a multiprogramming computer system modeled as a cyclic queue the number of program segments completed at the CPU in a period of time is discussed. It is shown that this number is approximately normally distributed as the time period becomes long. Parameters of the normal distribution are determined. Numerical examples illustrate the results.

A Note on the Intersection of Complexity Classes of Functions

Abstract: The classes of computable functions defined by a bound on the computation time are shown not to be closed under infinite descending intersection.

Compatibility and Complexity of Refinements of the Resolution Principle

Abstract: This paper studies a number of logically complete search strategies (refinements) for improving the performance of automatic theorem-proving programs based on the resolution principle. These strategies restrict the number of deductions generated by the program at the expense of sometimes missing the shortest proof.By considering elementary proof-preserving transformations on resolution proof trees, (i) it is shown that the conjunction of set-of-support, resolution-with-merging, and linear form deduction is again a complete refinement; (ii) bounds are obtained on the possible increase in complexity of the proof trees when the linear form and resolution-with-merging refinements are imposed.Finally, examples are given which demonstrate the savings in time and storage when refinements are used to prove some theorems of moderate difficulty in group theory and ternary boolean algebra.

Expectations of Functions of Sequences over Finite Alphabets with Given Transition Probabilities by Methods Independent of Sequence Length

Abstract: A special case of the problem discussed in this paper occurs in connection with non-parametric classification and is introduced from this point of view. The special case concerns the computation of expectations of statistical functions of the “distance” between pairs of fixed-length sequences over a binary alphabet with given a priori state transition probabilities. The general problem involves an extension to alphabets of arbitrary order and the comparison of an arbitrary number of fixed-length sequences. Given a set of sequences, it is shown that for a large class of functions exact computation may be carried out by an algorithm whose computation time is independent of the length of the sequences. It is further shown that results for all functions of this class may be derived from a small number of basis functions. Two methods for computing basis functions are given. Basis functions for the commonly encountered special case involving pairs of binary sequences are given explicitly.