We present two new data structure tools---disjoint set union with bottom-up linking, and pointer-based radix sort---and combine them with bottom-level microtrees to devise the first linear-time pointer-machine algorithms for off-line least common ancestors, minimum spanning tree (MST) verification, randomized MST construction, and computing dominators in a flowgraph.

We introduce the tree cross-product problem, which abstracts a data structure common to applications in graph visualization, string matching, and software analysis. We design solutions with a variety of tradeoffs, yielding improvements and new results for these applications.

This paper explores the concept of loops and loop nesting forests of control-flow graphs, using the problem of constructing the dominator tree of a graph and the problem of computing the iterated dominance frontier of a set of vertices in a graph as guiding applications. The contributions of this paper include: (1) An axiomatic characterization, as well as a constructive characterization, of a family of loop nesting forests that includes various specific loop nesting forests that have been previously defined. (2) The definition of a new loop nesting forest, as well as an e#cient, almost linear time, algorithm for constructing this forest. (3) An illustration of how loop nesting forests can be used to transform arbitrary (potentially irreducible) problem instances into equivalent acylic graph problem instances in the case of the two problems of (a) constructing the dominator tree of a graph, and (b) computing the iterated dominance frontier of a set of vertices in a graph, leading to new, almost linear time, algorithms for these problems

Abstract. Formal verification methods model systems by Kripke structures. In order to model live behaviors of systems, Kripke structures are augmented with fairness conditions. Such conditions partition the computations of the systems into fair computations, with respect to which verification proceeds, and unfair computations, which are ignored. Reasoning about Kripke structures augmented with fairness is typically harder than reasoning about non-fair Kripke structures. We consider the transition fairness condition, where a computation π is fair iff each transition that is enabled in π infinitely often is also taken in π infinitely often. Transition fairness is a natural and useful fairness condition. We show that reasoning about Kripke structures augmented with transition fairness is not harder than reasoning about non-fair Kripke structures. We demonstrate it for fair CTL and LTL model checking, and the problem of calculating the dominators and postdominators. 1

We consider the following decision problems: PROOFNET: Given a multiplicative linear logic (MLL) proof structure, is it a proof net? ESSNET: Given an essential net (of an intuitionistic MLL sequent), is it correct? In this paper we show that linear-time algorithms for ESS-NET can be obtained by constructing the dominator tree of the input essential net. As a corollary, by showing that PROOFNET is linear-time reducible to ESSNET (by the trip translation), we obtain a linear-time algorithm for PROOFNET. We show further that these linear-time algorithms can be optimized to simple one-pass algorithms – each node of the input structure is visited at most once. As another application of dominator trees, we obtain lineartime algorithms for sequentializing proof nets (i.e. given a proof net, find a derivation for the underlying MLL sequent) and essential nets.

Abstract. The computation of dominators in a flowgraph has applications in program optimization, circuit testing, and other areas. Lengauer and Tarjan [17] proposed two versions of a fast algorithm for finding dominators and compared them experimentally with an iterative bit vector algorithm. They concluded that both versions of their algorithm were much faster than the bit-vector algorithm even on graphs of moderate size. Recently Cooper et al. [9] have proposed a new, simple, tree-based iterative algorithm. Their experiments suggested that it was faster than the simple version of the Lengauer-Tarjan algorithm on graphs representing computer program control flow. Motivated by the work of Cooper et al., we present an experimental study comparing their algorithm (and some variants) with careful implementations of both versions of the Lengauer-Tarjan algorithm and with a new hybrid algorithm. Our results suggest that, although the performance of all the algorithms is similar, the most consistently fast are the simple Lengauer-Tarjan algorithm and the hybrid algorithm, and their advantage increases as the graph gets bigger or more complicated. 1

Operations of today’s large corporations are usually supported by complex software infrastructures that involve hundreds or thousands of software systems. Companies frequently need to redesign their software infrastructures in response to changes in the marketplace. This paper describes Enterprise Navigator, a system that allows architects to visualize system interconnections of selected products and services by making database queries on the web. Moreover, analysis tools are provided for the architects to examine dominating information flows, perform clustering analysis to find substructures, and study the structural evolution of particular business processes or functions. The system has been used extensively on AT&T’s System Profile Database (SPDB). A case study is included in this paper to show how an architect can use Enterprise Navigator to perform various visualization and analysis tasks.

We present a linear-time algorithm that given a flowgraph G = (V, A, r) and a tree T, checks whether T is the dominator tree of G. Also we prove that there exist two spanning trees of G, T1 and T2, such that for any vertex v the paths from r to v in T1 and T2 intersect only at the vertices that dominate v. The proof is constructive and our algorithm can build the two spanning trees in linear time. Simpler versions of our two algorithms run in O(mα(m, n))time, where n is the number of vertices and m is the number of arcs in G. The existence of such two spanning trees implies that we can order the calculations of the iterative algorithm for finding dominators, proposed by Allen and Cocke [2], so that it builds the dominator tree in a single iteration.

This article focuses on the latter

In this thesis, we consider the following problem: Given a strongly connected digraph G = (V, E), where V is the set of vertices and E is the set of edges, “is it a minimal strong connected digraph?”. A reducible edges e is one for which G−e is strongly connected. A minimal strongly connected digraph is one with no reducible edges. Our approach is to apply depth first search on G to generate a depth first search tree and the sets of back, forward, and cross edges. Then we determine if there are any reducible non-tree edges. If not, we then check if there are any reducible tree edges based on an algorithm for finding immediate dominators. We have implemented the algorithm and report experimental results that show the algorithm can handle large digraphs quickly.