CICLOPS'061 AR (Action Rules) The Language, Implementation, and Applications A tutorial given at CICLOPS06 Neng-Fa Zhou CUNY Brooklyn College and Graduate.

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




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 |


append(Xs,Ys,Zs),var(Xs),{ins(Xs)} => true.append([],Ys,Zs) => Ys=Zs.append([X|Xs],Ys,Zs) =>


CICLOPS'06 17

Outline




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


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


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




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 109

leq 6,406 2,313 360

primes 6,532 1,125 640

zebra 6,843 1,765 453

CPU time: milliseconds, Windows XP

CICLOPS'06 38

Outline




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 example

go:-

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




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)


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


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

CICLOPS'061 AR (Action Rules) The Language, Implementation, and Applications A tutorial given at CICLOPS06 Neng-Fa Zhou CUNY Brooklyn College and Graduate.

Documents

y slide

x s domain slide

posts insx x

channel variable x

insx event slide

conclusion slide

fa slide

x s domain domx