The Journal of Logic Programming最新文献

The independent choice logic (ICL) is part of a project to combine logic and decision/game theory into a coherent framework. The ICL has a simple possible-worlds semantics characterised by independent choices and an acyclic logic program that specifies the consequences of these choices. This paper gives an abductive characterization of the ICL. The ICL is defined model-theoretically, but we show that it is naturally abductive: the set of explanations of a proposition g is a concise description of the worlds in which g is true. We give an algorithm for computing explanations and show it is sound and complete with respect to the possible-worlds semantics. What is unique about this approach is that the explanations of the negation of g can be derived from the explanations of g. The use of probabilities over choices in this framework and going beyond acyclic logic programs are also discussed.

Nonmonotonic reasoning has been explored as a form of abductive reasoning where default assumptions are treated as abductive hypotheses. While the semantics and proof theories under this approach have been studied extensively, the question of how disjunctive programs may be used to reason abductively has rarely been investigated. At the center of the question is how to embed disjunctive reasoning into that of negation-as-failure. A more concrete question is about whether the elegant abductive proof procedure by Eshghi and Kowalski can be extended to answer queries for disjunctive programs, and if yes, what is the semantics that such an extended procedure computes. In this paper we answer these questions by formulating a semantics, the regular extension semantics, for disjunctive programs, and by presenting a sound and complete extension of the Eshghi–Kowalski procedure, called disjunctive EK procedure, for query answering with respect to ground disjunctive programs under this semantics.

The precise probability of a compound event (e.g. $\text{e}{}_1\text{∨}\text{e}{}_2\text{,e}{}_1\text{∧}\text{e}{}_2$) depends upon the known relationships (e.g. independence, mutual exclusion, ignorance of any relationship, etc.) between the primitive events that constitute the compound event. To date, most research on probabilistic logic programming has assumed that we are ignorant of the relationship between primitive events. Likewise, most research in AI (e.g. Bayesian approaches) has assumed that primitive events are independent. In this paper, we propose a hybrid probabilistic logic programming language in which the user can explicitly associate, with any given probabilistic strategy, a conjunction and disjunction operator, and then write programs using these operators. We describe the syntax of hybrid probabilistic programs, and develop a model theory and fixpoint theory for such programs. Last, but not least, we develop three alternative procedures to answer queries, each of which is guaranteed to be sound and complete.

It is well-known that adding structural information to an analysis domain can increase the precision of the analysis with respect to the original domain. This paper presents a program transformation based on untupling and specialisation which can be applied to upgrade (logic) program analysis by providing additional structural information. It can be applied to (almost) any type of analysis and in conjunction with (almost) any analysis framework for logic programs. The approach is an attractive alternative to the more complex Pat$\text{(}\text{R}\text{)}$ construction which automatically enhances an abstract domain $\text{R}$ (in the context of abstract interpretation) with structural information.

Tracing by automatic program source instrumentation has major advantages over compiled code instrumentation: it is more portable from one Prolog system to another, it produces traces in terms of the original program, and it can be tailored to specific debugging needs. The main argument usually put forward in favor of compiled code instrumentation is its supposed efficiency. We have compared the performances of two operational low-level Prolog tracers with source instrumentation. We have executed classical Prolog benchmark programs, collecting trace information without displaying it. On average, collecting trace information by program instrumentation is about as fast as using a low-level tracer in one case, and only twice slower in the other. This is a minor penalty to pay, compared to the advantages of the approach. To our knowledge, this is the first time that a quantitative comparison of both approaches is made for any programming language.