Results 1  10
of
36
Efficient Management of Transitive Relationships
 in Large Data and Knowledge Bases,” in Proc. ACM Symp. on Management of Data (SIGMOD
, 1989
"... We argue that accessing the transitive closure of relationsbips is an important component of both databases and knowledge representation systems in Artificial Intelligence. The demands for efficient access and management of large relationships motivate the need for explicitly storing the transitive ..."
Abstract

Cited by 123 (3 self)
 Add to MetaCart
We argue that accessing the transitive closure of relationsbips is an important component of both databases and knowledge representation systems in Artificial Intelligence. The demands for efficient access and management of large relationships motivate the need for explicitly storing the transitive closure in a compressed and local way, while allowing updates to the base relation to be propagated incrementally. We present a transitive closure compression technique, based on labeling spanning trees with numeric intervals, and provide both analytical and empirical evidence of its efficacy, including a proof of optimality. 1. OVERVlEW The significance of transitive relationships has long been acknowledged in varied fields. Recently, database researchers have recognized its utility in querying databases in fact, it has been argued that transitivity is the dominant form of recursion that is of practical utility [2,24,27]. After briefly reviewing the motivation for managing large transitive relationships in databases, we present a second application arex the management and use of subclass (ISA) hierarchies
Maintenance of a Minimum Spanning Forest in a Dynamic Plane Graph
, 1992
"... We give an efficient algorithm for maintaining a minimum spanning forest of a plane graph subject to online modifications. The modifications supported include changes in the edge weights, and insertion and deletion of edges and vertices which are consistent with the given embedding. Our algorithm r ..."
Abstract

Cited by 66 (25 self)
 Add to MetaCart
We give an efficient algorithm for maintaining a minimum spanning forest of a plane graph subject to online modifications. The modifications supported include changes in the edge weights, and insertion and deletion of edges and vertices which are consistent with the given embedding. Our algorithm runs in O(log n) time per operation and O(n) space.
Fully Dynamic Algorithms for Maintaining AllPairs Shortest Paths and Transitive Closure in Digraphs
 IN PROC. 40TH IEEE SYMPOSIUM ON FOUNDATIONS OF COMPUTER SCIENCE (FOCS’99
, 1999
"... This paper presents the first fully dynamic algorithms for maintaining allpairs shortest paths in digraphs with positive integer weights less than b. For approximate shortest paths with an error factor of (2 + ffl), for any positive constant ffl, the amortized update time is O(n 2 log 2 n= log ..."
Abstract

Cited by 63 (0 self)
 Add to MetaCart
This paper presents the first fully dynamic algorithms for maintaining allpairs shortest paths in digraphs with positive integer weights less than b. For approximate shortest paths with an error factor of (2 + ffl), for any positive constant ffl, the amortized update time is O(n 2 log 2 n= log log n); for an error factor of (1 + ffl) the amortized update time is O(n 2 log 3 (bn)=ffl 2 ). For exact shortest paths the amortized update time is O(n 2:5 p b log n). Query time for exact and approximate shortest distances is O(1); exact and approximate paths can be generated in time proportional to their lengths. Also presented is a fully dynamic transitive closure algorithm with update time O(n 2 log n) and query time O(1). The previously known fully dynamic transitive closure algorithm with fast query time has onesided error and update time O(n 2:28 ). The algorithms use simple data structures, and are deterministic.
Efficient Inference of Object Types
, 1995
"... Abadi and Cardelli have recently investigated a calculus of objects [2]. The calculus supports a key feature of objectoriented languages: an object can be emulated by another object that has more refined methods. Abadi and Cardelli presented four firstorder type systems for the calculus. The simpl ..."
Abstract

Cited by 53 (6 self)
 Add to MetaCart
Abadi and Cardelli have recently investigated a calculus of objects [2]. The calculus supports a key feature of objectoriented languages: an object can be emulated by another object that has more refined methods. Abadi and Cardelli presented four firstorder type systems for the calculus. The simplest one is based on finite types and no subtyping, and the most powerful one has both recursive types and subtyping. Open until now is the question of type inference, and in the presence of subtyping "the absence of minimum typings poses practical problems for type inference" [2]. In this paper...
FirstOrder Incremental Evaluation of Datalog Queries
 Annals of Mathematics and Artificial Intelligence
, 1993
"... We consider the problem of repeatedly evaluating the same (computationally expensive) query to a database that is being updated between successive query requests. In this situation, it should be possible to use the difference between successive database states and the answer to the query in one stat ..."
Abstract

Cited by 49 (17 self)
 Add to MetaCart
We consider the problem of repeatedly evaluating the same (computationally expensive) query to a database that is being updated between successive query requests. In this situation, it should be possible to use the difference between successive database states and the answer to the query in one state to reduce the cost of evaluating the query in the next state. We use firstorder queries to compute the differences, and call this process "firstorder incremental query evaluation." After formalizing the notion of firstorder incremental query evaluation, we give an algorithm that constructs, for each regular chain query (including transitive closure as a special case), a nonrecursive program to compute the difference between the answer after an update and the answer before the update. We then extend this result to weakly regular queries, which are regular chain programs augmented with conjunctive queries having the socalled cartesianclosed increment property, and to the case of unbound...
A Fully Dynamic Algorithm for Maintaining the Transitive Closure
 In Proc. 31st ACM Symposium on Theory of Computing (STOC'99
, 1999
"... This paper presents an efficient fully dynamic graph algorithm for maintaining the transitive closure of a directed graph. The algorithm updates the adjacency matrix of the transitive closure with each update to the graph. Hence, each reachability query of the form "Is there a directed path fro ..."
Abstract

Cited by 44 (1 self)
 Add to MetaCart
This paper presents an efficient fully dynamic graph algorithm for maintaining the transitive closure of a directed graph. The algorithm updates the adjacency matrix of the transitive closure with each update to the graph. Hence, each reachability query of the form "Is there a directed path from i to j?" can be answered in O(1) time. The algorithm is randomized; it is correct when answering yes, but has O(1/n^c) probability of error when answering no, for any constant c. In acyclic graphs, worst case update time is O(n^2). In general graphs, update time is O(n^(2+alpha)), where alpha = min {.26, maximum size of a strongly connected component}. The space complexity of the algorithm is O(n^2).
Fully Dynamic Transitive Closure: Breaking Through The O(n²) Barrier
 IN PROC. IEEE SYMPOSIUM ON FOUNDATIONS OF COMPUTER SCIENCE
, 2000
"... In this paper we introduce a general framework for casting fully dynamic transitive closure into the problem of reevaluating polynomials over matrices. With this technique, we improve the best known bounds for fully dynamic transitive closure. In particular, we devise a deterministic algorithm for g ..."
Abstract

Cited by 42 (7 self)
 Add to MetaCart
In this paper we introduce a general framework for casting fully dynamic transitive closure into the problem of reevaluating polynomials over matrices. With this technique, we improve the best known bounds for fully dynamic transitive closure. In particular, we devise a deterministic algorithm for general directed graphs that achieves O(n²) amortized time for updates, while preserving unit worstcase cost for queries. In case of deletions only, our algorithm performs updates faster in O(n) amortized time. Our
ONLINE PLANARITY TESTING
, 1996
"... The online planaritytesting problem consists of performing the following operations on a planar graph G: (i) testing if a new edge can be added to G so that the resulting graph is itself planar; (ii) adding vertices and edges such that planarity is preserved. An efficient technique for online plan ..."
Abstract

Cited by 25 (2 self)
 Add to MetaCart
The online planaritytesting problem consists of performing the following operations on a planar graph G: (i) testing if a new edge can be added to G so that the resulting graph is itself planar; (ii) adding vertices and edges such that planarity is preserved. An efficient technique for online planarity testing of a graph is presented that uses O(n) space and supports tests and insertions of vertices and edges in O(log n) time, where n is the current number of vertices of G. The bounds for tests and vertex insertions are worstcase and the bound for edge insertions is amortized. We also present other applications of this technique to dynamic algorithms for planar graphs.
Experimental Analysis of Dynamic Algorithms for the Single Source Shortest Path Problem
 ACM Jounal of Experimental Algorithmics
, 1997
"... In this paper we propose the first experimental study of the fully dynamic single source shortest paths problem on directed graphs with positive real edge weights. In particular, we perform an experimental analysis of three different algorithms: Dijkstra's algorithm, and the two output bound ..."
Abstract

Cited by 23 (3 self)
 Add to MetaCart
In this paper we propose the first experimental study of the fully dynamic single source shortest paths problem on directed graphs with positive real edge weights. In particular, we perform an experimental analysis of three different algorithms: Dijkstra's algorithm, and the two output bounded algorithms proposed by Ramalingam and Reps in [31] and by Frigioni, MarchettiSpaccamela and Nanni in [18], respectively. The main goal of this paper is to provide a first experimental evidence for: (a) the effectiveness of dynamic algorithms for shortest paths with respect to a traditional static approach to this problem; (b) the validity of the theoretical model of output boundedness to analyze dynamic graph algorithms. Beside random generated graphs, useful to capture the "asymptotic" behavior of algorithms, we also develope experiments by considering a widely used graph from the real world, i.e., the Internet graph. Work partially supported by the ESPRIT Long Term Research Project...
Nonrecursive Incremental Evaluation of Datalog Queries
 Annals of Mathematics and Artificial Intelligence
, 1995
"... We consider the problem of repeatedly evaluating the same (computationally expensive) query to a database that is being updated between successive query requests. In this situation, it should be possible to use the difference between successive database states and the answer to the query in one stat ..."
Abstract

Cited by 19 (8 self)
 Add to MetaCart
We consider the problem of repeatedly evaluating the same (computationally expensive) query to a database that is being updated between successive query requests. In this situation, it should be possible to use the difference between successive database states and the answer to the query in one state to reduce the cost of evaluating the query in the next state. We use nonrecursive Datalog (which are unions of conjunctive queries) to compute the differences, and call this process "incremental query evaluation using conjunctive queries." After formalizing the notion of incremental query evaluation using conjunctive queries, we give an algorithm that constructs, for each regular chain query (including transitive closure as a special case), a nonrecursive Datalog program to compute the difference between the answer after an update and the answer before the update. We then extend this result to weakly regular queries, which are regular chain programs augmented with conjunctive queries havin...