Thom W. Frühwirth

Theory and practice of constraint handling rules

Abstract Constraint Handling Rules (CHR) are our proposal to allow more flexibility and application-oriented customization of constraint systems. CHR are a declarative language extension especially designed for writing user-defined constraints. CHR are essentially a committed-choice language consisting of multi-headed guarded rules that rewrite constraints into simpler ones until they are solved. In this broad survey we aim at covering all aspects of CHR as they currently present themselves. Going from theory to practice, we will define syntax and semantics for CHR, introduce an important decidable property, confluence, of CHR programs and define a tight integration of CHR with constraint logic programming languages. This survey then describes implementations of the language before we review several constraint solvers – both traditional and nonstandard ones – written in the CHR language. Finally we introduce two innovative applications that benefited from using CHR.

Logic programs as types for logic programs

Optimistic type systems for logic programs are considered. In such systems types are conservative approximations to the success set of the program predicates. The use of logic programs to describe types is proposed. It is argued that this approach unifies the denotational and operational approaches to descriptive type systems and is simpler and more natural than previous approaches. The focus is on the use of unary-predicate programs to describe the types. A proper class of unary-predicate programs is identified, and it is shown that it is expensive enough to express several notions of types. An analogy with two-way automata and a correspondence with alternating algorithms are used to obtain a complexity characterization of type inference and type checking. This characterization is facilitated by the use of logic programs to represent types.<<ETX>>

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).

KI 2004: Advances in Artificial Intelligence

The year 2004 marks the fiftieth birthday of the first computer generated proof of a mathematical theorem: “the sum of two even numbers is again an even number” (with Martin Davis’ implementation of Presburger Arithmetic in 1954). While Martin Davis and later the research community of automated deduction used machine oriented calculi to find the proof for a theorem by automatic means, the Automath project of N.G. de Bruijn – more modest in its aims with respect to automation – showed in the late 1960s and early 70s that a complete mathematical textbook could be coded and proof-checked by a computer. Classical theorem proving procedures of today are based on ingenious search techniques to find a proof for a given theorem in very large search spaces – often in the range of several billion clauses. But in spite of many successful attempts to prove even open mathematical problems automatically, their use in everyday mathematical practice is still limited. The shift from search based methods to more abstract planning techniques however opened up a new paradigm for mathematical reasoning on a computer and several systems of the new kind now employ a mix of interactive, search based as well as proof planning techniques. The Ωmega system is at the core of several related and well-integrated research projects of the Ωmega research group, whose aim is to develop system support for the working mathematician, in particular it supports proof development at a human oriented level of abstraction. It is a modular system with a central proof data structure and several supplementary subsystems including automated deduction and computer algebra systems. Ωmega has many characteristics in common with systems like NuPrL [ACE00], CoQ [Coq03], Hol [GM93], Pvs [ORR96], and Isabelle [Pau94,NPW02]. However, it differs from these systems with respect to its focus on proof planning and in that respect it is more similar to the proof planning systems Clam and λClam at Edinburgh [RSG98,BvHHS90]. 1 http://www.win.tue.nl/automath/ S. Biundo, T. Frühwirth, and G. Palm (Eds.): KI 2004, LNAI 3238, pp. 3–28, 2004. c

Optimal union-find in Constraint Handling Rules

Constraint Handling Rules (CHR) is a committed-choice rule-based language that was originally intended for writing constraint solvers. In this paper we show that it is also possible to write the classic union-find algorithm and variants in CHR. The programs neither compromise in declarativeness nor efficiency. We study the time complexity of our programs: they match the almost-linear complexity of the best known imperative implementations. This fact is illustrated with experimental results.

Temporal annotated constraint logic programming

Abstract We introduce a family of logics and associated programming languages for representing and reasoning about time. The family is conceptually simple while allowing for different models of time. Formulae can be labelled with temporal information using annotations. In this way we avoid the proliferation of variables and quantifiers as encountered in first order approaches. Unlike temporal logic, both qualitative and quantitative (metric) temporal reasoning about definite and indefinite information with time points (instants) and time periods (temporal intervals) in different models of time are supported. Our temporal annotated logic can be made an instance of annotated constraint logic, which is also presented in this paper. Given a logic in this framework, there is a systematic way to make a clausal fragment executable as a constraint logic program. We show this for the generic case and for the specific case of temporal annotated logic. In both cases we give an interpreter and a compiler that can be implemented in standard constraint logic programming languages.

A linear-logic semantics for constraint handling rules

One of the attractive features of the Constraint Handling Rules (CHR) programming language is its declarative semantics where rules are read as formulae in first-order predicate logic. However, the more CHR is used as a general-purpose programming language, the more the limitations of that kind of declarative semantics in modelling change become apparent. We propose an alternative declarative semantics based on (intuitionistic) linear logic, establishing strong theorems on both soundness and completeness of the new declarative semantics w.r.t. operational semantics.

Compiling Constraint Handling Rules into Prolog with Attributed Variables

We introduce the most recent and advanced implementation of constraint handling rules (CHR) in a logic programming language, which improves both on previous implementations (in terms of completeness, flexibility and efficiency) and on the principles that should guide such a Prolog implementation consisting of a runtime system and a compiler. The runtime system utilizes attributed variables for the realization of the constraint store with efficient retrieval and update mechanisms. Rules describing the interactions between constraints are compiled into Prolog clauses by a multi-phase compiler, the core of which comprises a small number of compact code generating templates in the form of definite clause grammar rules.

Proving Termination of Constraint Solver Programs

We adapt and extend existing approaches to termination in rule-based languages (logic programming and rewriting systems) to prove termination of actually implemented CHR constraint solvers. CHR (Constraint Handling Rules) are a declarative language especially designed for writing constraint solvers. CHR are a concurrent constraint logic programming language consisting of multi-headed guarded rules that rewrite constraints into simpler ones until they are solved. The approach allows to prove termination of many constraint solvers, from Boolean and arithmetic to terminological and path-consistent constraints. Because of multi-heads, our termination orders must consider conjunctions, while atomic formulas suffice in usual approaches. Our results indicate that in practice, proving termination for concurrent constraint logic programs may not be harder than for other classes of logic programming languages, contrary to what has been feared in the literature.

Parallelizing union-find in constraint handling rules using confluence analysis

Constraint Handling Rules is a logical concurrent committed-choice rule-based language. Recently it was shown that the classical union-find algorithm can be implemented in CHR with optimal time complexity. Here we investigate if a parallel implementation of this algorithm is also possible in CHR. The problem is hard for several reasons: - Up to now, no parallel computation model for CHR was defined. - Tarjans optimal union-find is known to be hard to parallelize. - The parallel code should be as close as possible to the sequential one. It turns out that confluence analysis of the sequential implementation gives almost all the information needed to parallelize the union-find algorithm under a rather general parallel computation model for CHR.