Martin Slota

Normative systems represented as hybrid knowledge bases

Normative systems have been advocated as an effective tool to regulate interaction in multi-agent systems. Logic programming rules intuitively correspond to conditional norms, and their semantics is based on the closed world assumption, which allows default negation, often used in norms. However, there are cases where the closed world assumption is clearly not adequate, and others that require reasoning about unknown individuals, which is not possible in logic programming. On the other hand, description logics are based on the open world assumption and support reasoning about unknown individuals, but do not support default negation. In this paper, we demonstrate the need for the aforementioned features (closed and open world assumptions, and reasoning about unknown individuals) in order to model human laws, with examples from the Portuguese Penal Code. We advocate the use of hybrid knowledge bases combining rules and ontologies, which provide the joint expressivity of logic programming and description logics. We define a normative scenario as the pair of a set of facts and a set of norms, and give it a formal semantics by translation into an MKNF knowledge base. We describe the implementation of the language, which computes the relevant consequences of given facts and norms, and use it to establish the resulting sentence in a penal scenario.

The rise and fall of semantic rule updates based on SE-models

Logic programs under the stable model semantics, or answer-set programs, provide an expressive rule-based knowledge representation framework, featuring a formal, declarative and well-understood semantics. However, handling the evolution of rule bases is still a largely open problem. The Alchourr ´ on, Gand Makinson (AGM) framework for belief change was shown to give inappropriate results when directly applied to logic programs under a non-monotonic semantics such as the stable models. The approaches to address this issue, developed so far, proposed update semantics based on manipulating the syntactic structure of programs and rules. More recently, AGM revision has been successfully applied to a significantly more expressive semantic characterisation of logic programs based on SE-models. This is an important step, as it changes the focus from the evolution of a syntactic representation of a rule base to the evolution of its semantic content. In this paper, we borrow results from the area of belief update to tackle the problem of updating (instead of revising) answer-set programs. We prove a representation theorem which makes it possible to constructively define any operator satisfying a set of postulates derived from Katsuno and Mendelzons postulates for belief update. We define a specific operator based on this theorem, examine its computational complexity and compare the behaviour of this operator with syntactic rule update semantics from the literature. Perhaps surprisingly, we uncover a serious drawback of all rule update operators based on Katsuno and Mendelzons approach to update and on SE-models.

A unifying perspective on knowledge updates

We introduce an abstract update framework based on viewing a knowledge base as the set of sets of models of its elements and performing updates by introducing additional interpretations --- exceptions --- to the sets of models of elements of the original knowledge base. In [36], an instantiation of this framework for performing rule updates has been shown to semantically characterise one of the syntax-based rule update semantics. In this paper we show that the framework can also capture a wide range of both model- and formula-based belief update operators which constitute the formal underpinning of existing approaches to ontology updates. Exception-driven operators thus form a unifying perspective on both ontology and rule updates, opening new possibilities for addressing updates of hybrid knowledge bases consisting of both an ontology and a rule component.

On updates of hybrid knowledge bases composed of ontologies and rules

Throughout the last decade, two distinct knowledge representation paradigms have been standardised to capture rich metadata on the Web: ontology languages based on Classical Logic and reasoning rules based on Logic Programming. Both offer important features for knowledge representation and the interest in their integration has recently resulted in frameworks for hybrid knowledge bases that consist of an ontology and a rule component.Instead of the usual static view of hybrid knowledge, in this paper we address its dynamics and in particular focus on updates. We develop two hybrid update semantics that fit the needs of particular use cases of hybrid knowledge and provide the expected results when used in specific application domains. The first semantics uses a given ontology update operator to update the ontology component of a hybrid knowledge base in the presence of static rules. Inspired by a realistic application, and based on a generalised notion of splitting, known from Logic Programming, the second semantics offers a way to modularly combine an ontology update operator with a rule update semantics. It can be used for performing updates of hybrid knowledge bases consisting of ontology and rule layers that share information through a rule-based interface.Both of these developments constitute solutions to the problem of hybrid updates for restricted classes of hybrid knowledge bases. We examine their fundamental formal properties and show that despite the different ideas behind each of them, they are fully compatible with one another, i.e. when both are applicable, they lead to the same result.

Towards closed world reasoning in dynamic open worlds

The need for integration of ontologies with nonmonotonic rules has been gaining importance in a number of areas, such as the Semantic Web. A number of researchers addressed this problem by proposing a unified semantics for hybrid knowledge bases composed of both an ontology (expressed in a fragment of first-order logic) and nonmonotonic rules. These semantics have matured over the years, but only provide solutions for the static case when knowledge does not need to evolve. In this paper we take a first step towards addressing the dynamics of hybrid knowledge bases. We focus on knowledge updates and, considering the state of the art of belief update, ontology update and rule update, we show that current solutions are only partial and difficult to combine. Then we extend the existing work on ABox updates with rules, provide a semantics for such evolving hybrid knowledge bases and study its basic properties. To the best of our knowledge, this is the first time that an update operator is proposed for hybrid knowledge bases.

MKNF Knowledge Bases in Multi-Context Systems

In this paper we investigate the relationship between Multi-Context Systems and Hybrid MKNF Knowledge Bases. Multi-Context Systems provide an effective and modular way to integrate knowledge from different heterogeneous sources (contexts) through so-called bridge rules. Hybrid MKNF Knowledge Bases, based on the logic of minimal knowledge and negation as failure (MKNF), allow for a seamless combination of description logic ontology languages with non-monotonic logic programming rules. In this paper, we not only show that Hybrid MKNF Knowledge Bases can be used as particular contexts in Multi-Context Systems, but we also provide transformations from the former into the latter, without the need for an explicit Hybrid MKNF context, hence providing a way for agents to reason with Hybrid MKNF Knowledge Bases within Multi-Context Systems without the need for specialized Hybrid MKNF reasoners.

Back and forth between rules and SE-models

Rules in logic programming encode information about mutual interdependencies between literals that is not captured by any of the commonly used semantics. This information becomes essential as soon as a program needs to be modified or further manipulated. We argue that, in these cases, a program should not be viewed solely as the set of its models. Instead, it should be viewed and manipulated as the set of sets of models of each rule inside it. With this in mind, we investigate and highlight relations between the SE-model semantics and individual rules. We identify a set of representatives of rule equivalence classes induced by SE-models, and so pinpoint the exact expressivity of this semantics with respect to a single rule. We also characterise the class of sets of SE-interpretations representable by a single rule. Finally, we discuss the introduction of two notions of equivalence, both stronger than strong equivalence [1] and weaker than strong update equivalence [2], which seem more suitable whenever the dependency information found in rules is of interest.

EVOLP: An Implementation

In this paper we present an implementation of EVOLP under the Evolution Stable Model semantics, based on the transformation defined in [1]. We also discuss optimizations used in the implementation.

Non-monotonic Temporal Goals

In this paper we introduce a logic programming based framework which allows the representation of conditional non-monotonic temporal beliefs and goals in a declarative way. We endow it with stable model like semantics that allows us to deal with conflicting goals and generate possible alternatives. We show that our framework satisfies some usual properties on goals and that it allows imposing alternative constraints on the interaction between beliefs and goals. We prove the decidability of the usual reasoning tasks and show how they can be implemented using an ASP solver and an LTL reasoner in a modular way, thus taking advantage of existing LTL reasoners and ASP solvers.

EVOLP: Tranformation-Based Semantics

Over the years, Logic Programming has proved to be a good and natural tool for expressing, querying and manipulating explicit knowledge in many areas of computer science. However, it is not so easy to use in dynamic environments. Evolving Logic Programs (EVOLP) are an elegant and powerful extension of Logic Programming suitable for Multi-Agent Systems, planning and other uses where information tends to change dynamically. In this paper we characterize EVOLP by transforming it into an equivalent normal logic program over an extended language, that serves as a basis of an existing implementation. Then we prove that the proposed transformation is sound and complete and examine its computational complexity.