Showing papers on "Graph (abstract data type) published in 1990"

Robot Motion Planning

Abstract: 1 Introduction and Overview.- 2 Configuration Space of a Rigid Object.- 3 Obstacles in Configuration Space.- 4 Roadmap Methods.- 5 Exact Cell Decomposition.- 6 Approximate Cell Decomposition.- 7 Potential Field Methods.- 8 Multiple Moving Objects.- 9 Kinematic Constraints.- 10 Dealing with Uncertainty.- 11 Movable Objects.- Prospects.- Appendix A Basic Mathematics.- Appendix B Computational Complexity.- Appendix C Graph Searching.- Appendix D Sweep-Line Algorithm.- References.

Graph-set analysis of hydrogen-bond patterns in organic crystals

Abstract: A method is presented based on graph theory for categorizing hydrogen-bond motifs in such a way that complex hydrogen-bond patterns can be disentangled, or decoded, systematically and consistently. This method is based on viewing hydrogen-bond patterns topologically as if they were intertwined nets with molecules as the nodes and hydrogen bonds as the lines. Surprisingly, very few parameters are needed to define the hydrogen-bond motifs comprising these networks. The methods for making these assignments, and examples of their chemical utility are given.

Dynamic program slicing

Abstract: Program slices are useful in debugging, testing, maintenance, and understanding of programs. The conventional notion of a program slice, the static slice, is the set of all statements that might affect the value of a given variable occurrence. In this paper, we investigate the concept of the dynamic slice consisting of all statements that actually affect the value of a variable occurrence for a given program input. The sensitivity of dynamic slicing to particular program inputs makes it more useful in program debugging and testing than static slicing. Several approaches for computing dynamic slices are examined. The notion of a Dynamic Dependence Graph and its use in computing dynamic slices is discussed. The Dynamic Dependence Graph may be unbounded in length; therefore, we introduce the economical concept of a Reduced Dynamic Dependence Graph, which is proportional in size to the number of dynamic slices arising during the program execution.

Algorithms in C

Abstract: Algorithms in C is a comprehensive repository of algorithms, complete with code. If you're in a pinch and need to code something up fast, this book is the place to look. Starting with basic data structures, Algorithms in C covers an enormous scope of information, with extensive treatment of searching and advanced data structures, sorting, string processing, computational geometry, graph problems, and mathematical algorithms. Although the manual often neglects to provide rigorous analysis, the text surrounding the algorithms provides clear and relevant insight into why the algorithms work.

AND/OR graph representation of assembly plans

Abstract: A compact representation of all possible assembly plans of a given product using AND/OR graphs is presented. Such a representation forms the basis for efficient planning algorithms that make possible an increase in assembly system flexibility by allowing an intelligent robot to pick a course of action according to instantaneous conditions. The AND/OR graph is equivalent to a state transition graph but requires fewer nodes and simplifies the search for feasible plans. Three applications are discussed: the preselection of the best assembly plan, the recovery from execution errors, and the opportunistic scheduling of tasks. A hypothetical error situation in the assembly of the four-part assembly is discussed to show how a bottom-up search of the AND/OR graph leads to an efficient recovery. The scheduling efficiency using this representation is compared with fixed sequence and precedence graph representations. >

Memory Efficient Algorithms for the Verification of Temporal Properties

Abstract: This article addresses the problem of designing memory-efficient algorithms for the verification of temporal properties of finite-state programs. Both the programs and their desired temporal properties are modeled as automata on infinite words (Buchi automata). Verification is then reduced to checking the emptiness of the automaton resulting from the product of the program and the property. This problem is usually solved by computing the strongly connected components of the graph representing the product automaton. Here, we present algorithms that solve the emptiness problem without explicitly constructing the strongly connected components of the product graph. By allowing the algorithms to err with some probability, we can implement them with a randomly accessed memory of size O(n) bits, where n is the number of states of the graph, instead of O(n log n) bits that the presently known algorithms require.

The priority-based coloring approach to register allocation

Abstract: Global register allocation plays a major role in determining the efficacy of an optimizing compiler. Graph coloring has been used as the central paradigm for register allocation in modern compilers. A straightforward coloring approach can suffer from several shortcomings. These shortcomings are addressed in this paper by coloring the graph using a priority ordering. A natural method for dealing with the spilling emerges from this approach. The detailed algorithms for a priority-based coloring approach are presented and are contrasted with the basic graph-coloring algorithm. Various extensions to the basic algorithms are also presented. Measurements of large programs are used to determine the effectiveness of the algorithm and its extensions, as well as the causes of an imperfect allocation. Running time of the allocator and the impact of heuristics aimed at reducing that time are also measured.

Simulation Approaches to General Probabilistic Inference on Belief Networks

Abstract: A number of algorithms have been developed to solve probabilistic inference problems on belief networks. These algorithms can be divided into two main groups: exact techniques which exploit the conditional independence revealed when the graph structure is relatively sparse, and probabilistic sampling techniques which exploit the “conductance” of an embedded Markov chain when the conditional probabilities have non-extreme values. In this paper, we investigate a family of “forward” Monte Carlo sampling techniques similar to Logic Sampling [Henrion, 1988] which appear to perform well even in some multiplyconnected networks with extreme conditional probabilities, and thus would be generally applicable. We consider several enhancements which reduce the posterior variance using this approach and propose a framework and criteria for choosing when to use those enhancements.

Dynamic programming and influence diagrams

Abstract: The concept of a super value node is developed to extend the theory of influence diagrams to allow dynamic programming to be performed within this graphical modeling framework. The operations necessary to exploit the presence of these nodes and efficiently analyze the models are developed. The key result is that by representing value function separability in the structure of the graph of the influence diagram, formulation is simplified and operations on the model can take advantage of the separability. From the decision analysis perspective, this allows simple exploitation of separability in the value function of a decision problem. This allows algorithms to be designed to solve influence diagrams that automatically recognize the opportunity for applying dynamic programming. From the decision processes perspective, influence diagrams with super value nodes allow efficient formulation and solution of nonstandard decision process structures. They also allow the exploitation of conditional independence between state variables. >

Neural Network Design and the Complexity of Learning

Abstract: We formalize a notion of learning that characterizes the training of feed-forward networks. In the field of learning theory, it stands as a new model specialized for the type of learning problems that arise in connectionist networks. The formulation is similar to Valiant's (Val84) in that we ask what can be feasibly learned from examples and stored in a particular data structure. One can view the data structure resulting from Valiant-type learning as a 'sentence' in a language described by grammatical syntax rules. Neither the words nor their interrelationships are known a priori. Our learned data structure is more particular than Valiant's in that it must be a particular 'sentence'. The position and relationships of each 'word' are fully specified in advance, and the learning system need only discover what the missing words are. This corresponds to the problem of finding retrieval functions for each node in a given network. We prove this problem NP-complete and thus demonstrate that learning in networks has no efficient general solution. Corollaries to the main theorem demonstrate the NP-completeness of several sub-cases. While the intractability of the problem precludes its solution in all these cases, we sketch some alternative definitions of the problem in a search for tractable sub-cases. One broad class of subcases is formed by placing constraits on the network architecture; we study one type in particular. The focus of these constraints is on families of 'shallow' architectures which are defined to have bounded depth and unbounded width. We introduce a perspective on shallow networks, called the Support Cone Interaction (SCI) graph, which is helpful in distinguishing tractable from intractable subcases: When the SCI graph has tree-width O(log n), learning can be accomplished in polynomial time; when its tree-width is $n\sp{\Omega (1)}$ we find the problem NP-complete even if the SCI graph is a simple 2-dimensional planar grid.

Methods for set up and programming of machine and process controllers

Abstract: Graphical editing methods are employed to construct programs in high-level graphical languages prior to compilation and operation in controllers for industrial or commercial equipment. The editing methods include process, hardware and program editing tasks for defining both process and hardware I/O points and connecting them to variables in a controller program. Each editing task has a tree graph window, a graph editing window, and a palette with rotating panels of graphical editing tools. The hardware editing taks uses two-layered icons to graphically simulate the hardware environment. A plurality of graph types are based on generalized node-vert-arc graphical elements which are special classes programmed in the Smalltalk programming language. Languages for the controller program include function block, sequential function chart and ladder diagram.

Algorithms for discrete function manipulation

Abstract: An investigation was made of the analogous graph structure for representing and manipulating discrete variable problems. The authors define the multi-valued decision diagram (MDD), analyze its properties (in particular prove a strong canonical form) and provide algorithms for combining and manipulating MDDs. They give a method for mapping an MDD into an equivalent BDD (binary decision diagram) which allows them to provide a highly efficient implementation using the previously developed BDD packages. A direct implementation of the MDD structure has also been carried out, but this initial implementation has not yet been tuned to the same extent as the BDDs to allow a reasonable comparison to be made. The authors have used the mapping to BDDs to provide an initial understanding of the limits on the sizes of real problems that can be executed. The results are encouraging. >

Graphic display of network topology

Abstract: A system for automatically laying out and graphically displaying the topology of a computer network system. The layout system retrieves a list of the nodes within the network and their interconnections from a database which can be manually built by a network administrator or automatically constructed by other software. The system will provide any of three views that can be requested by the user. An internet view is the largest and shows the interconnection of different networks. A network view can be shown for any of the networks described in the internet view. A network is comprised of segments and the system will display a view of the nodes connected to any one of the segments. The system will automatically update the view as new nodes become available in the database. This aspect of the system and allows the system to dynamically update the graph when the list of nodes is being supplied by other software. The system also allows the user to dynamically alter the graph by using a graphical input device to move any of the objects displayed on the graph.

A Monte-Carlo algorithm for path planning with many degrees of freedom

Abstract: A stochastic technique is described for planning collision-free paths of robots with many degrees of freedom (DOFs). The algorithm incrementally builds a graph connecting the local minima of a potential function defined in the robot's configuration space and concurrently searches the graph until a goal configuration is attained. A local minimum is connected to another one by executing a random motion that escapes the well of the first minimum, succeeded by a gradient motion that follows the negated gradient of the potential function. All the motions are executed in a grid shown through the robot's configuration space. The random motions are implemented as random walks which are known to converge toward Brownian motions when the steps of the walks tend toward zero. The local minima graph is searched using a depth-first strategy with random backtracking. In the technique, the planner does not explicitly represent the local-minima graph. The path-planning algorithm has been fully implemented and has run successfully on a variety of problems involving robots with many degrees of freedom. >

A graph-oriented object database model

Abstract: A simple, graph-oriented database model, supporting object-identity, is presented. For this model, a transformation language based on elementary graph operations is defined. This transformation language is suitable for both querying and updates. It is shown that the transformation language supports both set-operations (except for the powerset operator) and recursive functions.

Load balancing and Poisson equation in a graph

Abstract: We present a fully distributed dynamic load balancing algorithm for parallel MIMD architectures. The algorithm can be described as a system of identical parallel processes, each running on a processor of an arbitrary interconnected network of processors. We show that the algorithm can be interpreted as a Poisson (heath) equation in a graph. This equation is analysed using Markov chain techniques and is proved to converge in polynomial time resulting in a global load balance. We also discuss some important parallel architectures and interconnection schemes such as linear processor arrays, tori, hypercubes, etc. Finally we present two applications where the algorithm has been successfully embedded (process mapping and molecular dynamic simulation).

Data-flow multiprocessor architecture with three dimensional multistage interconnection network for efficient signal and data processing

Abstract: A data-flow architecture and software environment for high-performance signal and data procesing. The programming environment allows applications coding in a functional high-level language 20 which a compiler 30 converts to a data-flow graph form 40 which a global allocator 50 then automatically partitions and distributes to multiple processing elements 80, or in the case of smaller problems, coding in a data-flow graph assembly language so that an assembler 15 operates directly on an input data-flow graph file 13 and produces an output which is then sent to a local allocator 17 for partitioning and distribution. In the former case a data-flow processor description file 45 is read into the global allocator 50, and in the latter case a data-flow processor description file 14 is read into the assembler 15. The data-flow processor 70 consists of multiple processing elements 80 connected in a three-dimensional bussed packet routing network. Data enters and leaves the processor 70 via input/output devices 90 connected to the processor. The processing elements are designed for implementation in VLSI (Very large scale integration) to provide realtime processing with very large throughput. The modular nature of the computer allows adding more processing elements to meet a range of throughout and reliability requirements. Simulation results have demonstrated high-performance operation, with over 64 million operations per second being attainable using only 64 processing elements.

Constant time algorithms for the transitive closure and some related graph problems on processor arrays with reconfigurable bus systems

Abstract: The transitive closure problem in O(1) time is solved by a new method that is far different from the conventional solution method. On processor arrays with reconfigurable bus systems, two O(1) time algorithms are proposed for computing the transitive closure of an undirected graph. One is designed on a three-dimensional n*n*n processor array with a reconfigurable bus system, and the other is designed on a two-dimensional n/sup 2/*n/sup 2/ processor array with a reconfigurable bus system, where n is the number of vertices in the graph. Using the O(1) time transitive closure algorithms, many other graph problems are solved in O(1) time. These problems include recognizing bipartite graphs and finding connected components, articulation points, biconnected components, bridges, and minimum spanning trees in undirected graphs. >

A graph based knowledge retrieval system

Abstract: The development of a natural language knowledge retrieval (NLKR) system of building an intelligent help prototype is outlined The objectives of NLKR systems are defined A general architecture, the main components of which are a semantic interpreter, a query processor, and a natural language generator, is proposed The current implementation of an NLKR system, called GKR (graph-based knowledge retrieval) system, is described The GKR system is based on the use of conceptual graphs as a knowledge representation scheme Query processing is treated as a graph matching process, and retrieval is performed by a semantic-based search The query processor uses an algorithm that automatically generates additional queries (subgoals) in conceptual graph form The GKR system is implemented in Prolog Its possible integration into hypertext environments is described Related work is discussed >

Very simple methods for all pairs network flow analysis

Abstract: A very simple algorithm for the classical problem of computing the maximum network flow value between every pair of nodes in an undirected, capacitated n node graph is presented; as in the well-known Gomory–Hu method, the method given here uses only $n - 1$ maximum flow computations Our algorithm is implemented by adding only five simple lines of code to any program that produces a minimum cut; a program to produce an equivalent flow tree, which is a compact representation of the flow values, is obtained by adding only three simple lines of code to any program producing a minimum cut A very simple version of the Gomory–Hu cut tree method that finds one minimum cut for every pair of nodes is also derived, and it is shown that the seemingly fundamental operation of that method, node contraction, is not needed, nor must crossing cuts be avoided As a result, this version of the Gomory–Hu method is implemented by adding less than ten simple lines of code to any program that produces a minimum cut The algor

The combination of scheduling, allocation, and mapping in a single algorithm

Abstract: A single high-level synthesis algorithm is presented that schedules the operations of a data dependence graph, allocates the necessary hardware and maps the operations to specific functional units. This is achieved by extending the global analysis approach developed for force-directed scheduling to include individual module instances. This new algorithm should be applicable to any behavioral synthesis system that schedules operations from a data dependence graph. >

Fractional balanced reduction: model reduction via fractional representation

Abstract: A method for the model reduction of finite-dimensional, linear, time-invariant (FDLTI) plants is proposed which uses normalized fractional representations is proposed. The method, dubbed fractional balanced reduction, applies balance and truncate to a special representation of the graph operator of the plant. This operation yields the graph operator of a reduced order plant. The method has such properties as existence of an a priori error bound in the graph metric and preservation of sector containment. Coupling fractional representations with principal component analysis gives a model reduction method that is capable of producing, in a numerically stable way, a good reduced order model using the whole full order model. Sector properties are also preserved-these are useful for deciding stability when nonlinearities are in the loop. >

Computational chemical graph theory

Abstract: The outcome of an American Chemical Society Conference Symposium held in Los Angeles, Sept. 1988. Chemical graph theory is a branch of mathematical chemistry that has concerned itself with the mathematical description and characterization of molecular species, notational schemes and the enumeration

Deciding properties of timed transition models

Abstract: Real-time distributed systems are modeled by a times transition model (TTM). For any finite-state TTM, decision procedures are provided for checking a small but important class of properties (specified in real-time temporal logic). The procedures are linear in the size of the system reachability graph. The class of properties includes invariance, precedence, eventuality and real-time response specifications. >

Direct transitive closure algorithms: design and performance evaluation

Abstract: We present new algorithms for computing transitive closure of large database relations. Unlike iterative algorithms, such as the seminaive and logarithmic algorithms, the termination of our algorithms does not depend on the length of paths in the underlying graph (hence the name direct algorithms). Besides reachability computations, the proposed algorithms can also be used for solving path problems. We discuss issues related to the efficient implementation of these algorithms, and present experimental results that show the direct algorithms perform uniformly better than the iterative algorithms. A side benefit of this work is that we have proposed a new methodology for evaluating the performance of recursive queries.

EDGE: an extendable graph editor

Abstract: EDGE is an editor kernel for the direct and visual manipulation of graphs. The kernel can be adapted quickly to diverse applications based on graphs, such as PERT chart editing, directory browsing, call graph display, logic circuit simulation or configuration visualization. EDGE provides potential solutions to the following general problems faced by any graph editor. (1) Automatic graph layout: how can application-specific layout requirements, individual preferences, and layout stability be integrated with automatic layout algorithms? EDGE solves this problem with a novel algorithm that is based on layout constraints. (2) Graph abstraction: how can users deal with large graphs containing hundreds of nodes and edges, and thousands of edge crossings? EDGE can reduce the apparent complexity with subgraph abstractions and a novel clustering technique called edge concentration. (3) Adaptability: how should the editor kernel be structured to be adaptable to various applications? EDGE uses a special graph representation language for specifying visual appearance and the inheritance mechanism of C++ to achieve extendibility. (4) Persistence of graphs: how can the graph structures produced by the editor be kept in long-term storage, especially if the node and edge data structures have been extended for a particular application? Our approach uses a standardized, external format for graphs and handles extensions with program generator technology: the I/O routines for reading and writing extended node and edge data structures are produced automatically from the declarations of these data structures. This paper describes EDGE and presents details of the above solutions.