Your SlideShare is downloading. ×
0
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Zhou ciclops floc06
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Zhou ciclops floc06

202

Published on

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
202
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
0
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. AR (Action Rules) The Language, Implementation, and Applications A tutorial given at CICLOPS’06 Neng-Fa Zhou CUNY Brooklyn College and Graduate Center
  • 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))
  • 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
  • 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.
  • 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
  • 6. The AR language Syntax
    • Action rules
      • Agent p(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
    Agent, Condition, {EventSet} => Action
  • 7. The AR language Syntax (Cont.)
    • Commitment rules
      • An action rule degenerates into a commitment rule if no event is specified
    • Example
    append([],Ys,Zs) => Ys=Zs. append([X|Xs],Ys,Zs) => Zs=[X|Zs1], append(Xs,Ys,Zs1).
  • 8. The AR language Operational semantics
    • 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} => Action
  • 9. Events
    • General form events
      • event(X,O)
        • X – channel variable
        • O – event object
      • Example
      • echo(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).
  • 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
  • 11. Example An echoing agent echo(X),{event(X,O)} => writeln(O). ?-echo(X),post_event(X,hello). hello ?-echo(X),repeat,post_event(X,hello),fail. hello hello hello …
  • 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
  • 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
  • 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)
  • 15. Co-routining and concurrency Delay clauses
    • Delay clause delay and(X,Y,Z) if var(X),var(Y),X==Y,Z==1
    • AR and(X,Y,Z), var(X),var(Y),X==Y,Z==1, {ins(X),ins(Y),ins(Z)} => true.
  • 16. Co-routining and concurrency Compiling 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).
  • 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
  • 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
  • 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.
  • 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.
  • 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.
  • 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.
  • 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 binary archive arc consistency.
  • 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
  • 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.
  • 26. Channeling constraints in dual CSPs
    • Dual CSPs
        • all_distinct([X 1 ,…,X N ]),X i in 1..N
        • all_distinct([Y 1 ,…,Y N ]) X i #= j #<=> Y j #= i X i #= j #<=> Y j #= I
    • Relating primal and dual variables
    primal_dual(Xi,I,DualVarVector),var(Xi), {dom_any(Xi,J)} => arg(J,DualVarVector,Yj), Yj #= I. primal_dual(Xi,I,DualVarVector) => true.
  • 27. Set constraints
    • Representing finite-set domain variables using FD variables
      • V l – The lower bound, complement of definite elements
      • V u – The upper bound, possible elements
      • V c – The cardinality
    • Example
      • V :: {1}..{1,2,3}
        • V l :: [0,2..4] the complement of {1} including dummies
        • V u :: [0..4] {1,2,3} including dummies
        • V c :: [1..3]
  • 28. Propagation for set constraints
    • Propagators for R  S
    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).
  • 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
  • 30. Benchmarking CLP(FD) systems (Cont.)
    • Benchmarks: www.di.univaq.it/~formisano/CLPASP/ www.probp.com/bench.tar.gz
    CPU time, Windows XP
  • 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
  • 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
  • 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
  • 34. Translating CHR into AR General 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)
  • 35. Translating CHR into AR Example 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).
  • 36. CHR to AR Example (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).
  • 37. Benchmarking CHR compilers CPU time: milliseconds, Windows XP 453 1,765 6,843 zebra 640 1,125 6,532 primes 360 2,313 6,406 leq 3,250 Leuven (SWI) 109 938 fib AR (by hand) Leuven (B-Prolog) Program
  • 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
  • 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.
  • 40. An example go:- cgButton(B,“Hello World!”), handleButtonClick(B), cgShow(B).   handleButtonClick(B), {actionPerformed(B)} => halt.
  • 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)
  • 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).  
  • 43. Demo of CGLIB
    • Graphical user interfaces
    • Animation
    • Information visualization
    • Constraint satisfaction problems
    • Games
  • 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
  • 45. The implementation of AR (The ATOAM architecture) P code area X1 X2 ... Xn registers s AR stack heap trail H T TOP
  • 46. The frame structure for deterministic predicates Arguments AR CPS BTM TOP Local vars
    • Frame slots
      • AR: Parent’s frame
      • CPS: Continuation PC
      • BTM: Bottom of the stack frame
      • TOP: Top of the stack
  • 47. The frame structure for agents (Suspension frames) Arguments AR CPS BTM TOP PREV STATE REEP EVENT Local vars
    • Frame slots
      • PREV: Previous suspension frame
      • STATE: State of the frame (start, sleep, woken, end)
      • REEP: Reentrance program pointer
      • EVENT: Activating event
  • 48. The frame structure for non-deterministic predicates Arguments AR CPS BTM TOP B CPF H T SF Local 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
  • 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
  • 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

×