We examine the power of incremental evaluation systems that use an SQL-like language for maintaining recursively-defined views. We show that recursive queries such as transitive closure, and "alternating paths" can be incrementally maintained in a nested relational language, when some auxiliary relations are allowed. In the presence of aggregate functions, even more queries can be maintained, for example, the "same generation" query. In contrast, it is still an open problem whether such queries are maintainable in relational calculus. We then restrict the language so that no nested relations are involved (but wekeep the aggregate functions). Such a language captures the capability of most practical relational database systems. We prove that this restriction does not reduce the incremental computational power; that is, any query that can be maintained in a nested language with aggregates, is still maintainable using only flat relations. We also show that one does not need auxiliar...

Abstract. The development of ontologies involves continuous but relatively small modifications. Existing ontology reasoners, however, do not take advantage of the similarities between different versions of an ontology. In this paper, we propose a technique for incremental reasoning—that is, reasoning that reuses information obtained from previous versions of an ontology—based on the notion of a module. Our technique does not depend on a particular reasoning calculus and thus can be used in combination with any reasoner. We have applied our results to incremental classification of OWL DL ontologies and found significant improvement over regular classification time on a set of real-world ontologies. 1

We study the problem of incrementally maintaining the result of an XPath query on an XML database under updates. In its most general form, this problem asks to maintain a materialized XPath view over an XML database. It assumes an underlying XML database D and a query Q. One is given a sequence of updates U to D and the problem is to compute the result of Q(U(D)), i.e., the result of evaluating query Q on the database D after having applied the updates U. In order to quickly answer this question, we are allowed to maintain an auxiliary data structure, and the complexity of the maintenance algorithms is measured in (i) the size of the auxiliary data structure, (ii) the worst-case time per update needed to compute Q(U(D)) and (iii) the worst-case time per update needed to bring the auxiliary data structure up to date. We allow three kinds of updates: node insertion, node deletion, and node relabeling. Our main results are that downward XPath queries can be incrementally maintained in time O(depth(D) · poly(|Q|)) per update and conjunctive forward XPath queries in time O(depth(D)·log(width(D))·poly(|Q|)) per update, where |Q | is the size of the query, and depth(D) and width(D) are the nesting depth and maximum number of siblings in the database D, respectively. The auxiliary data structures for maintenance are linear in |D | and polynomial in |Q | in all these cases.

It is common knowledge that relational calculus and even SQL are not expressive enough to express recursive queries such as the transitive closure. In a real database system, one can overcome this problem by storing a graph together with its transitive closure and maintaining the latter whenever updates to the former occur. This leads to the concept of an incremental evaluation system, or IES. Much is already known about the theory of IES but very little has been translated into practice. The purpose of this paper is to ll in this gap by providing a gentle introduction to and an overview of some recent theoretical results on IES. The introduction is through the translation into SQL of three interesting positive maintenance results that have practical importance { the maintenance of the transitive closure of acyclic graphs, of undirected graphs, and of arbitrary directed graphs. Interestingly, these examples also allow ustoshow the relationship between power and cost in the incremental maintenance of database queries. 1

Syndication on the Web has attracted a great amount of attention in recent years. However, today’s state-of-the-art syndication approaches still provide relatively weak ex-pressive power from a modeling perspective and provide very little automated reasoning support. If a more expressive approach with a formal semantics can be provided, many benefits can be achieved, including a rich semantics-based mechanism for expressing sub-scriptions and published content and automated reasoning for discovering subscription matches not found using traditional syntactic syndication approaches. In this dissertation, I develop a syndication framework based on the Web Ontology Language (OWL), which is the standardized language for representing the semantics of information on the Web. One of the main advantages of the framework is its support for formal reasoning, as the semantics of subsets of OWL are founded in description logic (a decidable fragment of first-order logic). Therefore, the previously mentioned benefits can be achieved using description logic (DL) reasoning. However, the main limitation in using OWL as the underlying representation model is related to the overhead of DL reasoning under changing data, which makes the approach

this report, we only consider queries from flat relations to flat relations; and the criteria for permissible update is restricted to the insertion and deletion of a single tuple. A restriction is also imposed so that the constants that appear in the auxiliary database must also appear in the database or in the answer or in some fixed set. In this report, this fixed set is Q , the set of rational numbers. We use the first-order incremental evaluation system, IES(FO)(called FOIES in [10]), to illustrate the concept. IES(FO) uses first-order logic to express update functions [9, 11]. For each relation symbol R,

. The incremental view maintenance problem deals with the efficient updating of materialized views in response to updates to base relations. This paper considers the problem in a distributed database environment, with communication cost minimization as the primary objective. The views considered are defined based on the relational join operation. The approach is to use "yes"/"no" tags as auxiliary data on tuples in the base relations to indicate whether the tuples participate in joins. These tags will help avoid sending irrelevant data over the network and thus reduce the communication cost. Two basic view maintenance algorithms are proposed using the tags. In addition to reducing communication costs, an important feature of these two basic algorithms is that they derive the "exact change" to views without looking at the old views. This feature allows us to maintain certain aggregates on views without actually materializing the views themselves; this feature is useful in applications s...

The paper investigates the power of the dynamic complexity classes DynFO, DynQF and DynPROP over string languages. The latter two classes contain problems that can be maintained using quantifier-free first-order updates, with and without auxiliary functions, respectively. It is shown that the languages maintainable in DynPROP exactly are the regular languages, even when allowing arbitrary precomputation. This enables lower bounds for DynPROP and separates DynPROP from DynQF and DynFO. Further, it is shown that any context-free language can be maintained in DynFO and a number of specific context-free languages, for example all Dyck-languages, are maintainable in DynQF. Furthermore, the dynamic complexity of regular tree languages is investigated and some results concerning arbitrary structures are obtained: there exist first-order definable properties which are not maintainable in DynPROP. On the other hand any existential first-order property can be maintained in DynQF when allowing precomputation.

Abstract. The Any-World Assumption (AWA) has been introduced for normal logic programs as a generalization of the well-known notions of Closed World Assumption (CWA) and the Open World Assumption (OWA). The AWA allows any assignment (i.e., interpretation), over a truth space (bilattice), to be a default assumption and, thus, the CWA and OWA are just special cases. To answer queries, we provide a novel and simple top-down procedure. 1

We study the problem of maintaining recursively-defined views, such as the transitive closure of a relation, in traditional relational languages that do not have recursion mechanisms. The main results of this paper show that in most cases such incremental maintenance is impossible if either no auxiliary relations are used or they are limited to be deterministic. Instead of concentrating on proving these results for some particular languages, we try to identify properties of query languages that make such incremental maintenance impossible. That is, we want to use known results on expressive power of languages to derive new results on expressiveness of incremental recomputation. We identify two properties, studied previously in the literature on expressive power of query languages and finite-model theory, that imply unmaintainability of several recursive queries under insertions or deletions. Furthermore, using known results on expressive power of query languages, we simplify...