As time goes by: Constraint Handling Rules

@article{Sneyers2009AsTG,
  title={As time goes by: Constraint Handling Rules},
  author={Jon Sneyers and Peter Van Weert and Tom Schrijvers and Leslie De Koninck},
  journal={Theory and Practice of Logic Programming},
  year={2009},
  volume={10},
  pages={1 - 47}
}
Abstract Constraint Handling Rules (CHR) is a high-level programming language based on multiheaded multiset rewrite rules. Originally designed for writing user-defined constraint solvers, it is now recognized as an elegant general purpose language. Constraint Handling Rules related research has surged during the decade following the previous survey by Frühwirth (J. Logic Programming, Special Issue on Constraint Logic Programming, 1998, vol. 37, nos. 1–3, pp. 95–138). Covering more than 180… 
Constraint Handling Rules
TLDR
This tutorial shows how to use CHR for solving their problems quickly and elegantly and makes the attendants aware of CHR's strengths as a programming language, and teaches them when and how to apply CHR for small to medium sized problems.
Optimization of CHR propagation rules: extended report
TLDR
This report introduces several optimizations that, for the majority of CHR rules, eliminate this overhead, and formally prove their correctness, and evaluates their implementation in two state-of-the-art CHR systems.
Optimizing Compilation and Computational Complexity of Constraint Handling Rules
Constraint Handling Rules [1,2] is a high-level programming language extension based on multi-headed committed-choice multiset rewrite rules. It can be used as a stand-alone language or as an
Aggregates in Constraint Handling Rules
TLDR
Constraint Handling Rules is a general-purpose programming language based on committed-choice, multi-headed, guarded multiset rewrite rules that requires explicit encoding, using auxiliary constraints and rules.
A tale of histories
TLDR
This work introduces two optimizations to reduce or even eliminate this overhead of CHR implementation, and evaluates their implementation in two state-of-the-art CHR systems.
Confluence Modulo Equivalence in Constraint Handling Rules
TLDR
A new operational semantics for CHR is introduced that significantly reduces notational overhead and allows to consider confluence for programs with extra-logical and incomplete built-in predicates.
Optimization of CHR Propagation Rules
TLDR
This work introduces several optimizations that, for the majority of CHR rules, eliminate this overhead, and formally prove their correctness, and evaluates their implementation in two state-of-the-art CHR systems.
CHR(Curry): Interpretation and Compilation of Constraint Handling Rules in Curry
TLDR
It is argued that an integrated functional logic language like Curry is an appropriate host language for CHR since it supports a natural formulation of constraint handling rules and a seamless integration into a typed environment.
The computational power and complexity of constraint handling rules
TLDR
The CHR machine is introduced, a model of computation based on the operational semantics of CHR that is compared to those of the well-understood Turing machine and Random Access Memory machine and proves the interesting result that every algorithm can be implemented in CHR with the best known time and space complexity.
Roskilde University Confluence Modulo Equivalence in Constraint Handling Rules
TLDR
A new operational semantics for CHR is introduced that significantly reduces notational overhead and allows to consider confluence for programs with extra-logical and incomplete builtin predicates.
...
...

References

SHOWING 1-10 OF 257 REFERENCES
High-Level Implementations of Constraint Handling Rules
TLDR
This paper describes basic principles of implementing CHRs in logic programming languages and shows how they actually have been implemented in the CHRs library of ECL i PS e , ECRC's constraint logic programming platform.
Theory and Practice of Constraint Handling Rules
A new approach to termination analysis of Constraint Handling Rules
TLDR
A new approach to termination analysis of CHR is presented which is applicable to a much larger class of CHR programs and successfully tested the condition on a benchmark of programs, using a prototype analyser.
On Completion of Constraint Handling Rules
TLDR
So-called completion methods that make a non-confluent CHR program confluent by adding new rules are investigated and it is shown that completion can be used to define new constraints in terms of already existing constraints and to derive constraint solvers for them.
Extending arbitrary solvers with constraint handling rules
TLDR
This paper shows how to define CHR programs that extend arbitrary solvers and fully interact with them, and examines how to compile such programs to perform as little recomputation as possible, and describes how to build index structures for CHR constraints that are modified automatically when variables in the underlying solver change.
Translating Constraint Handling Rules into Action Rules
TLDR
This paper explores a different implementation target for CHR: B-Prolog’s Action Rules (ARs), a rule-based language that is a good match for particular aspects of CHR.
Aggregates in Constraint Handling Rules
TLDR
Constraint Handling Rules is a general-purpose programming language based on committed-choice, multi-headed, guarded multiset rewrite rules that requires explicit encoding, using auxiliary constraints and rules.
Adding Constraint Handling Rules to Curry
TLDR
This paper proposes an integration of Constraint Handling Rules (CHR), a rulebased language to specify application-oriented constraint solvers, into the declarative multiparadigm language Curry, and defines a set of abstractions that hide the concrete CHR data objects.
Optimal union-find in Constraint Handling Rules
TLDR
It is shown that it is also possible to write the classic union-find algorithm and variants in CHR, and the time complexity of these programs match the almost-linear complexity of the best known imperative implementations.
The Refined Operational Semantics of Constraint Handling Rules
TLDR
This paper formally defines this refined operational semantics of CHRs and proves it implements the theoretical operational semantics, and shows how to create a (partial) confluence checker capable of detecting programs which are confluent under this semantics, but not under the theoretical Operational semantics.
...
...