ar (action rules) the language, implementation, and applications a tutorial given at ciclops’06
DESCRIPTION
AR (Action Rules) The Language, Implementation, and Applications A tutorial given at CICLOPS’06. Neng-Fa Zhou CUNY Brooklyn College and Graduate Center. Evolution from freeze to AR. Early delay constructs freeze in Prolog-II freeze(X,p(X,Y)) When declarations in NU-Prolog :-p(X,Y) when X . - PowerPoint PPT PresentationTRANSCRIPT
CICLOPS'06 1
AR (Action Rules)The Language, Implementation, and Applications
A tutorial given at CICLOPS’06
Neng-Fa ZhouCUNY Brooklyn College and Graduate Center
CICLOPS'06 2
Evolution from freeze to AR
Early delay constructs – freeze in Prolog-II
freeze(X,p(X,Y))
– When declarations in NU-Prolog:-p(X,Y) when X.
– Block and when in Sicstus Prolog:-block p(-,?).when(nonvar(X),p(X,Y))
CICLOPS'06 3
Evolution from freeze to AR(Cont.) Delay clauses in Sepia (Eclipse)
delay and(X,Y,Z) if var(X),var(Y),X\==Y,Z\==1
Action rules (B-Prolog)
p(X,Y),var(X),{ins(X)} => q(X,Y).
Allows for the description of not only delay conditions but also activating events and actions
CICLOPS'06 4
Sources of this tutorial N.-F. Zhou: Programming Finite-Domain Constraint
Propagators in Action Rules, Theory and Practice of Logic Programming, accepted 2005.
N.-F. Zhou, M.Wallace, and P.J. Stuckey: The dom Event and its Use in Implementing Constraint Propagators, Technical Report, CUNY Computer Science, 2006.
T. Schrijvers, N.-F. Zhou, and B. Demoen: Translating Constraint Handling Rules into Action Rules, CHR'06.
N.-F. Zhou: A Constraint-based Graphics Library for B-Prolog, Software - Practice and Experience, 2003.
CICLOPS'06 5
Outline The AR language
– Syntax and semantics of action rules– Events
Applications– Co-routining and concurrency– Constraint propagation– Compiling CHR– Interactive graphical user interfaces
The implementation Conclusion
CICLOPS'06 6
Agent, Condition, {EventSet} => ActionAgent, Condition, {EventSet} => Action
The AR language Syntax Action rules
– Agentp(X1,…,Xn)
– Condition• Inline tests (e.g., var(X),nonvar(X),X==Y,X>Y)
– EventSet• event(X,O) -- a general form event• ins(X) -- X is instantiated
– Action• Same as a clause body
A predicate can contain multiple action rules
CICLOPS'06 7
The AR language Syntax (Cont.) Commitment rules
– An action rule degenerates into a commitment rule if no event is specified
Exampleappend([],Ys,Zs) => Ys=Zs.append([X|Xs],Ys,Zs) =>
Zs=[X|Zs1],append(Xs,Ys,Zs1).
CICLOPS'06 8
An agent (subgoal) A is suspended if:– A matches Agent, and– Condition is true
A is activated when an event in EventSet is posted Action is executed when A is activated and Condition is true A is suspended again after Action is executed The next rule is tried if Condition fails A fails if Action fails
Agent, Condition, {EventSet} => ActionAgent, Condition, {EventSet} => Action
The AR languageOperational semantics
CICLOPS'06 9
Events General form events
– event(X,O)• X – channel variable• O – event object
– Exampleecho(X),{event(X,O)}=>writeln(O).
ins(X)– X is instantiated– Example (freeze(X,q(X,Y)) )
p(X,Y),var(X),{ins(X)}=>true.P(X,Y)=>q(X,Y).
CICLOPS'06 10
Posting events
A channel expression is– A channel variable X– A conjunction of variables: X1 /\ X2 … /\ Xn– A disjunction of variables: X1 \/ X2 … \/ Xn
Posting events– post_event(C,O)
• C is a channel expression– post_ins(X)
• Post an ins(X) event
CICLOPS'06 11
Example An echoing agentecho(X),{event(X,O)} => writeln(O).
?-echo(X),post_event(X,hello).hello
?-echo(X),repeat,post_event(X,hello),fail.hellohellohello…
CICLOPS'06 12
Killing agents
An agent vanishes after a commitment rule is applied to it
echo(Flag,X),var(Flag),{event(X,O),ins(Flag)}=> writeln(O).
echo(Flag,X) => true.
?-echo(Flag,X),post_event(X,hello),Flag=1.hello
CICLOPS'06 13
Outline The AR language
– Syntax and semantics of action rules– Events
Applications– Co-routining and concurrency– Constraint propagation– Compiling CHR– Interactive graphical user interfaces
The implementation Conclusion
CICLOPS'06 14
Co-routining and concurrency freeze(X,G)freeze(X,G), var(X), {ins(X)} => true.freeze(X,G) => call(G).
?-freeze(X,writeln(X)),X=f(a).f(a)
CICLOPS'06 15
Co-routining and concurrency Delay clauses Delay clause
delay and(X,Y,Z) if var(X),var(Y),X\==Y,Z\==1
ARand(X,Y,Z),
var(X),var(Y),X\==Y,Z\==1,{ins(X),ins(Y),ins(Z)}
=>true.
CICLOPS'06 16
Co-routining and concurrencyCompiling flat GHC Flat GHC
AR
append([],Ys,Zs):-true | Ys=Zs.append([X|Xs],Ys,Zs):-true |
Zs=[X|Zs1],append(Xs,Ys,Zs1).
append(Xs,Ys,Zs),var(Xs),{ins(Xs)} => true.append([],Ys,Zs) => Ys=Zs.append([X|Xs],Ys,Zs) =>
Zs=[X|Zs1],append(Xs,Ys,Zs1).
CICLOPS'06 17
Outline The AR language
– Syntax and semantics of action rules– Events
Applications– Co-routining and concurrency– Constraint propagation– Compiling CHR– Interactive graphical user interfaces
The implementation Conclusion
CICLOPS'06 18
Events for programming constraint propagation
– generated: When suspended for the first time– ins(X): X is instantiated– bound(X)
• A bound of X’s domain is updated– dom(X,E)
• An inner value E is excluded from X’s domain– dom(X)
• Some inner value is excluded from X’s domain– dom_any(X,E)
• An arbitrary value E is excluded from X’s domain– dom_any(X)
• Some value is excluded from X’s domain
CICLOPS'06 19
Posting events on domain variables
X#\=2– Posts dom(X,2) and dom_any(X,2)
X#\=4– Posts bound(X) and dom_any(X,4)
X#\=1– Posts ins(X)
X :: 1..4, X#\=2, X#\=4, X#\=1.
CICLOPS'06 20
Propagators for aX=bY+c
Forward checking
'aX=bY+c_forward'(A,X,B,Y,C),var(X),var(Y),{ins(X),ins(Y)} => true.
'aX=bY+c_forward'(A,X,B,Y,C),var(X) => T is B*Y+C, X is T//A, A*X=:=T.'aX=bY+c_forward'(A,X,B,Y,C) => T is A*X-C, Y is T//B, B*Y=:=T.
When either X or Y is instantiated, instantiate the other variable.
CICLOPS'06 21
Propagators for aX=bY+c
Interval consistency 'aX in bY+c_interval'(A,X,B,Y,C),var(X),var(Y),
{generated,bound(Y)} => 'aX in bY+c_reduce_domain'(A,X,B,Y,C).
'aX in bY+c_interval'(A,X,B,Y,C) => true.
Whenever a bound of Y’s domain is updated,reduce X’s domain to achieve interval consistency.
CICLOPS'06 22
Propagators for aX=bY+c
Arc consistency 'aX in bY+c_arc'(A,X,B,Y,C),var(X),var(Y),
{dom(Y,Ey)} => T is B*Ey+C, Ex is T//A, (A*Ex=:=T -> X #\=Ex;true).
'aX in bY+c_arc'(A,X,B,Y,C) => true.
Whenever an element Ey is excluded from Y’s domain,exclude Ey’s counterpart Ex from X’s domain.
CICLOPS'06 23
Propagator for A1*X1+...+An*Xn+C = 0
'A1*X1+...+An*Xn+C=0'(C,A1,A2,...,An,X1,X2,..,Xn),n_vars_gt(n,2),{generated,ins(X1),bound(X1),...,ins(Xn),bound(Xn)}
=> reduce domains of X1,..,Xn to achieve ic. 'A1*X1+...+An*Xn+C=0'(C,A1,A2,...,An,X1,X2,..,Xn)
=> nary_to_binary(NewC,B1,B2,Y1,Y2), call_binary_propagator(NewC,B1,Y1,B2,Y2).
When the constraint contains more than 2 variables,achieve interval consistency.
When the constraint becomes binaryarchive arc consistency.
CICLOPS'06 24
The use of the dom and dom_any events The AC-4 algorithm for general support
constraints Channeling constraints in dual CSPs Set constraints
CICLOPS'06 25
The AC-4 algorithm for general support constraints
ac4(BinaryRelation,X,Y), var(X),var(Y), {dom_any(X,Ex)} => decrement_counters(BinaryRelation,Ex,Y).ac4(BinaryRelation,X,Y) => true.
Whenever a value Ex is excluded from the domain of X,the counters of those values in the domain of Y supported by Ex are decremented.
CICLOPS'06 26
Channeling constraints in dual CSPs Dual CSPs
• all_distinct([X1,…,XN]),Xi in 1..N• all_distinct([Y1,…,YN])
Xi #= j #<=> Yj #= i Xi #\= j #<=> Yj #\= I
Relating primal and dual variablesprimal_dual(Xi,I,DualVarVector),var(Xi), {dom_any(Xi,J)} => arg(J,DualVarVector,Yj), Yj #\= I. primal_dual(Xi,I,DualVarVector) => true.
CICLOPS'06 27
Set constraints Representing finite-set domain variables using FD
variables– Vl – The lower bound, complement of definite elements– Vu – The upper bound, possible elements– Vc – The cardinality
Example– V :: {1}..{1,2,3}
• Vl :: [0,2..4] the complement of {1} including dummies• Vu :: [0..4] {1,2,3} including dummies• Vc :: [1..3]
CICLOPS'06 28
Propagation for set constraints
Propagators for RS
subset_from_R_to_S(set(Rl,_Ru,_Rc),S), {dom(Rl,E)} => clpset_add(S,E).
subset_from_S_to_R(R,set(_Sl,Su,_Sc)), {dom(Su,E)} =>
clpset_exclude(R,E).
CICLOPS'06 29
Benchmarking CLP(FD) systems(As of Aug. 14, 2006)
BP: B-Prolog 6.9
EP: Eclipse 5.8 #107
GP: Gnu-Prolog 1.2.16
SP: Sicstus-Prolog 3.12.5
CPU time, Windows XP
Benchmarks:www.probp.com/bench.tar.gz
CICLOPS'06 30
Benchmarking CLP(FD) systems(Cont.)
Benchmarks:
www.di.univaq.it/~formisano/CLPASP/
www.probp.com/bench.tar.gz
CPU time, Windows XP
CICLOPS'06 31
Outline The AR language
– Syntax and semantics of action rules– Events
Applications– Co-routining and concurrency– Constraint propagation– Compiling CHR– Interactive graphical user interfaces
The implementation Conclusion
CICLOPS'06 32
Compiling CHR
A comparison of CHR and AR– Common features
• Rule-based• Matching
– Differences• Multi-headed rules are allowed in CHR• Implicit delay in CHR vs. explicit delay in AR
CICLOPS'06 33
An example CHR program
reflexivity @ leq(X,X) <=> true.
antisymmetry @ leq(X,Y), leq(Y,X) <=> X = Y.
idempotence @ leq(X,Y) \ leq(X,Y) <=> true.
transitivity @ leq(X,Y), leq(Y,Z) ==> leq(X,Z).
simplification
propagation
simpagation
CICLOPS'06 34
Translating CHR into ARGeneral ideas All rules are single or double-headed
When a constraint p(X) is added into the store, an event of the the following form is posted
For each occurrence of a constraint symbol and each matching constraint in the store, there is an agent watching the arrival of its partner constraint
P <=> Body. P, Q <=> Body.P ==> Body. P \ Q <=> Body.
P, Q ==> Body.
constr(Cno,Alive,History,X)
CICLOPS'06 35
Translating CHR into ARExample
p(X):-gen_constr_num(Cno),Constr=constr(Cno,AliveP,HistoryP,X),get_channel(p_1_1,ChP),get_channel(q_1_1,ChQ),agent_p_1_1(ChP,AliveP,X),post_p_1(ChQ,Constr,AliveP,X).
agent_p_1_1(ChP,AliveP,X),var(AliveP),{event(ChP,Q),ins(AliveP)}
=> Q=constr(_,AliveQ,HistoryQ,Y),
(var(AliveQ)->AliveP=0,AliveQ=0,r(X,Y);true).agent_p_1_1(ChP,AliveP,X) => true.
p(X),q(Y) <=> r(X,Y).
CICLOPS'06 36
CHR to ARExample (Cont.)
post_p_1(ChQ,Constr,AliveP,X),var(AliveP),{generated,ins(X),ins(AliveP)}
=>post_event(ChQ,Constr).
post_p_1(ChQ,Constr,AliveP,X) => true.
p(X),q(Y) <=> r(X,Y).
CICLOPS'06 37
Benchmarking CHR compilers
Program Leuven (SWI)
Leuven(B-Prolog)
AR(by hand)
fib 3,250 938 109leq 6,406 2,313 360
primes 6,532 1,125 640zebra 6,843 1,765 453
CPU time: milliseconds, Windows XP
CICLOPS'06 38
Outline The AR language
– Syntax and semantics of action rules– Events
Applications– Co-routining and concurrency– Constraint propagation– Compiling CHR– Interactive graphical user interfaces
The implementation Conclusion
CICLOPS'06 39
CGLIB Motivation
– Implement an application with a GUI in one language Features
– Use constraints to specify the layouts of objects– Use action rules to specify interactions
Implementation– Implemented in B-Prolog, Java, JIPL, and C
Applications– Interactive user interfaces, animation, information
visualization, intelligent agents, and games.
CICLOPS'06 40
An examplego:-
cgButton(B,“Hello World!”),
handleButtonClick(B),
cgShow(B).
handleButtonClick(B),
{actionPerformed(B)}
=>
halt.
CICLOPS'06 41
Events for programming GUI actionPerformed(O) focusGained(O) focusLost(O) keyPressed(O,E) keyReleased(O,E) keyTyped(O,E ) mousePressed(O,E) mouseReleased(O,E) mouseEntered(O,E) mouseExited(O,E) mouseClicked(O,E) mouseDragged(O,E) mouseMoved(O,E)
windowClosing(O) windowOpened(O) windowIconified(O) windowDeiconified(O) windowClosed(O) windowActivated(O) windowDeactivated(O) componentResized(O,E) componentMoved(O,E) textValueChanged(O) itemStateChanged(O,E) adjustmentValueChanged(O,E) time(T)
CICLOPS'06 42
Timers and time events
go:- timer(T1,100), timer(T2,1000), ping(T1), pong(T2), repeat,fail.
ping(T),{time(T)} => writeln(ping).
pong(T),{time(T)} => writeln(pong).
CICLOPS'06 43
Demo of CGLIB
Graphical user interfaces Animation Information visualization Constraint satisfaction problems Games
CICLOPS'06 44
Outline The AR language
– Syntax and semantics of action rules– Events
Applications– Co-routining and concurrency– Constraint propagation– Compiling CHR– Interactive graphical user interfaces
The implementation Conclusion
CICLOPS'06 45
The implementation of AR(The ATOAM architecture)
P
code areaX1X2...Xn
registerss
AR stack heap trailH T
TOP
CICLOPS'06 46
The frame structure for deterministic predicates
ArgumentsARCPSBTMTOP
Local vars
Frame slots– AR: Parent’s frame– CPS: Continuation PC– BTM: Bottom of the stack
frame– TOP: Top of the stack
CICLOPS'06 47
The frame structure for agents(Suspension frames)
ArgumentsARCPSBTMTOP
PREVSTATEREEP
EVENTLocal vars
Frame slots– PREV: Previous suspension frame – STATE: State of the frame (start,
sleep, woken, end)– REEP: Reentrance program pointer– EVENT: Activating event
CICLOPS'06 48
The frame structure for non-deterministic predicates
ArgumentsARCPSBTMTOP
BCPF
HT
SFLocal vars
Frame slots– B: Parent choice point frame– CPF: Continuation PC on failure– H: Top of the heap – T: Top of the trail stack– SF: Suspension frame
CICLOPS'06 49
Spaghetti stack
Context switching is light Activation frames are not
in chronological order Run-time testing is needed
to de-allocate a frame The BTM slot is needed
for de-allocation of frames Stack needs be garbage
collected
CICLOPS'06 50
Conclusion Conclusion
– AR is a simple but powerful language which has a variety of applications
Further work– Multi-threaded AR– Even faster implementation– Debugging – Fast implementation of AR on WAM [B. Demoen]– New applications (Multi-agents)
More information– www.probp.com– www.bprolog.com