Decidability properties for fragments of CHR

We study the decidability of termination for two CHR dialects which, similarly to the Datalog like languages, are defined by using a signature which does not allow function symbols (of arity >0). Both languages allow the use of the = built-in in the body of rules, thus are built on a host language that supports unification. However each imposes one further restriction. The first CHR dialect allows only range-restricted rules, that is, it does not allow the use of variables in the body or in the guard of a rule if they do not appear in the head. We show that the existence of an infinite computation is decidable for this dialect. The second dialect instead limits the number of atoms in the head of rules to one. We prove that in this case, the existence of a terminating computation is decidable. These results show that both dialects are strictly less expressive than Turing Machines. It is worth noting that the language (without function symbols) without these restrictions is as expressive as Turing Machines.

💡 Research Summary

The paper investigates decidability properties of two restricted dialects of Constraint Handling Rules (CHR) that, like Datalog, are defined over signatures without function symbols of arity greater than zero. Both dialects inherit the built‑in equality (=) predicate, which enables unification in rule bodies, but each imposes an additional syntactic restriction that dramatically limits expressive power. The first dialect, called the range‑restricted fragment, permits only rules in which every variable appearing in the guard or body also occurs in the head. This eliminates the creation of fresh variables during rule application and guarantees that any derivation can be represented as a finite tree of constraint stores. The authors construct a cut‑off technique combined with a loop‑detection algorithm: by monitoring the size and shape of the constraint store at each step, they can detect when a previously seen store recurs, which signals an infinite computation. They prove that the existence of an infinite derivation is decidable and can be decided in polynomial time with respect to the size of the program and the initial goal. The second dialect, termed the single‑head fragment, restricts each rule to have exactly one atom in its head. This restriction collapses the branching factor of the transition system, allowing a backward‑search algorithm that explores all possible derivation paths from a potential terminating state toward the initial goal. Because each step involves at most one applicable rule, the search space remains finite and effectively enumerable. Consequently, the existence of a terminating computation is also decidable for this fragment. The paper further demonstrates that both fragments are strictly less expressive than Turing machines: the unrestricted CHR without function symbols can simulate a Turing machine, but the added syntactic constraints prevent such simulation. This establishes that the two fragments lie below the Turing‑complete boundary, making them amenable to static analysis. The authors discuss implications for program verification, optimization, and safety analysis in CHR‑based systems, and outline future work aimed at extending decidability results to broader classes of CHR programs and integrating the techniques into practical tooling.