Abstract not found

In this paper, we introduce a new method to recover from discrepancies in a general monitoring framework where the agent finds some explanations (points of failure) for discrepancies. According to this method, the agent finds a reverse plan to backtrack to a diagnosed point of failure and subsequently continues with the original plan. This method is appealing given that such a reverse plan is short with respect to the overall plan to be executed. While a reverse plan could be computed online by solving a planning problem, we present a potentially more efficient method: We first build offline a reverse plan library by finding reverse plans for action sequences, and then use this library online to construct reverse plans. The former part is done by reducing the problem of finding pairs of action sequences and reverse plans (of a certain length) to a conformant planning problem; for the latter, we present a polynomial time algorithm. Furthermore, we analyze the complexity of finding reverse plans, and obtain that the presented reduction is reasonable in general.

We focus on the aspect of sensing in reasoning about actions under qualitative and probabilistic uncertainty. We extend an A-related action language by actions with nondeterministic and probabilistic effects, and define a formal semantics in terms of deterministic, nondeterministic, and probabilistic transitions between epistemic states. We then introduce the notions of a conditional plan and its goodness in this framework, and we formulate the conditional planning problem. We present an algorithm for solving it, which is proved to be sound and complete in the sense that it produces all optimal plans. We also report on a first prototype implementation of this algorithm. An application in a robotic-soccer scenario underlines the usefulness of our formalism in realistic applications.

We present the class FDNC of logic programs which allows for function symbols(F), disjunction (D), non-monotonic negation under the answer set semantics (N), and constraints (C), while still retaining the decidability of the standard reasoning tasks. Thanks to these features, FDNC programs are a powerful formalism for rule-based modeling of applications with potentially infinite processes and objects, and which allows also for common-sense reasoning in this context. This is evidenced, for instance, by tasks in reasoning about actions and planning: brave and open queries over FDNC programs capture the well-known problems of plan existence and secure (conformant) plan existence, respectively, in transition-based actions domains. As for reasoning from FDNC programs, we show that consistency checking and brave/cautious reasoning tasks are ExpTimecomplete in general, but have lower complexity under syntactic restrictions that give rise to a family of program classes. Furthermore, we also determine the complexity of open queries (i.e., with answer variables), for which deciding non-empty answers is shown to be ExpSpace-complete under cautious entailment. Furthermore, we present algorithms for all reasoning tasks that are worst-case optimal. The majority of them resorts to a finite representation of the stable models of an FDNC program that employs maximal founded sets of knots, which are labeled trees of depth at most 1 from which each stable model can be reconstructed. Due to this property, reasoning over FDNC programs can in many cases be reduced to reasoning from knots. Once the knotrepresentation for a program is derived (which can be done off-line), several reasoning tasks are not more expensive than in the function-free case, and some are even feasible in polynomial time. This knowledge compilation technique paves the way to potentially more efficient online reasoning methods not only for FDNC, but also for other formalisms.

Thanks to recent advances, AI Planning has become the underlying technique for several applications. Amongst these, a prominent one is automated Web Service Composition (WSC). One important issue in this context has been hardly addressed so far: WSC requires dealing with background ontologies. The support for those is severely limited in current planning tools. We introduce a planning formalism that faithfully represents WSC. We show that, unsurprisingly, planning in such a formalism is very hard. We then identify an interesting special case that covers many relevant WSC scenarios, and where the semantics are simpler and easier to deal with. This opens the way to the development of effective support tools for WSC. Furthermore, we show that if one additionally limits the amount and form of outputs that can be generated, then the set of possible states becomes static, and can be modelled in terms of a standard notion of initial state uncertainty. For this, effective tools exist; these can realize scalable WSC with powerful background ontologies. In an initial experiment, we show how scaling WSC instances are comfortably solved by a tool incorporating modern planning heuristics.

We present an agent monitoring approach, which aims at refuting from (possibly incomplete) information at hand that a multi-agent system (MAS) is implemented properly. In this approach, agent collaboration is abstractly described in an action theory. Action sequences reaching the collaboration goal are determined by a planner, whose compliance with the actual MAS behavior allows to detect possible collaboration failures. The approach can be fruitfully applied to aid offline testing of a MAS implementation, as well as online monitoring.

Disjunctive Logic Programming (DLP) under the answer set semantics is an advanced formalism for knowledge representation and reasoning. It is generally considered more expressive than normal (disjunction-free) Logic Programming, whose expressiveness is limited to properties decidable in NP. However,

The purpose of this tutorial is to get the audience familiar with the Answer Set Programming (ASP) Paradigm in the perspective of its fruitful usage for Semantic Web applications. ASP is a declarative programming paradigm with its roots in Knowledge Representation and Logic Programming. Systems and languages based on ASP are ready for tackling many of the challenges the Semantic Web offers, and in particular, are good candidates for solving a variety of issues which have been delegated to the Rule/Logic Layers in the Semantic Web vision. ASP systems are scalable, allow to mix monotonic with nonmonotonic reasoning, permit to combine rules with ontologies, and can interface external reasoners. Moreover, ASP is especially tailored at solving configuration and matchmaking problems involving reasoning with preferences by featuring easy to use, fully declarative soft & hard constraint specification languages. We introduce the attendees to the ASP basics and its principal extensions tailored at Semantic Web applications. We discuss the current impact of Answer Set Programming in the Semantic Web Area and possible future directions. Applications and exercises are presented. The attendees will practice through an online interface using one of the state-of-the-art ASP solvers and some of its extensions.

Abstract. Action languages allow for compactly describing dynamic domains. They are usually implemented by compilation, e.g., to Answer Set Programming. To this end, we developed a tool, called Coala, offering manifold compilation techniques for several action languages. We provide an overview of the salient and distinctive features of Coala as well as an experimental comparison of them. 1

Thanks to recent advances, AI Planning has become the underlying technique for several applications. Figuring prominently among these is automated Web Service Composition (WSC) at the “capability ” level, where services are described in terms of preconditions and effects over ontological concepts. A key issue in addressing WSC as planning is that ontologies are not only formal vocabularies; they also axiomatize the possible relationships between concepts. Such axioms correspond to what has been termed “integrity constraints ” in the actions and change literature, and applying a web service is essentially a belief update operation. The reasoning required for belief update is known to be harder than reasoning in the ontology itself. The support for belief update is severely limited in current planning tools. Our first contribution consists in identifying an interesting special case of WSC which is both significant and more tractable. The special case, which we term forward effects, is characterized by the fact that every ramification of a web service application involves at least one new constant generated as output by the web service. We show that, in this setting, the reasoning required for belief update simplifies to standard reasoning in the ontology itself. This relates to, and extends,