Sofie Verbaeten

Logic programs with annotated disjunctions

Current literature offers a number of different approaches to what could generally be called “probabilistic logic programming”. These are usually based on Horn clauses. Here, we introduce a new formalism, Logic Programs with Annotated Disjunctions, based on disjunctive logic programs. In this formalism, each of the disjuncts in the head of a clause is annotated with a probability. Viewing such a set of probabilistic disjunctive clauses as a probabilistic disjunction of normal logic programs allows us to derive a possible world semantics, more precisely, a probability distribution on the set of all Herbrand interpretations. We demonstrate the strength of this formalism by some examples and compare it to related work.

Ensemble methods for noise elimination in classification problems

Ensemble methods combine a set of classifiers to construct a new classifier that is (often) more accurate than any of its component classifiers. In this paper, we use ensemble methods to identify noisy training examples. More precisely, we consider the problem of mislabeled training examples in classification tasks, and address this problem by pre-processing the training set, i.e. by identifying and removing outliers from the training set. We study a number of filter techniques that are based on well-known ensemble methods like cross-validated committees, bagging and boosting. We evaluate these techniques in an Inductive Logic Programming setting and use a first order decision tree algorithm to construct the ensembles.

Termination proofs for logic programs with tabling

Tabled evaluation is receiving increasing attention in the logic programming community. It avoids many of the shortcomings of SLD execution and provides a more flexible and often considerably more efficient execution mechanism for logic programs. In particular, tabled execution terminates more often than execution based on SLD-resolution. In this article, we introduce two notions of universal termination of logic programming with tabling: quasi-termination and (the stronger notion of) LG-termination. We present sufficient conditions for these two notions of termination, namely quasi-acceptability and LG-acceptability, and we show that these conditions are also necessary in case the selection of tabled predicates meets certain natural criteria. Starting from these conditions, we develop modular termination proofs, i.e., proofs capable of combining termination proofs of separate programs to obtain termination proofs of combined programs. Finally, in the presence of mode information, we state sufficient conditions which form the basis for automatically proving termination in a constraint-based way.

Compositionality of normal open logic programs

Compositionality of programs is an important concern in knowledge representation and software development. In the context of Logic Programming, up till now, the issue has mostly been studied for definite programs only. Here, we study compositionality in the context of normal open logic programming. This is a logic for knowledge representation in the context of uncertainty and incomplete knowledge on concepts and on problem domain, in which the compositionality issue turns up very naturally. The semantics of the logic is a generalisation (allowing non-Herbrand interpretations) of the well-founded semantics. We provide a number of results which oAer diAerent suAcient conditions under which the models of the composition of two theories can be related to the intersection of the models of the composing theories. In particular, under these conditions, logical consequence will be preserved under composition. ” 2000 Elsevier Science Inc. All rights reserved.

Termination Analysis of Tabled Logic Programs Using Mode and Type Information

Tabled logic programming is receiving increasing attention in the Logic Programming community. It avoids many of the shortcomings of SLD(NF) execution and provides a more flexible and efficient execution mechanism for logic programs. In particular, tabled execution of logic programs terminates more often than execution based on SLD-resolution. One of the few approaches studying termination of tabled logic programs was developed by Decorte et al. They present necessary and sufficient conditions for two notions of universal termination under SLG-resolution, the resolution principle of tabling: quasi-termination and (the stronger notion of) LG-termination. Starting from these necessary and sufficient conditions, we introduce sufficient conditions which are stated fully at the clause level and are easy to automatize. To this end, we use mode and type information: we consider simply moded, well-typed programs and queries. We point out how our termination conditions can be automatized, by extending the recently developed constraint-based automatic termination analysis for SLD-resolution by Decorte and De Schreye.

Modular Termination Proofs for Prolog with Tabling

Tabling avoids many of the shortcomings of SLD(NF) execution and provides a more flexible and efficient execution mechanism for logic programs. In particular, tabled execution of logic programs terminates more often than execution based on SLD-resolution. One of the few works studying termination under a tabled execution mechanism is that of Decorte et al. They introduce and characterise two notions of universal termination of logic programs w.r.t. sets of queries executed under SLG-resolution, using the left-to-right selection rule; namely the notion of quasi-termination and the (stronger) notion of LG-termination. This paper extends the results of Decorte et al in two ways: (1) we consider a mix of tabled and Prolog execution, and (2) besides a characterisation of the two notions of universal termination under such a mixed execution, we also give modular termination conditions. From both practical and efficiency considerations, it is important to allow tabled and non-tabled predicates to be freely intermixed. This motivates the first extension. Concerning the second extension, it was already noted in the literature in the context of termination under SLD-resolution (by e.g. Apt and Pedreschi), that it is important for programming in the large to have modular termination proofs, i.e. proofs that are capable of combining termination proofs of separate programs to obtain termination proofs of combined programs.

Termination of simply-moded well-typed logic programs under a tabled execution mechanism

Abstract. Tabled logic programming is receiving increasing attention in the Logic Programming community. It avoids many of the shortcomings of SLD(NF) execution and provides a more flexible and often extremely efficient execution mechanism for logic programs. In particular, tabled execution of logic programs terminates more often than execution based on SLD-resolution. So, if a program can be proven to terminate under SLD-resolution, then the program will trivially also terminate under SLG-resolution, the resolution principle of tabling. But, since there are SLG-terminating programs which are not SLD-terminating, more effective proof techniques can be found. One of the few approaches studying termination of tabled logic programs was developed by Decorte et al. They present necessary and sufficient conditions for two notions of termination under LG-resolution, i.e. SLG-resolution with left-to-right selection rule: quasi-termination and (the stronger notion of) LG-termination. Starting from these necessary and sufficient conditions, we introduce sufficient conditions for quasi-termination and LG-termination which are stated fully at the clause level and are easy to automatize. To this end, we use mode and type information: we consider simply-moded, well-typed programs and queries. We point out how our termination conditions can be automatized, by extending the recently developed, constraint-based, automatic termination analysis for SLD-resolution of Decorte and De Schreye. Finally, we present a result on substitution-closedness of quasi-termination and LG-termination for the class of simply-moded, well-typed programs and queries.