The Journal of Logic Programming最新文献

We propose an approach to declarative programming which integrates the functional and relational paradigms by taking possibly non-deterministic lazy functions as the fundamental notion. Classical equational logic does not supply a suitable semantics in a natural way. Therefore, we suggest to view programs as theories in a constructor-based conditional rewriting logic. We present proof calculi and a model theory for this logic, and we prove the existence of free term models which provide an adequate intended semantics for programs. We develop a sound and strongly complete lazy narrowing calculus, which is able to support sharing without the technical overhead of graph rewriting and to identify safe cases for eager variable elimination. Moreover, we give some illustrative programming examples, and we discuss the implementability of our approach.

We present a new and general approach for defining, understanding, and computing logic programming semantics. We consider disjunctive programs for generality, but our results are still interesting if specialized to normal programs. Our framework consists of two parts: (a) a semantical, where semantics are defined in an abstract way as the weakest semantics satisfying certain properties, and (b) a procedural, namely a bottom-up query evaluation method based on operators working on conditional facts. As to (a), we concentrate in this paper on a particular set of abstract properties (the most important being the unfolding or partial evaluation property GPPE) and define a new semantics D-WFS, which extends WFS and GCWA. We also mention that various other semantics, like Fitting's comp₃, Schipf's WFS_c, Gelfond and lifschitz' STABLE and Ross and Topor's WGCWA (also introduced independently by Rajasekar et al. (A. Rajasekar, J. Lobo, J. Minker, Journal of Automated Reasoning 5 (1989) 293–307)), can be captured in our framework. In (b) we compute for any program P a residual program res(P), and show that res(P) is equivalent to the original program under very general conditions on the semantics (which are satisfied, e.g., by the well-founded, stable, stationary, and static semantics). Many queries with respect to these semantics can already be answered on the basis of the residual program. In fact, res(P) is complete for D-WFS, WFS and GCWA.

The aim of our work is the definition of compositional semantics for modular units over the class of normal logic programs. In this sense, we propose a declarative semantics for normal logic programs in terms of model classes that is monotonic in the sense that $\text{Mod}\text{(P∪P′) ⊆}\text{Mod}\text{(P)}$, for any programs P and P′ and we show that in the model class associated to every program there is a least model that can be seen as the semantics of the program, which may be built upwards as the least fix point of a continuous immediate consequence operator. In addition, it is proved that this least model is “typical” for the class of models of Clark-Kunen's completion of the program. This means that our semantics is equivalent to Clark-Kunen's completion. Moreover, following the approach defined in a previous paper, it is shown that our semantics constitutes a “specification frame ” equipped with the adequate categorical constructions needed to define compositional and fully abstract (categorical) semantics for a number of program units. In particular, we provide a categorical semantics of arbitrary normal logic program fragments which is compositional and fully abstract with respect to the (standard) union.

We present a proof method in the style of Hoare's logic, aimed at providing a unifying framework for the verification of total correctness of logic and Prolog programs. The method, which relies on purely declarative reasoning, has been designed as a trade-off between expresiveness and ease of use. On the basis of a few simple principles, we reason uniformly on several properties of logic and Prolog programs, including partial correctness, call patterns, absence of run-time errors, safe omission of the occur-check, computed instances, termination and modula program development. We finally generalize the method to general programs.

We show how declarative diagnosis techniques can be extended to cope with verification of operational properties, such as computed and correct answers, and of abstract properties, such as depth(k) answers and groundness dependencies. The extension is achieved by using a simple semantic framework, based on abstract interpretation. The resulting technique (abstract diagnosis) leads to elegant bottom-up and top-down verification methods, which do not require to determine the symptoms in advance, and which are effective in the case of abstract properties described by finite domains.

Traces of program executions are a helpful source of information for program debugging. They, however, give a picture of program executions at such a low level that users often have difficulties to interpret the information. Opium, our extendable trace analyzer, is connected to a “standard” Prolog tracer. Opium is programmable and extendable. It provides a trace query language and abstract views of executions. Users can therefore examine program executions at the levels of abstraction which suit them. Opium has shown its capabilities to build abstract tracers and automated debugging facilities. This article describes in depth the trace query mechanism, from the model to its implementation. Characteristic examples are detailed. Extensions written so far on top of the trace query mechanism are listed. Two recent extensions are presented: the abstract tracers for the LO (Linear Objects) and the CHR (Constraint Handling Rules) languages. These two extensions were specified and implemented within a few days. They show how to use Opium for real applications.

Although Prolog is (still) the most widely used logic language, it suffers from a number of drawbacks which prevent it from being truely declarative. The nondeclarative features such as the depth-first search rule are nevertheless necessary to make Prolog reasonably efficient. Several authors have proposed methodologies to reconcile declarative programming with the algorithmic features of Prolog. The idea is to analyse the logic program with respect to a set of properties such as modes, types, sharing, termination, and the like in order to ensure that the operational behaviour of the Prolog program complies with its logic meaning. Such analyses are tedious to perform by hand and can be automated to some extent. This paper presents a state-of-the-art analyser which allows one to integrate many individual analyses previously proposed in the literature as well as new ones. Conceptually, the analyser is based on the notion of abstract sequence which makes it possible to collect all kinds of desirable information, including relations between the input and output sizes of terms, multiplicity, and termination.

Modes were introduced in logic programming to differentiate the input arguments of a predicate from its output arguments. This information can be used for verifying the most diverse properties of logic programs notably absence of run-time errors and absence of dead-locks in presence of delay declarations. We introduce here layered modes, an extension of existing mode systems which allow us to enlarge the class of programs which can be verified by using modes. In particular, we show that this extension allows us to better handle programs that employ a dynamic selection rule and programs that use incomplete data structures such as difference-lists.