Extended Logic Programs Research Articles

Temporally Annotated Extended Logic Programs

Extended logic programs (ELPs) are a set of logic rules with strong negation allowed in the bodies or head of the rules and weak negation ~ allowed in the bodies of the rules. ELPs enable for various forms of reasoning that cannot be achieved by definite logic programs. Answer Set Programming provides a widely acceptable semantics for ELPs. However, ELPs do not provide information regarding the temporal intervals that derived ELP literals or weakly negated ELP literals are valid. In this paper, we associate ELP rules with their validity temporal interval, resulting in a temporally annotated logic program. A ground temporal literal has the form L:i, where L is a ground ELP literal or weakly negated ELP literal and i is a temporal interval. We define (simple) entailment and maximal entailment of a ground temporal literal L:i from a temporally annotated logic program C. Both kinds of entailment are based on Answer Set Programming. Additionally, we provide an algorithm that for an ELP literal or a weakly negated ELP literal L returns a list with all temporal intervals i such that a temporally annotated logic program C maximally entails L:i. Based on this algorithm, the answer of various kinds of temporal queries can be provided.

On the implementation of the probabilistic logic programming language ProbLog

AbstractThe past few years have seen a surge of interest in the field of probabilistic logic learning and statistical relational learning. In this endeavor, many probabilistic logics have been developed. ProbLog is a recent probabilistic extension of Prolog motivated by the mining of large biological networks. In ProbLog, facts can be labeled with probabilities. These facts are treated as mutually independent random variables that indicate whether these facts belong to a randomly sampled program. Different kinds of queries can be posed to ProbLog programs. We introduce algorithms that allow the efficient execution of these queries, discuss their implementation on top of the YAP-Prolog system, and evaluate their performance in the context of large networks of biological entities.

DTProbLog: A Decision-Theoretic Probabilistic Prolog

We introduce DTProbLog, a decision-theoretic extension of Prolog and its probabilistic variant ProbLog. DTProbLog is a simple but expressive probabilistic programming language that allows the modeling of a wide variety of domains, such as viral marketing. In DTProbLog, the utility of a strategy (a particular choice of actions) is defined as the expected reward for its execution in the presence of probabilistic effects. The key contribution of this paper is the introduction of exact, as well as approximate, solvers to compute the optimal strategy for a DTProbLog program and the decision problem it represents, by making use of binary and algebraic decision diagrams. We also report on experimental results that show the effectiveness and the practical usefulness of the approach.

Transformations of logic programs on infinite lists

AbstractWe consider an extension of logic programs, called ω-programs, that can be used to define predicates overinfinite lists. ω-programs allow us to specify properties of the infinite behavior of reactive systems and, in general, properties of infinite sequences of events. The semantics of ω-programs is an extension of the perfect model semantics. We present variants of the familiar unfold/fold rules which can be used for transforming ω-programs. We show that these new rules are correct, that is, their application preserves the perfect model semantics. Then we outline a general methodology based on program transformation for verifying properties of ω-programs. We demonstrate the power of our transformation-based verification methodology by proving some properties of Büchi automata and ω-regular languages.

CHR(PRISM)-based probabilistic logic learning

AbstractPRISM is an extension of Prolog with probabilistic predicates and built-in support for expectation-maximization learning. Constraint Handling Rules (CHR) is a high-level programming language based on multi-headed multiset rewrite rules.In this paper, we introduce a new probabilistic logic formalism, called CHRiSM, based on a combination of CHR and PRISM. It can be used for high-level rapid prototyping of complex statistical models by means of “chance rules”. The underlying PRISM system can then be used for several probabilistic inference tasks, including probability computation and parameter learning. We define the CHRiSM language in terms of syntax and operational semantics, and illustrate it with examples. We define the notion of ambiguous programs and define a distribution semantics for unambiguous programs. Next, we describe an implementation of CHRiSM, based on CHR(PRISM). We discuss the relation between CHRiSM and other probabilistic logic programming languages, in particular PCHR. Finally, we identify potential application domains.

Strategies in PRholog

PRholog is an experimental extension of logic programming with strategic conditional transformation rules, combining Prolog with Rholog calculus. The rules perform nondeterministic transformations on hedges. Queries may have several results that can be explored on backtracking. Strategies provide a control on rule applications in a declarative way. With strategy combinators, the user can construct more complex strategies from simpler ones. Matching with four different kinds of variables provides a flexible mechanism of selecting (sub)terms during execution. We give an overview on programming with strategies in PRholog and demonstrate how rewriting strategies can be expressed.

General default logic

In this paper, we propose a new nonmonotonic logic called general default logic. On the one hand, it generalizes Reiter's default logic by adding to it rule-like operators used in logic programming. On the other hand, it extends logic programming by allowing arbitrary propositional formulas. We show that with this new logic, one can formalize naturally rule constraints, generalized closed world assumptions, and conditional defaults. We show that under a notion of strong equivalence, sentences of this new logic can be converted to a normal form. We also investigate the computational complexity of various reasoning tasks in the logic, and relate it to some other nonmonotonic formalisms such as Lin and Shoham's logic of GK and Moore's autoepistemic logic.

A Logic-Program-Based Negotiation Mechanism

This paper presents a logic-program-based mechanism of negotiation between two agents. In this mechanism an extended logic program (ELP) is regarded as an agent. The negotiation process between two agents is then modelled as multiple encounters between two ELPs, each of which selects an answer set as its initial demand. Both agents mutually revise the original sets of demands through accepting part of the opponent's demand and/or giving up part of its own demand. The overall dynamics can be regarded as mutual updates between two extended logic programs. A deal to achieve an appropriate negotiation solution is put forward. The conditions of existence and terminability of an appropriate negotiation are given. Properties of a negotiation solution are discussed, including its weak Pareto optimality.

Preferences and Nonmonotonic Reasoning

We give an overview of the multifaceted relationship between nonmonotonic logics and preferences. We discuss how the nonmonotonicity of reasoning itself is closely tied to preferences reasoners have on models of the world or, as we often say here, possible belief sets. Selecting extended logic programming with answer‐set semantics as a generic nonmonotonic logic, we show how that logic defines preferred belief sets and how preferred belief sets allow us to represent and interpret normative statements. Conflicts among program rules (more generally, defaults) give rise to alternative preferred belief sets. We discuss how such conflicts can be resolved based on implicit specificity or on explicit rankings of defaults. Finally, we comment on formalisms that explicitly represent preferences on properties of belief sets. Such formalisms either build preference information directly into rules and modify the semantics of the logic appropriately or specify preferences on belief sets independently of the mechanism to define them.

Consistency properties and set based logic programming

Blair et al. (2001) developed an extension of logic programming called set based logic programming. In the theory of set based logic programming the atoms represent subsets of a fixed universe X and one is allowed to compose the one-step consequence operator with a monotonic idempotent operator O so as to ensure that the analogue of stable models in the theory are always closed under O. Marek et al. (1992, Ann Pure Appl Logic 96:231---276 1999) developed a generalization of Reiter's normal default theories that can be applied to both default theories and logic programs which is based on an underlying consistency property. In this paper, we show how to extend the normal logic programming paradigm of Marek, Nerode, and Remmel to set based logic programming. We also show how one can obtain a new semantics for set based logic programming based on a consistency property.

An algebraic approach to revising propositional rule-based knowledge bases

One of the important topics in knowledge base revision is to introduce an efficient implementation algorithm. Algebraic approaches have good characteristics and implementation method; they may be a choice to solve the problem. An algebraic approach is presented to revise propositional rule-based knowledge bases in this paper. A way is firstly introduced to transform a propositional rule-based knowledge base into a Petri net. A knowledge base is represented by a Petri net, and facts are represented by the initial marking. Thus, the consistency check of a knowledge base is equivalent to the reachability problem of Petri nets. The reachability of Petri nets can be decided by whether the state equation has a solution; hence the consistency check can also be implemented by algebraic approach. Furthermore, algorithms are introduced to revise a propositional rule-based knowledge base, as well as extended logic programming. Compared with related works, the algorithms presented in the paper are efficient, and the time complexities of these algorithms are polynomial.

Compressing probabilistic Prolog programs

ProbLog is a recently introduced probabilistic extension of Prolog (De Raedt, et al. in Proceedings of the 20th international joint conference on artificial intelligence, pp. 2468–2473, 2007). A ProbLog program defines a distribution over logic programs by specifying for each clause the probability that it belongs to a randomly sampled program, and these probabilities are mutually independent. The semantics of ProbLog is then defined by the success probability of a query in a randomly sampled program. This paper introduces the theory compression task for ProbLog, which consists of selecting that subset of clauses of a given ProbLog program that maximizes the likelihood w.r.t. a set of positive and negative examples. Experiments in the context of discovering links in real biological networks demonstrate the practical applicability of the approach.

A Logic Approach to Database Dynamic Updating

We introduce a logic-based framework for database updating under constraints. In our framework, the constraints are represented as an instantiated extended logic program. When performing an update, database consistency may be violated. We provide an approach of maintaining database consistency, and study the conditions under which the maintenance process is deterministic. We show that the complexity of the computations and decision problems presented in our framework is in each case polynomial time. Keywords—Databases, knowledge bases, constraints, updates, minimal change, consistency.

Temporal Contextual Logic Programming

The importance of temporal representation and reasoning is well known not only in the database community but also in the artificial intelligence one. Contextual Logic Programming [António Porto and Luís Monteiro. Contextual logic programming. In Giorgio Levi and Maurizio Martelli, editors, Proceedings 6th Intl. Conference on Logic Programming, Lisbon, Portugal, 19–23 June 1989, pages 284–299. The MIT Press, Cambridge, MA, 1989] (CxLP) is a simple and powerful language that extends logic programming with mechanisms for modularity. Recent work not only presented a revised specification of CxLP together with a new implementation for it but also explained how this language could be seen as a shift into the Object-Oriented Programming paradigm [Salvador Abreu and Daniel Diaz. Objective: In minimum context. In Catuscia Palamidessi, editor, ICLP, volume 2916 of Lecture Notes in Computer Science, pages 128–147. Springer, 2003]. In this paper we propose a temporal extension of such language called Temporal Contextual Logic Programming. Such extension follows a reified approach to the temporal qualification, that besides the acknowledge increased expressiveness of reification allows us to capture the notion of time of the context. Together with the syntax of this language we also present its operational semantics and an application to the management of workflows.

A knowledge-based approach for selecting information sources

AbstractThrough the Internet and the World-Wide Web, a vast number of information sources has become available, which offer information on various subjects by different providers, often in heterogeneous formats. This calls for tools and methods for building an advanced information-processing infrastructure. One issue in this area is the selection of suitable information sources in query answering. In this paper, we present a knowledge-based approach to this problem, in the setting where one among a set of information sources (prototypically, data repositories) should be selected for evaluating a user query. We use extended logic programs (ELPs) to represent rich descriptions of the information sources, an underlying domain theory, and user queries in a formal query language (here, XML-QL, but other languages can be handled as well). Moreover, we use ELPs for declarative query analysis and generation of a query description. Central to our approach are declarativesource-selection programs, for which we define syntax and semantics. Due to the structured nature of the considered data items, the semantics of such programs must carefully respect implicit context information in source-selection rules, and furthermore combine it with possible user preferences. A prototype implementation of our approach has been realized exploiting the DLV KR system and its PLP front-end for prioritized ELPs. We describe a representative example involving specific movie databases, and report about experimental results.

Defeasible reasoning: A discussion of some intuitions

In this article, we discuss some issues related to the intuitions of defeasible reasoning, in particular floating conclusions, reinstatement, and zombie paths. Defeasible logic serves as the formal basis for our analysis. We also make some comments on the comparison between defeasible logics and the well-founded semantics of extended logic programs with priorities. © 2006 Wiley Periodicals, Inc. Int J Int Syst 21: 545–558, 2006.

Model theory approach to transaction processing system development

This paper presents a new approach, model theory approach, to small and medium scale transaction processing system (TPS) development. A TPS of this paper is an information system designed to process day-to-day business event data at operational level of an organization. The paper is not concerned with data base construction but with transaction processing. The model theory approach is not a software engineering approach but a systems theory approach. In the approach a model of the target system, which is called a user model, is constructed in set theory using a formal system structure of a TPS. The user model is, then, compiled into an extended Prolog (extProlog) model. The extProlog is an extension of Prolog to meet requirements for management information system development. On compilation a standardized user interface (UI) called internal UI is attached. The extProlog model with the internal UI is, then, executed under control of another standardized UI called an external UI. Implementation is an integral part of the approach. Because the UIs are designed for the formalized (abstract) structure of a TPS, they can be standardized and are provided as black box components to system development. Because a systems developer is required to only build a user model in set theory based on a model theoretic structure in the approach, it is called a model theory approach. Advantages of this approach are that it provides a theoretical structure to information systems development so that systems development can be made an engineering discipline, and facilitates rapid systems development.

Declarative programming of integrated peer-to-peer and Web based systems: the case of Prolog

Web and peer-to-peer systems have emerged as popular areas in distributed computing, and their integrated usage permits the benefits of both to be exploited. While much work in these areas have utilized the imperative programming paradigm, the need for declarative programming paradigms is increasingly being recognized, not only for the often cited advantages such as a higher level of abstraction and specialized language features, but also to tackle the querying and manipulation of knowledge and reasoning with semantics that will be the mainstay of the proposed next generation of the Web and peer-to-peer computing. This paper presents an approach towards integrative use of the Web and peer-to-peer systems within a declarative programming paradigm. We contend that logic programming can be useful in peer-to-peer computing, especially for querying and representing knowledge shared over peer networks, and for scripting applications that involve sophisticated search behaviour over peer networks. As an example of peer-to-peer querying expressed in a logic programming language, we propose a simple extension of Prolog, which we call LogicPeer, to enable goal evaluation over peers in a peer network. Using LogicPeer, we outline how a peer-to-peer version of a Yahoo-like system can be built and queried, and several other applications that involve decentralized knowledge sharing. We then show how LogicPeer can be used with LogicWeb, a Prolog extension to access Web pages, thereby integrating peer-to-peer querying and Web querying in a common declarative framework.

Reasoning about evolving nonmonotonic knowledge bases

Recently, several approaches to updating knowledge bases modeled as extended logic programs have been introduced, ranging from basic methods to incorporate (sequences of) sets of rules into a logic program, to more elaborate methods which use an update policy for specifying how updates must be incorporated. In this article, we introduce a framework for reasoning about evolving knowledge bases, which are represented as extended logic programs and maintained by an update policy. We first describe a formal model which captures various update approaches, and we define a logical language for expressing properties of evolving knowledge bases. We then investigate semantical and computational properties of our framework, where we focus on properties of knowledge states with respect to the canonical reasoning task of whether a given formula holds in a given evolving knowledge base. In particular, we present finitary characterizations of the evolution for certain classes of framework instances, which can be exploited for obtaining decidability results. In more detail, we characterize the complexity of reasoning for some meaningful classes of evolving knowledge bases, ranging from polynomial to double exponential space complexity.

A parameterised hierarchy of argumentation semantics for extended logic programming and its application to the well-founded semantics

Argumentation has proved a useful tool in defining formal semantics for assumption-based reasoning by viewing a proof as a process in which proponents and opponents attack each others arguments by undercuts (attack to an argument's premise) and rebuts (attack to an argument's conclusion). In this paper, we formulate a variety of notions of attack for extended logic programs from combinations of undercuts and rebuts and define a general hierarchy of argumentation semantics parameterised by the notions of attack chosen by proponent and opponent. We prove the equivalence and subset relationships between the semantics and examine some essential properties concerning consistency and the coherence principle, which relates default negation and explicit negation. Most significantly, we place existing semantics put forward in the literature in our hierarchy and identify a particular argumentation semantics for which we prove equivalence to the paraconsistent well-founded semantics with explicit negation, WFSX. Finally, we present a general proof theory, based on dialogue trees, and show that it is sound and complete with respect to the argumentation semantics.