The links to "further information" should probably not be as in an academic paper and dump you onto the bibliography page, where they are not active links.

Let's just go directly to:

• Thom Frühwirth's page on CHR: http://www.constraint-handling-rules.org
• K.U. Leuven: https://dtai.cs.kuleuven.be/CHR/
• Wikipedia: https://en.wikipedia.org/wiki/Constraint_Handling_Rules
• The bibliography page: https://dtai.cs.kuleuven.be/CHR/biblio.shtml

Note the following outcomes of calling a CHR constraint from Prolog:

• The call results in an empty CHR constraint store: success at the Prolog level.
• The call results in an nonempty CHR constraint store (or an impasse??): failure at the Prolog level.
• There is not enough information to proceed with constraint solving (i,e variables are not sufficiently instantiated): The constraint is suspended and the Prolog program "continues optimistically", same as for dif/2. If the variables involved are made more precise (possibly even ground) a bit later in the Prolog proof tree via unification, CHR processing is restarted. This may fail or succeed, leading to success or failure of the unification that re-awakened the CHR processor. If there are suspended constraints on return to the Prolog toplevel, they are printed out, same as for dif/2. See also: chr_show_store/1

Example:

:- module(my_test,[a/2]).
:- use_module(library(chr)).

:- chr_constraint a/2, b/1, c/1.

% ------------
% CHR
% ------------

rule_1 @ a(X,1) <=> in1(X) | b(X) , out1(X).
rule_2 @ a(X,2) <=> in2(X) | c(X) , out2(X).
rule_3 @ b(X) <=> in3(X) | memberchk(X,[1,2]), out3(X).
rule_4 @ c(X) <=> in4(X) | memberchk(X,[u,v]), out4(X).

% ------------
% Prolog called by CHR
% ------------

in1(X) :- format("rule_1 called : a(~q,1) <=> b(~q)\n",[X,X]).
in2(X) :- format("rule_2 called : a(~q,2) <=> c(~q)\n",[X,X]).
in3(X) :- format("rule_3 called : b(~q) <=> ~q=1\n",[X,X]).
in4(X) :- format("rule_4 called : c(~q) <=> ~q=2\n",[X,X]).

out1(X) :- format("rule_1 success with X=~q\n",[X]).
out2(X) :- format("rule_2 success with X=~q\n",[X]).
out3(X) :- format("rule_3 success with X=~q\n",[X]).
out4(X) :- format("rule_4 success with X=~q\n",[X]).

Then:

?- a(u,2),writeln("I succeed!"),chr_runtime:chr_show_store(my_test).
rule_2 called : a(u,2) <=> c(u)
rule_4 called : c(u) <=> u=2
rule_4 success with X=u
rule_2 success with X=u
I succeed!
true.

?- a(1,2),writeln("I fail!"),chr_runtime:chr_show_store(my_test).
rule_2 called : a(1,2) <=> c(1)
rule_4 called : c(1) <=> 1=2
false.

?- a(1,X),writeln("I suspend!"),chr_runtime:chr_show_store(my_test).
I suspend!
a(1,_124472)  % What we print
a(1, X).      % What Prolog prints

?- a(1,X),writeln("I suspend but then succeed!"),X=1,chr_runtime:chr_show_store(my_test).
I suspend but then succeed!
rule_1 called : a(1,1) <=> b(1)
rule_3 called : b(1) <=> 1=1
rule_3 success with X=1
rule_1 success with X=1
X = 1.

?- a(1,X),writeln("I suspend but then fail!"),X=2,chr_runtime:chr_show_store(my_test).
I suspend but then fail!
rule_2 called : a(1,2) <=> c(1)
rule_4 called : c(1) <=> 1=2
false.

"Committed Choice" very concretely means there is no backtracking over the CHR rules. The first "matching rule" is selected, and if the guard passes, the CHR processor will stick to it.

(However, there is backtracking over any Prolog predicates called by CHR rules.)

Consider the example below.

• Running a(1) results in success because the first matching rules goes down a path whereby the constraint store can be fully cleared
• Running a(u) results in failure even though a(u) is not qualitatively different from a(1) and would be handled if there were backtracking, but there isn't.

Run the test code with rt(_).

:- module(chr_is_pretty_cool,[a/1,rt/1]).
:- use_module(library(chr)).

:- chr_constraint a/1, b/1, c/1.

% ------------
% CHR
% ------------

rule_1 @ a(X) <=> in1(X) | b(X) , out1(X).
rule_2 @ a(X) <=> in2(X) | c(X) , out2(X).
rule_3 @ b(X) <=> in3(X) | memberchk(X,[1,2]), out3(X).
rule_4 @ c(X) <=> in4(X) | memberchk(X,[u,v]), out4(X).

% ------------
% Prolog called by CHR
% ------------

in1(X) :- format("rule_1 called : a(~q) <=> b(~q)\n",[X,X]).
in2(X) :- format("rule_2 called : a(~q) <=> c(~q)\n",[X,X]).
in3(X) :- format("rule_3 called : b(~q) <=> ~q=1\n",[X,X]).
in4(X) :- format("rule_4 called : c(~q) <=> ~q=2\n",[X,X]).

out1(X) :- format("rule_1 success with X=~q\n",[X]).
out2(X) :- format("rule_2 success with X=~q\n",[X]).
out3(X) :- format("rule_3 success with X=~q\n",[X]).
out4(X) :- format("rule_4 success with X=~q\n",[X]).

% ------------
% Plunit code
% ------------

:- begin_tests(my_chr_tests).

% Committed choice: a(1) succeeds because the first branch
% taken (rule_1) is the correct one.

test(one) :- a(1).

% Committed choice: a(u) fails because the first branch
% taken (rule_1) is the incorrect one. Should take the
% second one (rule_2), but there is no backtracking.

test(two,fail) :- a(u).

:- end_tests(my_chr_tests).

% ------------
% Calling Plunit code
% ------------

rt(my_chr_tests) :- run_tests(my_chr_tests).

If you replace memberchk/2 by member/2 in the code above, you get an open choicepoint.

With memberchk/2:

?- a(X).
rule_1 called : a(_127802) <=> b(_127802)
rule_3 called : b(_128024) <=> _128024=1
rule_3 success with X=1
rule_1 success with X=1
X = 1.

With member/2, rule 3 can succeed in two ways:

?- a(X).
rule_1 called : a(_176470) <=> b(_176470)
rule_3 called : b(_176692) <=> _176692=1
rule_3 success with X=1
rule_1 success with X=1
X = 1 ;
rule_3 success with X=2
rule_1 success with X=2
X = 2.