The World Wide Web is nowadays the most famous and widespread information system. Its success is witnessed by its enormous size and rate of growth: however, the same success of the Web has brought to a situation where more sophisticated techniques are urgently needed to properly handle this mass of information. In this sense, the more ambitious plan for an evolution of a Web is the so called Semantic Web, envisioned by the inventor of the Web itself, Tim Berners-Lee. In this architectural vision, there is the need for further layers of semantics, properly enriching the data that now overflow the classic Web: ontologies, rules, logic, proofs, trust are all ingredients of this ambitious picture. Given these premises, it should not come as a surprise the fact that this evolution is bringing the Web closer and closer to another field, that since quite some time has been facing similar problems of logical organization of knowledge: logic programming. Early examples, like the Metalog system in the World Wide Web Consortium (W3C), had shown that connecting logic programming and the Semantic Web was quite a natural and fruitful step: and in fact, the burst of research in Semantic Web developments has eventually started to touch, connect and reinterprete many topics that were and are mainstream of the logic programming area. We feel this is a necessary progression, as the Semantic Web, and more generally the Web of the future, has a lot to learn from research in the logic programming area. And, conversely, in these new scenarios there are lot of new applied problems that can be challenging and rewarding from a logic programming perspective. This calls for a tighter interaction between the Web and logic programming, which was the reason to motivate this special issue as well: gathering together a selection of the best contributions that could showcase the potential of the cross-breeding.

The refinement calculus for logic programs is a framework for deriving logic programs from specifications. It is based on a wide-spectrum language that can express both specifications and code, and a refinement relation that models the notion of correct implementation. In this paper we extend and generalise earlier work on contextual refinement. Contextual refinement simplifies the refinement process by abstractly capturing the context of a subcomponent of a program, which typically includes information about the values of the free variables. This paper also extends and generalises module refinement. A module is a collection of procedures that operate on a common data type; module refinement between a specification module A and an implementation module C allows calls to the procedures of A to be systematically replaced with calls to the corresponding procedures of C. Based on the conditions for module refinement, we present a method for calculating an implementation module from a specification module. Both contextual and module refinement within the refinement calculus have been generalised from earlier work and the results are presented in a unified framework.

Disjunctive logic programming (DLP) is a very expressive formalism. It allows forexpressing every property of finite structures that is decidable in thecomplexity class ΣP2(=NPNP). Despite this high expressiveness, thereare some simple properties, often arising in real-world applications, whichcannot be encoded in a simple and natural manner. Especially properties thatrequire the use of arithmetic operators (like sum, times, or count) on a set ormultiset of elements, which satisfy some conditions, cannot be naturallyexpressed in classic DLP. To overcome this deficiency, we extend DLP byaggregate functions in a conservative way. In particular, we avoid theintroduction of constructs with disputed semantics, by requiring aggregates tobe stratified. We formally define the semantics of the extended language (called ), and illustrate how it can be profitably used for representingknowledge. Furthermore, we analyze the computational complexity of , showing that the addition of aggregates does not bring a highercost in that respect. Finally, we provide an implementation of in DLV—a state-of-the-art DLP system—andreport on experiments which confirm the usefulness of the proposed extensionalso for the efficiency of computation.

This article considers the problem of reasoning on massive amounts of (possibly distributed) data. Presently, existing proposals show some limitations: (i) the quantity of data that can be handled contemporarily is limited, because reasoning is generally carried out in main-memory; (ii) the interaction with external (and independent) Database Management Systems is not trivial and, in several cases, not allowed at all; and (iii) the efficiency of present implementations is still not sufficient for their utilization in complex reasoning tasks involving massive amounts of data. This article provides a contribution in this setting; it presents a new system, called DLVDB, which aims to solve these problems. Moreover, it reports the results of a thorough experimental analysis we have carried out for comparing our system with several state-of-the-art systems (both logic and databases) on some classical deductive problems; the other tested systems are LDL++, XSB, Smodels, and three top-level commercial Database Management Systems. DLVDB significantly outperforms even the commercial database systems on recursive queries.

We present in this paper a first-order axiomatization of an extended theory T of finite or infinite trees, built on a signature containing an infinite set of function symbols and a relation finite(t), which enables to distinguish between finite and infinite trees. We show that T has at least one model and prove its completeness by giving not only a decision procedure, but a full first-order constraint solver that gives clear and explicit solutions for any first-order constraint satisfaction problem in T. The solver is given in the form of 16 rewriting rules that transform any first-order constraint ϕ into an equivalent disjunction φ of simple formulas such that φ is either the formula true or the formula false or a formula having at least one free variable, being equivalent neither to true nor to false and where the solutions of the free variables are expressed in a clear and explicit way. The correctness of our rules implies the completeness of T. We also describe an implementation of our algorithm in CHR (Constraint Handling Rules) and compare the performance with an implementation in C++ and that of a recent decision procedure for decomposable theories.

We introduce and study logic programs whose clauses are built out of monotone constraint atoms. We show that the operational concept of the one-step provability operator generalizes to programs with monotone constraint atoms, but the generalization involves nondeterminism. Our main results demonstrate that our formalism is a common generalization of (1) normal logic programming with its semantics of models, supported models and stable models, (2) logic programming with weight atoms lparse programs) with the semantics of stable models, as defined by Niemelä, Simons and Soininen, and (3) of disjunctive logic programming with the possible-model semantics of Sakama and Inoue.

Tracers provide users with useful information about program executions. In thisarticle, we propose a “tracer driver”. From a single tracer,it provides a powerful front-end enabling multiple dynamic analysis tools to beeasily implemented, while limiting the overhead of the trace generation. Therelevant execution events are specified by flexible event patterns and a largevariety of trace data can be given either systematically or “ondemand”. The proposed tracer driver has been designed in the contextof constraint logic programming (CLP); experiments have been made withinGNU-Prolog. Execution views provided by existing tools have been easily emulatedwith a negligible overhead. Experimental measures show that the flexibility andpower of the described architecture lead to good performance. The tracer driveroverhead is inversely proportional to the average time between two tracedevents. Whereas the principles of the tracer driver are independent of thetraced programming language, it is best suited for high-level languages, such asCLP, where each traced execution event encompasses numerous low-level executionsteps. Furthermore, CLP is especially hard to debug. The current environments donot provide all the useful dynamic analysis tools. They can significantlybenefit from our tracer driver which enables dynamic analyses to be integratedat a very low cost.

Tabled Constraint Logic Programming is a powerful execution mechanism for dealing with Constraint Logic Programming without worrying about fixpoint computation. Various applications, e.g. in the fields of program analysis and model checking, have been proposed. Unfortunately, a high-level system for developing new applications is lacking, and programmers are forced to resort to complicated ad hoc solutions.

This papers presents TCHR, a high-level framework for tabled Constraint Logic Programming. It integrates in a light-weight manner Constraint Handling Rules (CHR), a high-level language for constraint solvers, with tabled Logic Programming. The framework is easily instantiated with new application-specific constraint domains. Various high-level operations can be instantiated to control performance. In particular, we propose a novel, generalized technique for compacting answer sets.

This paper presents a new type analysis for logic programs. The analysis is performed with a priori type definitions; and type expressions are formed from a fixed alphabet of type constructors. Non-discriminative union is used to join type information from different sources without loss of precision. An operation that is performed repeatedly during an analysis is to detect if a fixpoint has been reached. This is reduced to checking the emptiness of types. Due to the use of non-discriminative union, the fundamental problem of checking the emptiness of types is more complex in the proposed type analysis than in other type analyses with a priori type definitions. The experimental results, however, show that use of tabling reduces the effect to a small fraction of analysis time on a set of benchmarks.

The Semantic Web drives toward the use of the Web for interacting with logically interconnected data. Through knowledge models such as Resource Description Framework (RDF), the Semantic Web provides a unifying representation of richly structured data. Adding logic to the Web implies the use of rules to make inferences, choose courses of action, and answer questions. This logic must be powerful enough to describe complex properties of objects but not so powerful that agents can be tricked by being asked to consider a paradox. The Web has several characteristics that can lead to problems when existing logics are used, in particular, the inconsistencies that inevitably arise due to the openness of the Web, where anyone can assert anything. N3Logic is a logic that allows rules to be expressed in a Web environment. It extends RDF with syntax for nested graphs and quantified variables and with predicates for implication and accessing resources on the Web, and functions including cryptographic, string, math. The main goal of N3Logic is to be a minimal extension to the RDF data model such that the same language can be used for logic and data. In this paper, we describe N3Logic and illustrate through examples why it is an appropriate logic for the Web.

Refactoring is an established technique from the object-oriented (OO) programming community to restructure code: it aims at improving software readability, maintainability, and extensibility. Although refactoring is not tied to the OO-paradigm in particular, its ideas have not been applied to logic programming until now. This paper applies the ideas of refactoring to Prolog programs. A catalogue is presented listing refactorings classified according to scope. Some of the refactorings have been adapted from the OO-paradigm, while others have been specifically designed for Prolog. The discrepancy between intended and operational semantics in Prolog is also addressed by some of the refactorings. In addition, ViPReSS, a semi-automatic refactoring browser, is discussed and the experience with applying ViPReSS to a large Prolog legacy system is reported. The main conclusion is that refactoring is both a viable technique in Prolog and a rather desirable one.

Building rules on top of ontologies is the ultimate goal of the logical layer of the Semantic Web. To this aim, an ad-hoc markup language for this layer is currently under discussion. It is intended to follow the tradition of hybrid knowledge representation and reasoning systems, such as -log that integrates the description logic and the function-free Horn clausal language Datalog. In this paper, we consider the problem of automating the acquisition of these rules for the Semantic Web. We propose a general framework for rule induction that adopts the methodological apparatus of Inductive Logic Programming and relies on the expressive and deductive power of -log. The framework is valid whatever the scope of induction (description versus prediction) is. Yet, for illustrative purposes, we also discuss an instantiation of the framework which aims at description and turns out to be useful in Ontology Refinement.

Recently there has been a growing interest in research in tabling in the logic programming community because of its usefulness in a variety of application domains including program analysis, parsing, deductive databases, theorem proving, model checking, and logic-based probabilistic learning. The main idea of tabling is to memorize the answers to some subgoals and use the answers to resolve subsequent variant subgoals. Early resolution mechanisms proposed for tabling such as OLDT and SLG rely on suspension and resumption of subgoals to compute fixpoints. Recently, the iterative approach named linear tabling has received considerable attention because of its simplicity, ease of implementation, and good space efficiency. Linear tabling is a framework from which different methods can be derived on the basis of the strategies used in handling looping subgoals. One decision concerns when answers are consumed and returned. This article describes two strategies, namely, lazy and eager strategies, and compares them both qualitatively and quantitatively. The results indicate that, while the lazy strategy has good locality and is well suited for finding all solutions, the eager strategy is comparable in speed with the lazy strategy and is well suited for programs with cuts. Linear tabling relies on depth-first iterative deepening rather than suspension to compute fixpoints. Each cluster of interdependent subgoals as represented by a topmost looping subgoal is iteratively evaluated until no subgoal in it can produce any new answers. Naive re-evaluation of all looping subgoals, albeit simple, may be computationally unacceptable. In this article, we also introduce semi-naive optimization, an effective technique employed in bottom-up evaluation of logic programs to avoid redundant joins of answers, into linear tabling. We give the conditions for the technique to be safe (i.e., sound and complete) and propose an optimization technique called early answer promotion to enhance its effectiveness. Benchmarking in B-Prolog demonstrates that with this optimization linear tabling compares favorably well in speed with the state-of-the-art implementation of SLG.

Requirements about the quality of clinical guidelines can be represented byschemata borrowed from the theory of abductive diagnosis, using temporal logicto model the time-oriented aspects expressed in a guideline. Previously, we haveshown that these requirements can be verified using interactive theorem provingtechniques. In this paper, we investigate how this approach can be mapped to thefacilities of a resolution-based theorem prover, otter and acomplementary program that searches for finite models of first-order statements,mace-2. It is shown that the reasoning required for checking thequality of a guideline can be mapped to such a fully automated theorem-provingfacilities. The medical quality of an actual guideline concerning diabetesmellitus 2 is investigated in this way.

Given an argumentation framework AF, we introduce a mapping function that constructs a disjunctive logic program P, such that the preferred extensions of AF correspond to the stable models of P, after intersecting each stable model with the relevant atoms. The given mapping function is of polynomial size w.r.t. AF.

In particular, we identify that there is a direct relationship between the minimal models of a propositional formula and the preferred extensions of an argumentation framework by working on representing the defeated arguments. Then we show how to infer the preferred extensions of an argumentation framework by using UNSAT algorithms and disjunctive stable model solvers. The relevance of this result is that we define a direct relationship between one of the most satisfactory argumentation semantics and one of the most successful approach of nonmonotonic reasoning i.e., logic programming with the stable model semantics.

We are researching the interaction between the rule and the ontology layers of the Semantic Web, by comparing two options: 1) using OWL and its rule extension SWRL to develop an integrated ontology/rule language, and 2) layering rules on top of an ontology with RuleML and OWL. Toward this end, we are developing the SWORIER system, which enables efficient automated reasoning on ontologies and rules, by translating all of them into Prolog and adding a set of general rules that properly capture the semantics of OWL. We have also enabled the user to make dynamic changes on the fly, at run time. This work addresses several of the concerns expressed in previous work, such as negation, complementary classes, disjunctive heads, and cardinality, and it discusses alternative approaches for dealing with inconsistencies in the knowledge base. In addition, for efficiency, we implemented techniques called extensionalization, avoiding reanalysis, and code minimization.

In everyday life it happens that a person has to reason out what other peoplethink and how they behave, in order to achieve his goals. In other words, anindividual may be required to adapt his behavior by reasoning about the others'mental state. In this paper we focus on a knowledge-representation languagederived from logic programming which both supports the representation of mentalstates of individual communities and provides each with the capability ofreasoning about others' mental states and acting accordingly. The proposedsemantics is shown to be translatable into stable model semantics of logicprograms with aggregates.

Logic programming under the answer-set semantics nowadays deals with numerous different notions of program equivalence. This is due to the fact that equivalence for substitution (known as strong equivalence) and ordinary equivalence are different concepts. The former holds, given programs P and Q, iff P can be faithfully replaced by Q within any context R, while the latter holds iff P and Q provide the same output, that is, they have the same answer sets. Notions in between strong and ordinary equivalence have been introduced as theoretical tools to compare incomplete programs and are defined by either restricting the syntactic structure of the considered context programs R or by bounding the set of atoms allowed to occur in R (relativized equivalence). For the latter approach, different yield properly different equivalence notions, in general. For the former approach, however, it turned out that any “reasonable” syntactic restriction to R coincides with either ordinary, strong, or uniform equivalence (for uniform equivalence, the context ranges over arbitrary sets of facts, rather than program rules). In this paper, we propose a parameterization for equivalence notions which takes care of both such kinds of restrictions simultaneously by bounding, on the one hand, the atoms which are allowed to occur in the rule heads of the context and, on the other hand, the atoms which are allowed to occur in the rule bodies of the context. We introduce a general semantical characterization which includes known ones as SE-models (for strong equivalence) or UE-models (for uniform equivalence) as special cases. Moreover, we provide complexity bounds for the problem in question and sketch a possible implementation method making use of dedicated systems for checking ordinary equivalence.

In this paper we introduce a class of constraint logic programs such that their termination can be proved by using affine level mappings. We show that membership to this class is decidable in polynomial time.

Extensible Markup Language (XML) is a simple, very flexible text format derived from SGML. Originally designed to meet the challenges of large-scale electronic publishing, XML is also playing an increasingly important role in the exchange of a wide variety of data on the Web and elsewhere. XPath language is the result of an effort to provide address parts of an XML document. In support of this primary purpose, it becomes in a query language against an XML document. In this paper we present a proposal for the implementation of the XPath language in logic programming. With this aim we will describe the representation of XML documents by means of a logic program. Rules and facts can be used for representing the document schema and the XML document itself. In particular, we will present how to index XML documents in logic programs: rules are supposed to be stored in main memory, however facts are stored in secondary memory by using two kind of indexes: one for each XML tag, and other for each group of terminal items. In addition, we will study how to query by means of the XPath language against a logic program representing an XML document. It evolves the specialization of the logic program with regard to the XPath expression. Finally, we will also explain how to combine the indexing and the top-down evaluation of the logic program.