Independence { the study of what is relevant to a given problem of reasoning { has received an increasing attention from the AI community. In this paper, we consider two basic forms of independence, namely, a syntactic one and a semantic one. We show features and drawbacks of them. In particular, while the syntactic form of independence is computationally easy to check, there are cases in which things that intuitively are not relevant are not recognized as such. We also consider the problem of forgetting, i.e., distilling from a knowledge base only the part that is relevant to the set of queries constructed from a subset of the alphabet. While such process is computationally hard, it allows for a simpli - cation of subsequent reasoning, and can thus be viewed as a form of compilation: once the relevant part of a knowledge base has been extracted, all reasoning tasks to be performed can be simpli ed.

The benefits of modular representations are well known from many areas of computer science. In this paper, we concentrate on the benefits of modular ontologies with respect to local containment of terminological reasoning. We define an architecture for modular ontologies that supports local reasoning by compiling implied subsumption relations.

We present a general-purpose method for dynamically factoring a planning domain, whose structure is then exploited by our generic planning method to find sound and complete plans. The planning algorithm’s time complexity scales linearly with the size of the domain, and at worst exponentially with the size of the largest subdomain and interaction between subdomains. The factorization procedure divides a planning domain into subdomains that are organized in a tree structure such that interaction between neighboring subdomains in the tree is minimized. The combined planning algorithm is sound and complete, and we demonstrate it on a representative planning domain. The algorithm appears to scale to very large problems regardless of the black box planner used. 1

Query answering over commonsense knowledge bases typically employs a first-order logic theorem prover. While first-order inference is intractable in general, provers can often be hand-tuned to answer queries with reasonable performance in practice.

We present exact algorithms for identifying deterministic-actions ’ effects and preconditions in dynamic partially observable domains. They apply when one does not know the action model (the way actions affect the world) of a domain and must learn it from partial observations over time. Such scenarios are common in real world applications. They are challenging for AI tasks because traditional domain structures that underly tractability (e.g., conditional independence) fail there (e.g., world features become correlated). Our work departs from traditional assumptions about partial observations and action models. In particular, it focuses on problems in which actions are deterministic of simple logical structure and observation models have all features observed with some frequency. We yield tractable algorithms for the modified problem for such domains. Our algorithms take sequences of partial observations over time as input, and output deterministic action models that could have lead to those observations. The algorithms output all or one of those models (depending on our choice), and are exact in that no model is misclassified given the observations. Our algorithms take polynomial time in the number of time steps and state features for some traditional action classes examined in the AI-planning literature, e.g., STRIPS actions. In contrast, traditional approaches for HMMs and Reinforcement Learning are inexact and exponentially intractable for such domains. Our experiments verify the theoretical tractability guarantees, and show that we identify action models exactly. Several applications in planning, autonomous exploration, and adventure-game playing already use these results. They are also promising for probabilistic settings, partially observable reinforcement learning, and diagnosis. 1.

In this paper, we define a simple but scalable framework for peer-to-peer data sharing systems, in which the problem of answering queries over a network of semantically related peers is always decidable.

Abstract not found

One of the major approaches to approximation of logical theories is the upper and lower bounds approach introduced in (Selman and Kautz, 1991, 1996). In this paper, we address the problem of lowest upper bound (LUB) approximation in a general setting. We characterize LUB approximations for arbitrary target languages, both propositional and first order, and describe algorithms of varying generality and efficiency for all target languages, proving their correctness. We also examine some aspects of the computational complexity of the algorithms, both propositional and first order; show that they can be used to characterize properties of whole families of resolution procedures; discuss the quality of approximations; and relate LUB approximations to other approaches existing in the literature which are not typically seen in the approximation framework, and which go beyond the “knowledge compilation ” perspective that led to the introduction of LUBs.

Abstract. Recently, the benefits of modular representations of ontologies has been recognized by the semantic web community. Existing methods for splitting up models into modules either optimize for completeness of local or for the efficiency of distributed reasoning. In our work on semantics-based P2P systems, we are also concerned with the additional criteria of robustness or reasoning in cases where peers are unavailable and with ease of maintenance. We define a number of structural criteria for modularized ontologies and argue why these criteria are suitable for estimating efficiency, robustness and maintainability. We apply the criteria to a number of modularization approaches and discuss the trade-offs made. Based on the discussion we propose a general quality measure for modular representations in the context of our use case. 1

Abstract. This paper presents algorithms whose input is an undirected graph, and whose output is a tree decomposition of width that approximates the optimal, the treewidth of that graph. The algorithms differ in their computation time and their approximation guarantees. The first algorithm works in polynomial-time and finds a factor-O(log OP T), where OP T is the treewidth of the graph. This is the first polynomial-time algorithm that approximates the optimal by a factor that does not depend on n, the number of nodes in the input graph. As a result, we get an algorithm for finding pathwidth within a factor of O(log OP T · log n) from the optimal. We also present algorithms that approximate the treewidth of a graph by constant factors of 3.66, 4, and 4.5, respectively and take time that is exponential in the treewidth. These are more efficient than previously known algorithms by an exponential factor, and are of practical interest. Finding triangulations of minimum treewidth for graphs is central to many problems in computer science. Real-world problems in artificial intelligence, VLSI design and databases are efficiently solvable if we have an efficient approximation algorithm for them. Many of those applications rely on weighted graphs. We extend our results to weighted graphs and weighted treewidth, showing similar approximation results for this more general notion. We report on experimental results confirming the effectiveness of our algorithms for large