Karl R. Abrahamson

A simple parallel tree contraction algorithm

Abstract A simple reduction from the tree contraction problem to the list ranking problem is presented. The reduction takes O(log n) time for a tree with n nodes, using O( n log n ) EREW processors. Thus tree contraction can be done as efficiently as list ranking. A broad class of parallel tree computations to which the tree contraction techniques apply is described. This subsumes earlier characterizations. Applications to the computation of certain properties of cographs are presented in some detail.

On achieving consensus using a shared memory

Chor, Israeli and Li recently published three randomized algorithms for a version of the consensus problem for a shared memory model of distributed computing. Their model requires, as atomic instructions on the shared memory, reads and random writes (in which a random choice and a write are done together in a single atomic instruction). This paper develops randomized algorithms for a model in which the only atomic operations on the shared memory are reads and writes.

Fixed-Parameter Intractability II (Extended Abstract)

We describe new results in parameterized complexity theory, including an analogue of Ladners theorem, and natural problems concerning k-move games which are complete for parameterized problem classes that are analogues of P-space.

On the complexity of fixed parameter problems

The authors address the question of why some fixed-parameter problem families solvable in polynomial time seem to be harder than others with respect to fixed-parameter tractability: whether there is a constant alpha such that all problems in the family are solvable in time O(n/sup alpha /). The question is modeled by considering a class of polynomially indexed relations. The main results show that (1) this setting supports notions of completeness that can be used to explain the apparent hardness of certain problems with respect to fixed-parameter tractability, and (2) some natural problems are complete.<<ETX>>

Time-space tradeoffs for algebraic problems on general sequential machines

Abstract This paper establishes time-space tradeoffs for some algebraic problems in the branching program model, including convolution of vectors, integer multiplication, matrix-vector products, matrix multiplication, matrix inversion, computing the product of three matrices, and computing PAQ where P and Q are permutation matrices. The lower bounds apply to general sequential models of computation. Although the lower bounds are for a more general model, they are as large as the known bounds for straight-line programs (even improving the known straight-line bounds for matrix multiplication) except for the case of computing PAQ , for which non-oblivious algorithms can outperform oblivious ones, and integer multiplication, where our lower bound is a polylogarithmic factor below the known straight-line bound. Some of the tradeoffs are proved for expected time and space, where all inputs are equally likely.

A time-space tradeoff for Boolean matrix multiplication

A time-space tradeoff is established in the branching program model for the problem of computing the product of two n*n matrices over a certain semiring. It is assumed that each element of each n*n input matrix is chosen independently to be 1 with probability n/sup -1/2/ and to be 0 with probability 1-n/sup -1/2/. Letting S and T denote expected space and time of a deterministic algorithm, the tradeoff is ST= Omega (n/sup 3.5/) for T<c/sub 1/n/sup 2.5 /and ST Omega (n/sup 3/) for T<c/sub 2/n/sup 2.5/, where c/sub 1/,/sub /c/sub 2/ >0. The lower bounds are matched to within a logarithmic factor by upper bounds in the branching program model. Thus, the tradeoff possesses a sharp break at T= Theta (n/sup 2.5/). These expected case lower bounds are also the best known lower bounds for the worst case.<<ETX>>

Time-space tradeoffs for branching programs contrasted with those for straight-line programs

This paper establishes time-space tradeoffs for some algebraic problems in the branching program model. For a finite field F, convolution of n-vectors over F requires ST = Θ(n2 log |F|), where S is space and T is time, in good agreement with corresponding results for straightline programs. Our result for n × n matrix multiplication over F, ST2 = Θ(n6 log |F|), is stronger than the previously known bound ST = Ω(n3) for straight-line and branching programs. The problem of computing PAQ, where P and Q are n × n permutation matrices and A is a particular matrix, requires Ω(n3) ≤ ST ≤ O(n3logn) for branching programs, in contrast to ST = Ω(n4) for straight-line programs.

Randomized function evaluation on a ring

AbstractLetR be a unidirectional asynchronous ring ofn identical processors each with a single input bit. Letf be any cyclic nonconstant function ofn boolean variables. Moran and Warmuth (1986) prove that anydeterministic algorithm that evaluatesf onR has communication complexity Ω (n logn) bits. They also construct a family of cyclic nonconstant boolean functions that can be evaluated inO(n logn) bits by a deterministic algorithm.This contrasts with the following new results:1.There exists a family of cyclic nonconstant boolean functions which can be evaluated with expected complexity

Probabilistic leader election on rings of known size

O(n\sqrt {\log n} )