In the past 20 years there has been treftlendous progress in developing and analyzing parallel algorithftls. Researchers have developed efficient parallel algorithms to solve most problems for which efficient sequential solutions are known. Although some ofthese algorithms are efficient only in a theoretical framework, many are quite efficient in practice or have key ideas that have been used in efficient implementations. This research on parallel algorithms has not only improved our general understanding ofparallelism but in several cases has led to improvements in sequential algorithms. Unf:ortunately there has been less success in developing good languages f:or prograftlftling parallel algorithftls, particularly languages that are well suited for teaching and prototyping algorithms. There has been a large gap between languages

We prove that the graph isomorphism problem restricted to trees and to colored graphs with color multiplicities 2 and 3 is many-one complete for several complexity classes within NC². In particular we show that tree isomorphism, when trees are encoded as strings, is NC¹-hard under AC0-reductions. NC¹-completeness thus follows from Buss's NC¹ upper bound. By contrast, we prove that testing isomorphism of two trees encoded as pointer lists is L-complete. Concerning colored graphs we show that the isomorphism problem for graphs with color multiplicities 2 and 3 is complete for symmetric logarithmic space SL under many-one reductions. This result improves the existing upper bounds for the problem. We also show that the graph automorphism problem for colored graphs with color classes of size 2 is equivalent to deciding whether a graph has more than a single connected component and we prove that for color classes of size 3 the graph automorphism problem is contained in SL.

Self-adjusting computation offers a language-centric approach to writing programs that can automatically respond to modifications to their data (e.g., inputs). Except for several domain-specific implementations, however, all previous implementations of self-adjusting computation assume mostly functional, higher-order languages such as Standard ML. Prior to this work, it was not known if self-adjusting computation can be made to work with low-level, imperative languages such as C without placing undue burden on the programmer. We describe the design and implementation of CEAL: a C-based language for self-adjusting computation. The language is fully general and extends C with a small number of primitives to enable writing self-adjusting programs in a style similar to conventional C programs. We present efficient compilation techniques for translating CEAL programs into C that can be compiled with existing C compilers using primitives supplied by a run-time library for self-adjusting computation. We implement the proposed compiler and evaluate its effectiveness. Our experiments show that CEAL is effective in practice: compiled self-adjusting programs respond to small modifications to their data by orders of magnitude faster than recomputing from scratch while slowing down a from-scratch run by a moderate constant factor. Compared to previous work, we

The tree isomorphism problem is the problem of determining whether two trees are isomorphic. The tree canonization problem is the problem of producing a canonical tree isomorphic to a given tree. The tree comparison problem is the problem of determining whether one tree is less than a second tree in a natural ordering on trees. We present alternating logarithmic time algorithms for the tree isomorphism problem, the tree canonization problem and the tree comparison problem. As a consequence, there is a recursive enumeration of the alternating log time tree problems.

Parallel tree contraction has been found to be a useful and quite powerful tool for the design of a wide class of efficient graph algorithms. We propose a corresponding technique for the parallel solution of problems with incremental changes in the data. In dynamic tree contraction problems, we are given an initial tree T, and then an on-line algorithm processes requests regarding T. Requests may be either incremental changes to T or requests for certain values computed using the tree. A simple example is maintaining the pre-order numbering on a tree. The on-line algorithm would then have to handle incremental changes to the tree, and would also have to quickly answer queries about the pre-order number of any tree node. Our dynamic algorithms are based on the prior parallel tree contraction algorithms, and hence we call such algorithms incremental tree contraction algorithms. By maintaining the connection between our incremental algorithms and the parallel tree contraction algorithm, we create incremental algorithms for tree contraction. We consider a dynamic binary tree T of ≤ n nodes and unbounded depth. We describe a procedure, which we call the dynamic parallel tree contraction algorithm, which incrementally processes various parallel modification requests and queries: (1) parallel requests to add or delete leaves of T, or modify labels of internal nodes or leaves of T, and also (2) parallel tree contraction queries which require recomputing values at specified nodes. Each modification or query is with respect to a set of nodes U in T. We make use of a random splitting tree as an aid

The isomorphism problem for planar graphs is known to be efficiently solvable. For planar 3-connected graphs, the isomorphism problem can be solved by efficient parallel algorithms, it is in the class AC¹. In this paper we improve the upper bound for planar 3-connected graphs to unambiguous logspace, in fact to UL ∩ coUL. As a consequence of our method we get that the isomorphism problem for oriented graphs is in NL. We also show that the problems are hard for L.

We show that the isomorphism of 3-connected planar graphs can be decided in deterministic log-space. This improves the previously known bound UL ∩ coUL of [13].

We give an algorithm that for an input n-vertex graph G and integer k> 0, in time O(c k n) either outputs that the treewidth of G is larger than k, or gives a tree decomposition of G of width at most 5k + 4. This is the first algorithm providing a constant factor approximation for treewidth which runs in time single-exponential in k and linear in n. Treewidth based computations are subroutines of numerous algorithms. Our algorithm can be used to speed up many such algorithms to work in time which is single-exponential in the treewidth and linear in the input size.

In this note we prove that the tree isomorphism problem, when trees are encoded as strings, is NC¹-hard under DLOGTIME-reductions. NC¹-completeness thus follows from Buss's recent NC¹ upper bound. By contrast, we prove that testing isomorphism of two trees encoded as pointer lists is L-complete.

Abstract We give an algorithm for isomorphism testing of planar graphs suitable for practical implementation. The algorithm is based on the decomposition of a graph into biconnected components and further into SPQR-trees. We provide a proof of the algorithm's correctness and a complexity analysis. We determine the conditions in which the implemented algorithm outperforms other graph matchers, which do not impose topological restrictions on graphs. We report experiments with our planar graph matcher tested against McKay's, Ullmann's, and SUBDUE's (a graph-based data mining system) graph matchers.