Slim Abdennadher

Essentials of Constraint Programming

1. Introduction.- I. Constraint Programming.- 2. Algorithm = Logic + Control.- 3. Preliminaries of Syntax and Semantics.- 4. Logic Programming.- 5. Constraint Logic Programming.- 6. Concurrent Constraint Logic Programming.- 7. Constraint Handling Rules.- II. Constraint Systems.- 8. Constraint Systems and Constraint Solvers.- 9. Boolean Algebra B.- 10. Rational Trees RT.- 11. Linear Polynomial Equations R.- 12. Finite Domains FD.- 13. Non-linear Equations I.- III. Applications.- 14. Market Overview.- 15. Optimal Sender Placement for Wireless Communication.- 16. The Munich Rent Advisor.- 17. University Course Timetabling.- IV. Appendix.- A. Foundations from Logic.- A.1 First-Order Logic: Syntax and Semantics.- A.2 Basic Calculi and Normal Forms.- A.2.1 Substitutions.- A.2.2 Negation Normal Form and Prenex Form.- A.2.3 Skolemization.- A.2.4 Clauses.- A.2.5 Resolution.- List of Figures.- References.

Operational Semantics and Confluence of Constraint Propagation Rules

Constraint Handling Rules (CHR) allow one to specify and implement both propagation and simplification for user-defined constraints. Since a propagation rule is applicable again and again, we present in this paper for the first time an operational semantics for CHR that avoids the termination problem with propagation rules. In previous work [AFM96], a sufficient and necessary condition for the confluence of terminating simplification rules was given inspired by results about conditional term rewriting systems. Confluence ensures that the solver will always compute the same result for a given set of constraints independent of which rules are applied. The confluence of propagation rules was an open problem. This paper shows that we can also give a sufficient and a necessary condition for confluence of terminating CHR programs with propagation rules based on the more refined operational semantics.

Enhancing one-class support vector machines for unsupervised anomaly detection

Support Vector Machines (SVMs) have been one of the most successful machine learning techniques for the past decade. For anomaly detection, also a semi-supervised variant, the one-class SVM, exists. Here, only normal data is required for training before anomalies can be detected. In theory, the one-class SVM could also be used in an unsupervised anomaly detection setup, where no prior training is conducted. Unfortunately, it turns out that a one-class SVM is sensitive to outliers in the data. In this work, we apply two modifications in order to make one-class SVMs more suitable for unsupervised anomaly detection: Robust one-class SVMs and eta one-class SVMs. The key idea of both modifications is, that outliers should contribute less to the decision boundary as normal instances. Experiments performed on datasets from UCI machine learning repository show that our modifications are very promising: Comparing with other standard unsupervised anomaly detection algorithms, the enhanced one-class SVMs are superior on two out of four datasets. In particular, the proposed eta one-class SVM has shown the most promising results.

Confluence and Semantics of Constraint Simplification Rules

Constraint Simplification Rules (CSR) is a subset of the Constraint Handling Rules (CHR) language. CHR is a powerful special-purpose declarative programming language for writing constraint solvers. The CSR subset of CHR forms essentially a committed-choice language consisting of guarded rules with multiple heads that replace constraints by simpler ones until they are solved. This paper gives declarative and operational semantics as well as soundness and completeness results for CSR programs.We also introduce a notion of confluence for CSR programs. Confluence is an essential syntactical property of any constraint solver. It ensures that the solver will always compute the same result for a given set of constraints independent of which rules are applied. It also means that it does not matter for the result in which order the constraints arrive at the constraint solver.We give a decidable, sufficient and necessary syntactic condition for confluence of terminating CSR programs. Moreover, as shown in this paper, confluence of a program implies consistency of its logical meaning (under a mild restriction).

CHRv: A Flexible Query Language

We show how the language Constraint Handling Rules (CHR), a high-level logic language for the implementation of constraint solvers, can be slightly extended to become a general-purpose logic programming language with an expressive power subsuming the expressive ower of Horn clause programs with SLD resolution. The extended language, called “CHR∀”, retains however the extra features of CHR, e.g., committed choice and matching, which axe important for other purposes, especially for efficiently solving constraints. CHR∀ turns out to be a very flexible query language in the sense that it supports several (constraint) logic programming paradigms and allows to mix them in a single program. In particular, it supports top-down query evaluation and also bottom-up evaluation as it is frequently used in (disjunctive) deductive databases.

An Experimental CLP Platform for Integrity Constraints and Abduction

Integrity constraint and abduction are important in query-answering systems for enhanced query processing and for expressing knowledge in databases. A straightforward characterization of the two is given in a subset of the language CHRv, originally intended for writing constraint solvers to be applied for CLP languages. This subset has a strikingly simple computational model that can be executed using existing, Prolog-based technology. Together with earlier results, this confirms CHRv as a multiparadigm platform for experimenting with combinations of top-down and bottom-up evaluation, disjunctive databases and, as shown here, integrity constraint and abduction

JACK:: A Java Constraint Kit

Abstract Most existing libraries providing constraint facilities are embedded in the logic programming language, Prolog, or in the object-oriented language, C++. Recently, some proposals have been made to integrate constraint handling in Java. The goal of this work is to provide a new constraint library for Java, called JACK. It consists of a high-level language for writing constraint solvers, a generic search engine and a tool to visualize the simplification and propagation of constraints.

On confluence of constraint handling rules

We introduce the notion of confluence for Constraint Handling Rules (CHR), a powerful language for writing constraint solvers. With CHR one simplifies and solves constraints by applying rules. Confluence guarantees that a CHR program will always compute the same result for a given set of constraints independent of which rules are applied. We give a decidable, sufficient and necessary syntactic condition for confluence. Confluence turns out to be an essential syntactical property of CHR programs for two reasons. First, confluence implies correctness (as will be shown in this paper). In a correct CHR program, application of CHR rules preserves logical equivalence of the simplified constraints. Secondly, even when the program is already correct, confluence is highly desirable. Otherwise, given some constraints, one computation may detect their inconsistency while another one may just simplify them into a still complex constraint. As a side-effect, the paper also gives soundness and completeness results for CHR programs. Due to their special nature, and in particular correctness, these theorems are stronger than what holds for the related families of (concurrent) constraint programming languages.

Operational Equivalence of CHR Programs and Constraints

A fundamental question in programming language semantics is when two programs should be considered equivalent. In this paper we introduce a notion of operational equivalence for CHR programs and user-defined constraints. Constraint Handling Rules (CHR) is a high-level language for writing constraint solvers either from scratch or by modifying existing solvers.

Integration and Optimization of Rule-Based Constraint Solvers

One lesson learned from practical constraint solving applications is that constraints are often heterogeneous. Solving such constraints requires a collaboration of constraint solvers. In this paper, we introduce a methodology for the tight integration of CHR constraint programs into one such program. CHR is a high-level rule-based language for writing constraint solvers and reasoning systems. A constraint solver is well-behaved if it is terminating and confluent. When merging constraint solvers, this property may be lost. Based on previous results on CHR program analysis and transformation we show how to utilize completion to regain well-behavedness. We identify a class of solvers whose union is always confluent and we show that for preserving termination such a class is hard to find. The merged and completed constraint solvers may contain redundant rules. Utilizing the notion of operational equivalence, which is decidable for well-behaved CHR programs, we present a method to detect redundant rules in a CHR program.