Extended Logic Programs Research Articles

An efficient propositional system for Abductive Logic Programming

Abductive logic programming (ALP) extends logic programming with hypothetical reasoning by means of abducibles, an extension able to handle interesting problems, such as diagnosis, planning, and verification with formal methods. Implementations of this extension have been using Prolog meta-interpreters and Prolog programs with Constraint Handling Rules (CHR). While the latter adds a clean and efficient interface to the host system, it still suffers in performance for large programs. Here, the concern is to obtain a more performant implementation of the SCIFF system following a compiled approach. This paper, as a first step in this long term goal, sets out a propositional ALP system following SCIFF, eliminating the need for CHR and achieving better performance.

Deductive databases in four-valued logic: rule semantics and models

Abstract In this paper, we investigate rule semantics for deductive databases in the context of four-valued logic. In our approach, a database is a pair $\varDelta =(E,R)$, where $E$ is a set of pairs, each pair associating a ground fact with a truth value (thus, allowing to store true, false or inconsistent facts) and $R$ is a set of rules generalizing standard Datalog rules in the following sense: (i) the head of a rule can be a positive or a negative atom and (ii) the body can involve any among the connectors of four-valued logic. We define the database semantics as the least fixed point of a monotonic operator and we compare this semantics with that of k-existential programs defined by Fitting and paraconsistent extended logic programs defined by Arieli. Our main contribution is to show that, if we consider rules as implications (i.e. if we view the database as a set of formulas) then the semantics of the database is the unique minimal model of the set of database formulas. Here, minimality is understood with respect to the knowledge ordering of four-valued logic satisfying a monotonicity property whereby the truth value of the head of an instantiated rule is greater than that of the body. Moreover, we characterize databases having finite semantics and then, we address the issue of database updating. We argue that our approach allows for a new kind of updates, in which the update result depends not only on the fact involved in the update but also on its current truth value in the database.

A Survey of the Proof-Theoretic Foundations of Logic Programming

AbstractSeveral formal systems, such as resolution and minimal model semantics, provide a framework for logic programming. In this article, we will survey the use of structural proof theory as an alternative foundation. Researchers have been using this foundation for the past 35 years to elevate logic programming from its roots in first-order classical logic into higher-order versions of intuitionistic and linear logic. These more expressive logic programming languages allow for capturing stateful computations and rich forms of abstractions, including higher-order programming, modularity, and abstract data types. Term-level bindings are another kind of abstraction, and these are given an elegant and direct treatment within both proof theory and these extended logic programming languages. Logic programming has also inspired new results in proof theory, such as those involving polarity and focused proofs. These recent results provide a high-level means for presenting the differences between forward-chaining and backward-chaining style inferences. Anchoring logic programming in proof theory has also helped identify its connections and differences with functional programming, deductive databases, and model checking.

Lazy Stream Programming in Prolog

In recent years, stream processing has become a prominent approach for incrementally handling large amounts of data, with special support and libraries in many programming languages. Unfortunately, support in Prolog has so far been lacking and most existing approaches are ad-hoc. To remedy this situation, we present lazy stream generators as a unified Prolog interface for stateful computations on both finite and infinite sequences of data that are produced incrementally through I/O and/or algorithmically. We expose stream generators to the application programmer in two ways: 1) through an abstract sequence manipulation API, convenient for defining custom generators, and 2) as idiomatic lazy lists, compatible with many existing list predicates. We define an algebra of stream generator operations that extends Prolog via an embedded language interpreter, provides a compact notation for composing generators and supports moving between the two isomorphic representations. As a special instance, we introduce answer stream generators that encapsulate the work of coroutining first-class logic engines and support interoperation between forward recursive AND-streams and backtracking-generated OR-streams. Keywords: lazy stream generators, lazy lists, first-class logic engines, stream combinators, AND-stream / OR-stream interoperation, Prolog extensions

Using SWISH to Realize Interactive Web-based Tutorials for Logic-based Languages

AbstractProgramming environments have evolved from purely text based to using graphical user interfaces, and now we see a move toward web-based interfaces, such as Jupyter. Web-based interfaces allow for the creation of interactive documents that consist of text and programs, as well as their output. The output can be rendered using web technology as, for example, text, tables, charts, or graphs. This approach is particularly suitable for capturing data analysis workflows and creating interactive educational material. This article describes SWISH, a web front-end for Prolog that consists of a web server implemented in SWI-Prolog and a client web application written in JavaScript. SWISH provides a web server where multiple users can manipulate and run the same material, and it can be adapted to support Prolog extensions. In this article we describe the architecture of SWISH, and describe two case studies of extensions of Prolog, namely Probabilistic Logic Programming and Logic Production System, which have used SWISH to provide tutorial sites.

General Belief Revision

In artificial intelligence, a key question concerns how an agent may rationally revise its beliefs in light of new information. The standard (AGM) approach to belief revision assumes that the underlying logic contains classical propositional logic. This is a significant limitation, since many representation schemes in AI don’t subsume propositional logic. In this article, we consider the question of what the minimal requirements are on a logic, such that the AGM approach to revision may be formulated. We show that AGM-style revision can be obtained even when extremely little is assumed of the underlying language and its semantics; in fact, one requires little more than a language with sentences that are satisfied at models, or possible worlds. The classical AGM postulates are expressed in this framework and a representation result is established between the postulate set and certain preorders on possible worlds. To obtain the representation result, we add a new postulate to the AGM postulates, and we add a constraint to preorders on worlds. Crucially, both of these additions are redundant in the original AGM framework, and so we extend , rather than modify , the AGM approach. As well, iterated revision is addressed and the Darwiche/Pearl postulates are shown to be compatible with our approach. Various examples are given to illustrate the approach, including Horn clause revision, revision in extended logic programs, and belief revision in a very basic logic called literal revision .

KProbLog: an algebraic Prolog for machine learning

We introduce kProbLog as a declarative logical language for machine learning. kProbLog is a simple algebraic extension of Prolog with facts and rules annotated by semi-ring labels. It allows to elegantly combine algebraic expressions with logic programs. We introduce the semantics of kProbLog, its inference algorithm, its implementation and provide convergence guarantees. We provide several code examples to illustrate its potential for a wide range of machine learning techniques. In particular, we show the encodings of state-of-the-art graph kernels such as Weisfeiler-Lehman graph kernels, propagation kernels and an instance of graph invariant kernels, a recent framework for graph kernels with continuous attributes. However, kProbLog is not limited to kernel methods and it can concisely express declarative formulations of tensor-based algorithms such as matrix factorization and energy-based models, and it can exploit semirings of dual numbers to perform algorithmic differentiation. Furthermore, experiments show that kProbLog is not only of theoretical interest, but can also be applied to real-world datasets. At the technical level, kProbLog extends aProbLog (an algebraic Prolog) by allowing multiple semirings to coexist in a single program and by introducing meta-functions for manipulating algebraic values.

A sound and complete semantics for a similarity-based logic programming language

Similarity-based Logic Programming replaces the syntactic unification algorithm of classical SLD-resolution by a fuzzy one, leading to an operational mechanism that we name Weak SLD-resolution. This is the operational semantics of a subset of Bousi∼Prolog, an extension of Prolog aiming at making the query answering process more flexible. In this paper, after recalling the model-theoretic and fixpoint semantics for a pure subset of this language, we detail the operational semantics of Bousi∼Prolog and we prove, among other results, its soundness and completeness. Significantly, throughout this work we also clarify some of the differences between our framework and other related proposals.

Deriving conclusions from non-monotonic cause-effect relations

AbstractWe present an extension of Logic Programming (under stable models semantics) that, not only allows concluding whether a true atom is a cause of another atom, but alsoderiving new conclusionsfrom these causal-effect relations. This is expressive enough to capture informal rules like “if some agent's actionshave beennecessaryto cause an eventEthen conclude atomcaused(,E),” something that, to the best of our knowledge, had not been formalised in the literature. To this aim, we start from a first attempt that proposed extending the syntax of logic programs with so-calledcausal literals. These causal literals are expressions that can be used in rule bodies and allow inspecting the derivation of some atomAin the program with respect to some query function ψ. Depending on how these query functions are defined, we can model different types of causal relations such as sufficient, necessary or contributory causes, for instance. The initial approach was specifically focused on monotonic query functions. This was enough to cover sufficient cause-effect relations but, unfortunately, necessary and contributory are essentiallynon-monotonic. In this work, we define a semantics for non-monotonic causal literals showing that, not only extends the stable model semantics for normal logic programs, but also preserves many of its usual desirable properties for the extended syntax. Using this new semantics, we provide precise definitions ofnecessaryandcontributorycausal relations and briefly explain their behaviour on a pair of typical examples from the Knowledge Representation literature.

Enablers and inhibitors in causal justifications of logic programs

AbstractIn this paper, we propose an extension of logic programming where each default literal derived from the well-founded model is associated to a justification represented as an algebraic expression. This expression contains both causal explanations (in the form of proof graphs built with rule labels) and terms under the scope of negation that stand for conditions that enable or disable the application of causal rules. Using some examples, we discuss how these new conditions, we respectively callenablersandinhibitors, are intimately related to default negation and have an essentially different nature from regular cause-effect relations. The most important result is a formal comparison to the recent algebraic approaches for justifications in logic programming:Why-not ProvenanceandCausal Graphs. We show that the current approach extends both Why-not Provenance and Causal Graphs justifications under the well-founded semantics and, as a byproduct, we also establish a formal relation between these two approaches.

Semantic-based construction of arguments: An answer set programming approach

In this paper, we introduce an argumentation approach which takes an extended logic program as input and gives a set of arguments with the respective disagreements among them as output. We establish the notion of an argument under the Well-Founded semantics and Stable semantics inferences, allowing us to identify arguments with stratified programs as support, even when the input for the argument engine is a non-stratified program. We propose a set of rationality postulates for argument-based systems under extended logic programs, which are based on a definition of closure for a set of clauses that considers the well-known Gelfond–Lifschitz reduction. We establish the conditions under which our approach satisfies these principles. In addition, we present a standalone argumentation-tool based on the XSB system which implements our argumentation approach.

A new probabilistic constraint logic programming language based on a generalised distribution semantics

Probabilistic logics combine the expressive power of logic with the ability to reason with uncertainty. Several probabilistic logic languages have been proposed in the past, each of them with their own features. We focus on a class of probabilistic logic based on Sato's distribution semantics, which extends logic programming with probability distributions on binary random variables and guarantees a unique probability distribution. For many applications binary random variables are, however, not sufficient and one requires random variables with arbitrary ranges, e.g. real numbers. We tackle this problem by developing a generalised distribution semantics for a new probabilistic constraint logic programming language. In order to perform exact inference, imprecise probabilities are taken as a starting point, i.e. we deal with sets of probability distributions rather than a single one. It is shown that given any continuous distribution, conditional probabilities of events can be approximated arbitrarily close to the true probability. Furthermore, for this setting an inference algorithm that is a generalisation of weighted model counting is developed, making use of SMT solvers. We show that inference has similar complexity properties as precise probabilistic inference, unlike most imprecise methods for which inference is more complex. We also experimentally confirm that our algorithm is able to exploit local structure, such as determinism, which further reduces the computational complexity.

Tabling as a library with delimited control

AbstractTabling is probably the most widely studied extension of Prolog. But despite its importance and practicality, tabling is not implemented by most Prolog systems. Existing approaches require substantial changes to the Prolog engine, which is an investment out of reach of most systems. To enable more widespread adoption, we present a new implementation of tabling in under 600 lines of Prolog code. Our lightweight approach relies on delimited control and provides reasonable performance.

Special issue on trust and security in wireless sensor networks

Special issue on trust and security in wireless sensor networks

Designing and evaluating weighted delegatable authorizations

SummaryThis paper studies logic‐based methods for representing and evaluating complex access control policies needed by modern applications. In our framework, authorization and delegation rules are specified in a weighted delegatable authorization program, which is an extended logic program. We show how extended logic programs can be used to specify complex security policies, which support weighted administrative privilege delegation, weighted positive and negative authorizations, and weighted authorization propagations. We also present a conflict resolution method that enables flexible delegation control by considering priorities of authorization grantors and weights of authorizations. We show how this method can be specialized to achieve many of the current existing conflict resolution methods. A number of rules are provided to achieve delegation depth control, conflict resolution, and authorization and delegation propagations. We also show how to use SMODELS to implement weighted delegatable authorization program. Copyright © 2015 John Wiley & Sons, Ltd.

The infinite-valued semantics: overview, recent results and future directions

The infinite-valued semantics was introduced in Rondogiannis and Wadge (2005) as a purely logical way for capturing the meaning of well-founded negation in logic programming. The purpose of this paper is threefold: first, to give a non-technical introduction to the infinite-valued semantics; second, to discuss the applicability of the infinite-valued approach to syntactically richer extensions of logic programming; and third, to present the main open problems whose resolution would further enhance the applicability of the technique.

Dynamic delegation framework for role based access control in distributed data management systems

This paper proposes a logic based framework that extends role based access control systems with dynamic delegation in a decentralised environment. It allows delegation of administrative privileges for both roles and access rights between roles. We have introduced the notion of trust in delegation and have shown how extended logic programs can be used to express and reason about roles and their delegations with trust degrees, roles' privileges and their propagations, delegation depth as well as conflict resolution. Furthermore, our framework is able to enforce various role constraints such as separation of duties, role composition and cardinality constraints. The implementation of the framework is also discussed. The proposed framework is flexible and provides a sound basis for specifying and evaluating sophisticated role based access control policies in decentralised environments.

Approach of Security Policy Expression and Verification Based on Well-Founded Semantic

This study proposes a logic-based security policy framework.First,the study proposes the security policy syntax and semantic.Next,four algoritms are proposed to transfer first-order logic based security policies into extended logic programs to evaluate queries with simple goals,to transfer complex queries into simple ones,and to verify security policies against complex security properties.Under well-founded semantics,all the algorithms are sound and completed,and their computational complexities are polynomial.In this framework,security policy declaration,evaluation and verification are executed under the same semantics,which is significant for security policy management.Furthmore,the framework can manage the security policies with advanced features,such as non-monotony and recursion,which is not supported in many existent security policy management frameworks.

K-Optimal: a novel approximate inference algorithm for ProbLog

ProbLog is a probabilistic extension of Prolog. Given the complexity of exact inference under ProbLog's semantics, in many applications in machine learning approximate inference is necessary. Current approximate inference algorithms for ProbLog however require either dealing with large numbers of proofs or do not guarantee a low approximation error. In this paper we introduce a new approximate inference algorithm which addresses these shortcomings. Given a user-specified parameter k, this algorithm approximates the success probability of a query based on at most k proofs and ensures that the calculated probability p is (1?1/e)p ?≤p≤p ?, where p ? is the highest probability that can be calculated based on any set of k proofs. Furthermore a useful feature of the set of calculated proofs is that it is diverse. Our experiments show the utility of the proposed algorithm.

Dependency semantics for sequences of extended logic programs

In this work, we present a framework based on the notion of dependencies. We use this framework to define semantics for inconsistent belief bases in a modular way to define general tools for handling inconsistency. We consider belief bases represented by non-monotonic formalisms, and in particular use extended logic programs and belief bases represented by sequences of these. We show the presented frameworks appliance with the answer set semantics for consistent belief bases. Moreover, we define various instantiations of the framework and show relations to other approaches. We present ways to improve the resulting semantics by means of changes to modules of the framework that lead to the definition of improved approaches to conflict handling in logic programming-based knowledge bases.