Richard B. Borie

Automatic generation of linear-time algorithms from predicate calculus descriptions of problems on recursively constructed graph families

This paper describes a predicate calculus in which graph problems can be expressed. Any problem possessing such an expression can be solved in linear time on any recursively constructed graph, once its decomposition tree is known. Moreover, the linear-time algorithm can be generatedautomatically from the expression, because all our theorems are proved constructively. The calculus is founded upon a short list of particularly primitive predicates, which in turn are combined by fundamental logical operations. This framework is rich enough to include the vast majority of known linear-time solvable problems.We have obtained these results independently of similar results by Courcelle [11], [12], through utilization of the framework of Bernet al. [6]. We believe our formalism is more practical for programmers who would implement the automatic generation machinery, and more readily understood by many theorists.

Automated flow graph-based testing of object-oriented software modules

Abstract Classes represent the fundamental building blocks in object-oriented software development. Several techniques have been proposed for testing classes. However, most of these techniques are heavily specification based, in the sense that they demand the existence of formal specifications for the module. In addition, most existing techniques generate test cases at random rather than systematically. We present some test case generation techniques that are based entirely on class implementation, involve systematic generation of test cases, and are fully automated. Our techniques are based on an adaptation of existing white-box, flow graph-based techniques for unit testing conventional procedures and functions. We also provide a general conceptual framework to support the modeling of classes using flow graphs. Our framework clarifies the fundamental definitions and concepts associated with this method for modeling classes.

Generation of polynomial-time algorithms for some optimization problems on tree-decomposable graphs

Recent work in the design of efficient algorithms for optimization problems on treedecomposable graphs concentrates on developing general approaches which lead to families of related algorithms, rather than on developing isolatedad hoc algorithms. This paper develops new general approaches to obtain two new families of related polynomial-time algorithms for (1) packing, partitioning, and covering problems and (2) multiset and multiproperty problems. These problems have not been handled by previous general approaches.

Deterministic decomposition of recursive graph classes

The popular class of series-parallel graphs can be built recursively from single edges by combining smaller components via connections only at a fixed pair of vertices called terminals. This recursive construction property with a limited number of terminals is essential to the linear time solution of problems on these graphs. A second useful property of these graphs is that decomposition is deterministic with respect to the series-parallel rules. This implies that the parse-tree of decomposition (which is required by the algorithms) can be determined in a straightforward manner by repeatedly applying the decomposition rules. Subject to retaining these properties, we examine how far the series-parallel graphs can be generalized. Corollaries of our results yield the deterministic decomposition of the series-parallel and Halin graph classes.

Solving problems on recursively constructed graphs

Fast algorithms can be created for many graph problems when instances are confined to classes of graphs that are recursively constructed. This article first describes some basic conceptual notions regarding the design of such fast algorithms, and then the coverage proceeds through several recursive graph classes. Specific classes include trees, series-parallel graphs, <i>k</i>-terminal graphs, treewidth-<i>k</i> graphs, <i>k</i>-trees, partial <i>k</i>-trees, <i>k</i>-jackknife graphs, pathwidth-<i>k</i> graphs, bandwidth-<i>k</i> graphs, cutwidth-<i>k</i> graphs, branchwidth-<i>k</i> graphs, Halin graphs, cographs, cliquewidth-<i>k</i> graphs, <i>k</i>-NLC graphs, <i>k</i>-HB graphs, and rankwidth-<i>k</i> graphs. The definition of each class is provided. Typical algorithms are applied to solve problems on instances of most classes. Relationships between the classes are also discussed.

Algorithms and complexity results for graph-based pursuit evasion

We study the classical edge-searching pursuit-evasion problem where a number of pursuers have to clear a given graph of fast-moving evaders despite poor visibility, for example, where robots search a cave system to ensure that no terrorists are hiding in it. We study when polynomial-time algorithms exist to determine how many robots are needed to clear a given graph (minimum robot problem) and how a given number of robots should move on the graph to clear it with either a minimum sum of their travel distances (minimum distance problem) or minimum task-completion time (minimum time problem). The robots cannot clear a graph if the vertex connectivity of some part of the graph exceeds the number of robots. Researchers therefore focus on graphs whose subgraphs can always be cut at a limited number of vertices, that is, graphs of low treewidth, typically trees. We describe an optimal polynomial-time algorithm, called CLEARTHETREE, that is shorter and algorithmically simpler than the state-of-the-art algorithm for the minimum robot problem on unit-width unit-length trees. We then generalize prior research to both unit-width arbitrary-length and unit-length arbitrary-width graphs and derive both algorithms and time complexity results for a variety of graph topologies. Pursuit-evasion problems on the former graphs are generally simpler than pursuit-evasion problems on the latter graphs. For example, the minimum robot and distance problems are solvable in polynomial time on unit-width arbitrary-length trees but NP-hard on unit-length arbitrary-width trees.

Scheduling on-demand broadcast with timing constraints

In a distributed system, broadcasting is an efficient way to dispense data in certain highly dynamic environments. While there are several well-known on-line broadcast scheduling strategies that minimize wait time, there has been little research that considers on-demand broadcasting with timing constraints. One application which could benefit from a strategy for on-demand broadcast with timing constraints is a real-time database system. Scheduling strategies are needed in real-time databases that identify which data item to broadcast next in order to minimize missed deadlines. The scheduling decisions required in a real-time broadcast system allow the system to be modeled as a Markov Decision Process (MDP). In this paper, we analyze the MDP model and determine that finding an optimal solution is a hard problem in PSPACE. We propose a scheduling approach, called Aggregated Critical Requests (ACR), which is based on the MDP formulation and present two algorithms based on this approach. ACR is designed for timely delivery of data to clients in order to maximize the reward by minimizing the deadlines missed. Results from trace-driven experiments indicate the ACR approach provides a flexible strategy that can outperform existing strategies under a variety of factors.

An integrated first-year curriculum for computer science and computer engineering

The University of Alabama has developed an integrated first-year curriculum for engineering students consisting primarily of an integrated block of mathematics, physics, chemistry, and engineering design. While this curriculum is highly appropriate (and successful) for most engineering majors, it does not meet the needs of a computer engineering (or computer science) major nearly as well. Recognizing this, the Departments of Computer Science and Electrical and Computer Engineering received funding under NSFs Course and Curriculum Development Program to generate an integrated introduction to the discipline of computing. The revised curriculum provides a five-hour block of instruction (each semester) in computer hardware, software development, and discrete mathematics. At the end of this three-semester sequence, students will have completed the equivalent of CS I and CS II, a digital logic course, an introductory sequence in computer organization and assembly language, and a discrete mathematics course. The revised curriculum presents these same materials in an integrated block of instruction. As one simple example, the instruction of basic data types in the software course (encountered early in the freshman year) is accompanied by machine representation of numbers (signed binary, one and twos complement) in the hardware course, and by arithmetic in different bases in the discrete mathematics course. It also integrates cleanly with the Foundation Coalitions freshman year, and provides a block of instruction that focuses directly upon the discipline of computing.

Algorithms for recognition of regular properties and decomposition of recursive graph families

This paper focuses on two themes within the broad context of recursively definable graph classes. First, we generalize the series-parallel operations and establish exactly how far they can be extended subject to some consistency conditions. We show explicitly how Halin graphs are included in the extension. Second, for recursively constructed graphs in general, we construct a predicate calculus within which graph problems can be stated and for those so stated, a linear time algorithm exists and can be automatically generated. We discuss some issues related to practical automatic generation.

File replication in video on demand services

A large-scale video-on-demand (VOD) system demands storage of hundreds of movies and support of thousands of concurrent accesses. The number of concurrent accesses to each movie may vary, depending on the popularity of each movie. File replication problem is concerned with how to replicate, and place the movie files over a number of magnetic disk arrays such that a given access profile can be supported at a minimum cost. This is an NP-hard combinatorial problem. However with its similarity to a transportation model, we develop a transportation-type algorithm to generate a good solution in an effective and convenient form. The computational results show that the proposed algorithm outperforms the existing greedy placement algorithm.