# Showing papers in "SIAM Journal on Computing in 1989"

••

TL;DR: A computational complexity theory of the “knowledge” contained in a proof is developed and examples of zero-knowledge proof systems are given for the languages of quadratic residuosity and 'quadratic nonresiduosity.

Abstract: Usually, a proof of a theorem contains more knowledge than the mere fact that the theorem is true. For instance, to prove that a graph is Hamiltonian it suffices to exhibit a Hamiltonian tour in it; however, this seems to contain more knowledge than the single bit Hamiltonian/non-Hamiltonian.In this paper a computational complexity theory of the “knowledge” contained in a proof is developed. Zero-knowledge proofs are defined as those proofs that convey no additional knowledge other than the correctness of the proposition in question. Examples of zero-knowledge proof systems are given for the languages of quadratic residuosity and 'quadratic nonresiduosity. These are the first examples of zero-knowledge proofs for languages not known to be efficiently recognizable.

3,117 citations

••

TL;DR: Algorithms are designed to answer the following kinds of questions about trees: what is the distance between two trees, and the analogous question for prunings as for subtrees.

Abstract: Ordered labeled trees are trees in which the left-to-right order among siblings is significant. The distance between two ordered trees is considered to be the weighted number of edit operations (in...

1,367 citations

••

TL;DR: A randomised approximation scheme for the permanent of a 0–1s presented, demonstrating that the matchings chain is rapidly mixing, apparently the first such result for a Markov chain with genuinely c...

Abstract: A randomised approximation scheme for the permanent of a 0–1s presented. The task of estimating a permanent is reduced to that of almost uniformly generating perfect matchings in a graph; the latter is accomplished by simulating a Markov chain whose states are the matchings in the graph. For a wide class of 0–1 matrices the approximation scheme is fully-polynomial, i.e., runs in time polynomial in the size of the matrix and a parameter that controls the accuracy of the output. This class includes all dense matrices (those that contain sufficiently many 1’s) and almost all sparse matrices in some reasonable probabilistic model for 0–1 matrices of given density.For the approach sketched above to be computationally efficient, the Markov chain must be rapidly mixing: informally, it must converge in a short time to its stationary distribution. A major portion of the paper is devoted to demonstrating that the matchings chain is rapidly mixing, apparently the first such result for a Markov chain with genuinely c...

878 citations

••

TL;DR: It is shown that the recent maximum flow algorithm of Goldberg and Tarjan can be extended to solve an important class of such parametric maximum flow problems, at the cost of only a constant factor in its worst-case time bound.

Abstract: The classical maximum flow problem sometimes occurs in settings in which the arc capacities are not fixed but are functions of a single parameter, and the goal is to find the value of the parameter such that the corresponding maximum flow or minimum cut satisfies some side condition. Finding the desired parameter value requires solving a sequence of related maximum flow problems. In this paper it is shown that the recent maximum flow algorithm of Goldberg and Tarjan can be extended to solve an important class of such parametric maximum flow problems, at the cost of only a constant factor in its worst-case time bound. Faster algorithms for a variety of combinatorial optimization problems follow from the result.

659 citations

••

TL;DR: The problem of nonpreemptively scheduling a set of m partially ordered tasks on n identical processors subject to interprocessor communication delays is studied in an effort to minimize the makespan and a new heuristic, called Earliest Task First (ETF), is designed and analyzed.

Abstract: The problem of nonpreemptively scheduling a set of m partially ordered tasks on n identical processors subject to interprocessor communication delays is studied in an effort to minimize the makespan. A new heuristic, called Earliest Task First (ETF), is designed and analyzed. It is shown that the makespan $\omega _{{\text{ETF}}} $ generated by ETF always satisfies $\omega _{{\text{ETF}}} \leqq ({{2 - 1} / n})\omega _{{\text{opt}}}^{(i)} + C$, where $\omega _{{\text{opt}}}^{(i)} $ is the optimal makespan without considering communication delays and C is the communication requirements over some immediate predecessor-immediate successor pairs along one chain. An algorithm is also provided to calculate C. The time complexity of Algorithm ETF is $O(nm^2 )$.

592 citations

••

TL;DR: This paper presents algorithms for the assignment problem, the transportation problem, and the minimum- cost flow problem of operations research that find a minimum-cost solution, yet run in time close to the best-known bounds for the corresponding problems without costs.

Abstract: This paper presents algorithms for the assignment problem, the transportation problem, and the minimum-cost flow problem of operations research. The algorithms find a minimum-cost solution, yet run in time close to the best-known bounds for the corresponding problems without costs. For example, the assignment problem (equivalently, minimum-cost matching in a bipartite graph) can be solved in $O(\sqrt {nm} \log (nN))$ time, where $n,m$, and N denote the number of vertices, number of edges, and largest magnitude of a cost; costs are assumed to be integral. The algorithms work by scaling. As in the work of Goldberg and Tarjan, in each scaled problem an approximate optimum solution is found, rather than an exact optimum.

457 citations

••

IBM

^{1}TL;DR: Using a pebbling argument, this paper shows that, for any $\varepsilon > 0$, ordinary multitape Turing machines using time T and space S can be simulated by reversible ones using time $O(T^{1 + \varpsilon } )$ and space $O (S\log T)$ or in linear time and space$O(ST^\varePSilon )$.

Abstract: A reversible Turing machine is one whose transition function is $1:1$, so that no instantaneous description (ID) has more than one predecessor. Using a pebbling argument, this paper shows that, for any $\varepsilon > 0$, ordinary multitape Turing machines using time T and space S can be simulated by reversible ones using time $O(T^{1 + \varepsilon } )$ and space $O(S\log T)$ or in linear time and space $O(ST^\varepsilon )$. The former result implies in particular that reversible machines can simulate ordinary ones in quadratic space. These results refer to reversible machines that save their input, thereby insuring a global $1:1$ relation between initial and final IDs, even when the function being computed is many-to-one. Reversible machines that instead erase their input can of course compute only $1:1$ partial recursive functions and indeed provide a Godel numbering of such functions. The time/space cost of computing a $1:1$ function on such a machine is equal within a small polynomial to the cost of co...

392 citations

••

TL;DR: A novel technique for constructing network synchronizers is presented, developed from some basic relationships between synchronizers and the structure of a t-spanning subgraph over the network and a synchronizer for the hypercube with optimal time and communication complexities is obtained.

Abstract: The synchronizer is a simulation methodology introduced by Awerbuch [J. Assoc. Comput. Math., 32 (1985), pp. 804–823] for simulating a synchronous network by an asynchronous one, thus enabling the execution of a synchronous algorithm on an asynchronous network. In this paper a novel technique for constructing network synchronizers is presented. This technique is developed from some basic relationships between synchronizers and the structure of a t-spanning subgraph over the network. As a special result, a synchronizer for the hypercube with optimal time and communication complexities is obtained.

340 citations

••

TL;DR: An efficient technique for on-line planarity testing of a graph is presented that uses O(n) space and supports tests and insertions of vertices and edges in O(\log n) time, where n is the current number of Vertices of G.

Abstract: The on-line planarity-testing problem consists of performing the following operations on a planar graph $G$: (i) testing if a new edge can be added to $G$ so that the resulting graph is itself planar; (ii) adding vertices and edges such that planarity is preserved. An efficient technique for on-line planarity testing of a graph is presented that uses $O(n)$ space and supports tests and insertions of vertices and edges in $O(\log n)$ time, where $n$ is the current number of vertices of $G$. The bounds for tests and vertex insertions are worst-case and the bound for edge insertions is amortized. We also present other applications of this technique to dynamic algorithms for planar graphs.

283 citations

••

Philips Design

^{1}TL;DR: This paper presents a much simpler algorithm using a related, but much more informative tree representation of interval graphs.

Abstract: The fastest-known algorithm for recognizing interval graphs [S. Booth and S. Lucker, J. Comput. System Sci., 13 (1976), pp. 335–379] iteratively manipulates the system of all maximal cliques of the given graph in a rather complicated way in order to construct a consecutive arrangement (more precisely, a tree representation of all possible consecutive arrangements). This paper presents a much simpler algorithm using a related, but much more informative tree representation of interval graphs. This tree is constructed in an incremental fashion by adding vertices to the graph in a predefined order such that adding a vertex u takes $O(|{\operatorname{Adj}}(u)| + 1)$ amortized time.

203 citations

••

TL;DR: The problem of finding a minimum weight complete matching (MWCM) in a complete weighted undirected graph is studied and an algorithm for finding an MWCM is given for the bipartite version.

Abstract: A set of $2n$ points on the plane induces a complete weighted undirected graph as follows. The points are the vertices of the graph, and the weight of an edge between any two points is the distance between the points under some metric. The problem of finding a minimum weight complete matching (MWCM) in such a graph is studied. An $O(n^{2.5} (\log n)^4 )$ algorithm is given for finding an MWCM in such a graph, for the $L_1 $ (manhattan ), the $L_2 $ (Euclidean), and the $L_\infty $ metrics. The bipartite version of the problem is also studied, where half the points are painted with one color and the other half with another color, and the restriction is that a point of one color may be matched only to a point of another color. An $O(n^{2.5} \log n)$ algorithm for the bipartite version, for the $L_1 $, $L_2$, and $L_\infty $ metrics, is presented. The running time for the bipartite version can be further improved to $O(n^2 (\log n)^3 )$ for the $L_1 $ and $L_\infty $ metrics.

••

TL;DR: The main result is an optimal randomized parallel algorithm for INTEGER_SORT, the first known that is optimal: the product of its time and processor bounds is upper bounded by a linear function of the input size.

Abstract: This paper assumes a parallel RAM (random access machine) model which allows both concurrent reads and concurrent writes of a global memory.The main result is an optimal randomized parallel algorithm for INTEGER_SORT (i.e., for sorting n integers in the range $[1,n]$). This algorithm costs only logarithmic time and is the first known that is optimal: the product of its time and processor bounds is upper bounded by a linear function of the input size. Also given is a deterministic sublogarithmic time algorithm for prefix sum. In addition this paper presents a sublogarithmic time algorithm for obtaining a random permutation of n elements in parallel. And finally, sublogarithmic time algorithms for GENERAL_SORT and INTEGER_SORT are presented. Our sub-logarithmic GENERAL_SORT algorithm is also optimal.

••

TL;DR: Improvements in parallel divide-and-conquer techniques are presented, resulting in improved parallel algorithms for a number of problems, including intersection detection, trapezoidal decomposition, and planar point location.

Abstract: Techniques for parallel divide-and-conquer are presented, resulting in improved parallel algorithms for a number of problems. The problems for which improved algorithms are given include segment intersection detection, trapezoidal decomposition, and planar point location. Efficient parallel algorithms are algo given for fractional cascading, three-dimensional maxima, two-set dominance counting, and visibility from a point. All of the algorithms presented run in $O(\log n)$ time with either a linear or a sublinear number of processors in the CREW PRAM model.

••

University of Toronto

^{1}, University of California, San Diego^{2}, University of Washington^{3}, IBM^{4}TL;DR: It is shown that small numbers of “role switches” in two- person pebbling can be eliminated and a general result that shows closure under complementation of classes defined by semi-unbounded fan-in circuits is shown.

Abstract: Following the recent independent proofs of Immerman [SIAM J. Comput., 17 (1988), pp. 935–938] and Szelepcsenyi [Bull. European Assoc. Theoret. Comput. Sci., 33 (1987), pp. 96–100] that nondeterministic space-bounded complexity classes are closed under complementation, two further applications of the inductive counting technique are developed. First, an errorless probabilistic algorithm for the undirected graph s-t connectivity problem that runs in $O(\log n)$ space and polynomial expected time is given. Then it is shown that the class LOGCFL is closed under complementation. The latter is a special case of a general result that shows closure under complementation of classes defined by semi-unbounded fan-in circuits (or, equivalently, nondeterministic auxiliary pushdown automata or tree-size bounded alternating Turing machines). As one consequence, it is shown that small numbers of “role switches” in two-person pebbling can be eliminated.

••

New York University

^{1}, University of Virginia^{2}, Rutgers University^{3}, Hungarian Academy of Sciences^{4}TL;DR: Given n points in the plane and an integer k, the problem of selecting that pair of points that determines the line with the kth smallest or largest slope is considered and line sweeping gives an optimal, $O(n\log n)$-time algorithm.

Abstract: Given n points in the plane and an integer k, the problem of selecting that pair of points that determines the line with the kth smallest or largest slope is considered. In the restricted case, where k is $O(n)$, line sweeping gives an optimal, $O(n\log n)$-time algorithm. For general k the parametric search technique of Megiddo is used to describe an $O(n(\log n)^2 )$-time algorithm. This is modified to produce a new, optimal $O(n\log n)$-time selection algorithm by incorporating an approximation idea.

••

TL;DR: The main concern of this paper is with testing membership and (essential) emptiness of limit sets for linear and two-dimensional cellular automata.

Abstract: The limit sets of cellular automata, defined by Wolfram, play an important role in applications of cellular automata to complex systems. A number of results on limit sets are proved, considering both finite and infinite configurations of cellular automata. The main concern of this paper is with testing membership and (essential) emptiness of limit sets for linear and two-dimensional cellular automata.

••

TL;DR: The upper bounds derived on the computational complexity of the algorithms above improve the upper bounds given by Kannan and Bachem in [SIAM J. Comput., 8 (1979), pp. 499–507].

Abstract: An $O(s^5 M(s^2 ))$ algorithm for computing the canonical structure of a finite Abelian group represented by an integer matrix of size s (this is the Smith normal form of the matrix) is presented. Moreover, an $O(s^3 M(s^2 ))$ algorithm for computing the Hermite normal form of an integer matrix of size s is given.The upper bounds derived on the computational complexity of the algorithms above improve the upper bounds given by Kannan and Bachem in [SIAM J. Comput., 8 (1979), pp. 499–507] and Chou and Collins in [SIAM J. Comput., 11 (1982), pp. 687–708].

••

Yale University

^{1}TL;DR: It is shown that the time needed by a concurrent-read, concurrent-write parallel random access machine (CRAM) to check if an input has a certain property is the same as the minimal depth of a first depth machine.

Abstract: It is shown that the time needed by a concurrent-read, concurrent-write parallel random access machine (CRAM) to check if an input has a certain property is the same as the minimal depth of a first...

••

TL;DR: A parallel algorithm, called adaptive bitonic sorting, which runs on a PRAC, a shared-memory multiprocessor where fetch and store conflicts are disallowed, which achieves optimal performance for any computation time in the range of $\Omega (\log^{2} N) \leq T\leq O(N \log N)$.

Abstract: We propose a parallel algorithm, called adaptive bitonic sorting, which runs on a PRAC, a shared-memory multiprocessor where fetch and store conflicts are disallowed. On a $P$ processors PRAC, our algorithm achieves optimal performance $TP = O(N \log N)$, for any computation time $T$ in the range $\Omega (\log^{2} N) \leq T \leq O(N \log N)$. Adaptive bitonic sorting has also a small constant factor, since it performs less than $2N \log N$ comparisons, and only a handful of operations per comparison.

••

Yale University

^{1}, University of Jena^{2}, Cornell University^{3}, Columbia University^{4}, Dartmouth College^{5}, University of Augsburg^{6}TL;DR: The Boolean Hierarchy I: Structural Properties explores the structure of the boolean hierarchy, the closure of NP with respect to boolean hierarchies, and the role of symbols in this hierarchy.

Abstract: The Boolean Hierarchy I: Structural Properties [J. Cai et al., SIAM J. Comput ., 17 (1988), pp. 1232–252] explores the structure of the boolean hierarchy, the closure of NP with respect to boolean ...

••

TL;DR: In this article the authors state and prove a corrected version of Theorem 3.5 in [SIAM J. Comput., 18 (1989), pp. 859--881].

Abstract: In this article we state and prove a corrected version of Theorem 3.5 in [SIAM J. Comput., 18 (1989), pp. 859--881].

••

TL;DR: It is shown how to extend the solution for the approximate distribution problem to an optimal probabilistic algorithm for the exact distribution problem on a similar class of expander graphs.

Abstract: A solution to the following fundamental communication problem is presented. Suppose that n tokens are arbitrarily distributed among n processors with no processor having more than K tokens. The problem is to specify a bounded-degree network topology and an algorithm that can distribute the tokens uniformly among the processors.The first result is a tight $\Theta (K + \log n)$ bound on the complexity of this problem. It is also shown that an approximate version of this problem can be solved deterministically in $O(K + \log n)$ on any expander graph with sufficiently large expansion factor.In the second part of this work, it is shown how to extend the solution for the approximate distribution problem to an optimal probabilistic algorithm for the exact distribution problem on a similar class of expander graphs. Note that communication through an expander graph is a necessary condition for an $O(K + \log n)$ solution of the problem.These results have direct applications to the efficient implementation of many...

••

Bell Labs

^{1}TL;DR: It can be proven that the bit-reversal permutation requires $\Theta (n\log n)$ time to access in this model, and it is shown that the expected cost of accessing random sequences in thismodel is the same as it is for the case where the tree is static.

Abstract: Two methods are given for obtaining lower bounds on the cost of accessing a sequence of nodes in a symmetrically ordered binary search tree, in a model where rotations can be done on the tree and the entire sequence is known before accessing begins (but the accesses must be done in the order given). For example, it can be proven that the bit-reversal permutation requires $\Theta (n\log n)$ time to access in this model. It is also shown that the expected cost of accessing random sequences in this model is the same as it is for the case where the tree is static.

••

TL;DR: It is found that strictly nonblocking operation can be obtained for multirate traffic with essentially the same complexity as in the classical context.

Abstract: An extension of the classical theory of connection networks is defined and studied. This extension models systems in which multiple connections of differing data rates share the links within a network. Conditions under which the Clos and Cantor networks are strictly nonblocking for multirate traffic are determined. The authors also determine conditions under which the Benes network and variants of the Cantor and Clos networks are rearrangeable. It is found that strictly nonblocking operation can be obtained for multirate traffic with essentially the same complexity as in the classical context.

••

TL;DR: The average-case performance of an algorithm for CNF SAT, recently introduced by the author, is discussed and it is shown that the algorithm takes polynomial average time for a class of CNF equations satisfying the condition that for.

Abstract: The average-case performance of an algorithm for CNF SAT, recently introduced by the author, is discussed. It is shown that the algorithm takes polynomial average time for a class of CNF equations satisfying the condition that for, a constant c, $p^2 v \geqq \ln t - c$, where v is the number of variables, t is the number of clauses, and p is the probability that a given literal appears in a clause. It was known that backtracking plus the pure literal rule, a common way of solving CNF SAT, takes polynomial average time if $p \geqq \varepsilon $ (any small constant) or $p \leqq c(\ln {v / v})^{{3 / 2}} $, but no algorithms were known to take polynomial average time (for all t) in the range $c(\ln v/v)^{3/2} 0$ the new algorithm runs in polynomial average time for $p > (\alpha \ln {v / v})^{{1 / 2}} $, so the unfavorable region is reduced to $c(\ln {v / v})^{{3 / 2}} < p < (\alpha \ln {v / v})^{{1 / 2}} $.

••

TL;DR: It is shown that Stable Matching problems are the same as problems about stable configurations of X-networks and consequences include easy proofs of old theorems, a new simple algorithm for finding a stable matching, and a fast parallel reduction from the Stable Marriage problem to the Assignment problem.

Abstract: It is shown that Stable Matching problems are the same as problems about stable configurations of X-networks. Consequences include easy proofs of old theorems, a new simple algorithm for finding a stable matching, an understanding of the difference between Stable Marriage and Stable Roommates, NP-completeness of Three-party Stable Marriage, CC-completeness of several Stable Matching problems, and a fast parallel reduction from the Stable Marriage problem to the Assignment problem.

••

TL;DR: One of the primary functions in a distributed network is the routing of messages between pairs of nodes, and maintaining a completeroutingtable for this purpose can be expensive for largenetworks.

Abstract: The problem of routing messages along near-shortest paths in a distributed network without using complete routing tables is considered It is assumed that the nodes of the network can be assigned suitable short names at the time the network is established Two space-efficient near-shortest-path routing schemes are given for the class of planar networks Both schemes use the separator property of planar networks in assigning the node names and performing the routings For an n-node network, the first scheme uses $O(\log n)$-bit names and a total of $O(n^{{4 / 3}} )$ items of routing information, each $O(\log n)$ bits long, to generate routings that are only three times longer than corresponding shortest routings in worst cases For any constant $\epsilon ,0 < \epsilon < 1/3$, the second scheme achieves the better space bound of $O(n^{1 + \epsilon } )$ items, each $O(({1 / \epsilon })\log n)$ bits long, but at the expense of $O(({1 / \epsilon })\log n)$-bit node names and a worst-case bound of 7 on the rout

••

TL;DR: One of the main results of this paper shows that for unrestricted inputs, deterministic, unambiguous and nondeterministic machines form a hierarchy with respect to the number of states, solving an open problem of Stearns and Hunt.

Abstract: We consider the problem of how the size of a nondeterministic finite automaton (nfa) representing a regular language depends on the degree of ambiguity of the nfa. We obtain results for the unary and bounded inputs, and partial results for the unrestricted inputs. One of the main results of this paper shows that for unrestricted inputs, deterministic, unambiguous and nondeterministic machines form a hierarchy with respect to the number of states, solving an open problem of Stearns and Hunt. We also propose a new approach to the study of the succinctness of representation through regularity preserving closure properties and obtain some results in this direction.

••

TL;DR: This is the first deterministic algorithm for the maximal independent set problem (MIS) whose running time is polylogarithmic and whose processor-time product is optimal up to a polylogARithmic factor.

Abstract: A new parallel algorithm for the maximal independent set problem is constructed. It runs in $O(\log ^4 n)$ time when implemented on a linear number of EREW-processors. This is the first deterministic algorithm for the maximal independent set problem (MIS) whose running time is polylogarithmic and whose processor-time product is optimal up to a polylogarithmic factor.

••

TL;DR: A maximum network flow algorithm for the synchronous distributed model of computation that uses at most O(n2√m) messages and O( n2) time is developed, thereby improving upon the best previously known algorithms for this model.

Abstract: We study the class of preflow push algorithms recently introduced by Goldberg and Tarjan for solving the maximum network flow problem on a weighted digraph G(V,E). We improve Goldberg and Tarjanis O(n3) time bound for the maximum distance preflow push algorithm to O(n2√m) and show that this bound is tight by constructing a parametrized worst case network. We then develop the maximal excess preflow push algorithm and show that it achieves a bound of O(n2√m) pushes. Based on this we develop a maximum network flow algorithm for the synchronous distributed model of computation that uses at most O(n2√m) messages and O(n2) time, thereby improving upon the best previously known algorithms for this model.