Programming in SPARK - TU Dresden · The SPARK System SPARK – Stanford Research Institute...

VIb. Reactive Action Programs 1

Programming in SPARK


The SPARK System

SPARK – Stanford Research Institute Procedural Agent Realization Kit

Largescale, practical applications of reactive agent programs

BDImodel, PRSarchitecture (like AgentSpeak)

More expressive means to control agents in rich and dynamic domains


SPARK Syntax

Belief literals :<=> belief atoms or their negation

Actions :<=> primitive actions or names for complex behaviors

Predefined belief atoms are:

Desire(a) where a action

Success(a) where a action

Fail(a) where a action

Desire() where belief literal

Success() where belief literal

Fail() where belief literal


Triggers and Procedures

Triggers are of the form

Do(a) where a action

Achieve() where belief literal

+ where belief literal

Procedures are of the form

e : ←

where e trigger, formula using belief atoms, task description


Programming Language for Task Descriptions

Task Meaning

noop do nothing

fail fail

add the fact to the beliefs

delete the fact from the beliefs

perform the action

conclude retract

do a

achieve attempt to achieve seq(1, 2) execute 1 then 2

if(, 1, 2) if is true, execute 1, else 2

try( , 1, 2) if succeeds, execute 1, else 2

wait(, ) wait until is true, then execute while(, 1, 2) repeat 1 until has no solution, then execute 2


Example Procedures

Do(ForwardMessage(x)) : ¬IsSpam(x) ← try ( achieve ClassifyMessage(x,y),

do AddToFolder(x,y),

do Forward(x)

)

Do(ForwardMessage(x)) : IsSpam(x) ← do Delete(x)


SPARK Interpreter Loop


Operational Semantics: State Transitions

Semantics of a task description given by a finite automaton

Distinguished states in this automaton:

s0 initial state

s+ success state

s failure state

Labeled state transitions

s →s'c∣e


Conditions and Effects

In a labeled state transition s →s', the

conditions are

presence of belief literal

absence of belief literal

effects are

addition of belief atom

removal of belief atom

Empty conditions and/or effects are simply omitted

c∣e

c=c1 , ... ,cn

e=e1 , ... ,em

c i=

c i=

ei=

ei=


Example (1)

Do(ForwardMessage(x)) : IsSpam(x) ← do Delete(x)

| Desire(Delete(x)) Success(Delete(x)) |

Fail(Delete(x)) |

so

s

s+


Recursive Construction of State Machine

M(noop) :<=> {s0 → s+}

M(fail) :<=> {s0 → s}

M(conclude ) :<=> {s0 → s+}

M(retract ) :<=> {s0 → s+}

M(do a) :<=> {s0 → s, s → s+, s → s}

M(achieve ) :<=> { s0 → s+, s0 → s, s → s+, s → s}

∣

∣

∣Desire a Success a ∣ Fail a∣

∣ ∣Desire Success ∣ Fail ∣


Construction of State Machine (cont'd)

M(seq(1, 2)) :<=> M(1){s+/s} M(2){s0/s}

M(if (, 1, 2)) :<=> M(1) M(2)

M(try ( , 1, 2)) :<=> M(){s+/s1, s/s2} M(1){s0/s1} M(2){s0/s2}

M(wait (, )) :<=> {s0 → s} M( ){ s0/s}

M(while (, 1, 2)) :<=> {s0 → s} M(1){s0/s, s+/s} M(2){s0/s}


Derivations

⟨B, D, I, ⟩ state

B set of belief literals

D set of Desire(a), Desire(), or +

I set of triples ⟨d, S, s⟩ d desire S state machine instance s current state in S

{Sense, Select, Act}

⟨B, {}, {}, Sense⟩ initial state


Selection Functions

SD selects an element from the current desires

SP selects an applicable procedure for a desire

SI selects an element ⟨d, S, s1⟩ I with an allowed state transition s1 → s2

c∣e


Derivation Rules (1/5)

B ' :<=> B updated according to sensing result

D ' :<=> D plus all sensed desires

⟨B ,D , I ,Sense ⟩

⟨B ' ,D ' , I ,Select⟩



If SD (D) = Desire(x) and there is applicable procedure for Do(a) (if x = a) or Achieve() (if x = )

where S state machine from SP(Desire(x))

If SD (D) = Desire(x) and no procedure applicable:

where S = {s0 → s+}

⟨B ,{}, I ,Select⟩

⟨B , {}, I ,Act⟩

⟨B ,D , I ,Select⟩

⟨B ,D \ {Desire x } , I∪{⟨Desire x ,S ,s0 ⟩ } ,Act⟩


⟨B ,D \ {Desire x } , I∪{⟨Desire x ,S ,s0 ⟩ } ,Act⟩∣Fail x



If SD (D) = + and there is applicable procedure:

where I' :<=> all ⟨+, S, s0⟩ for applicable procedures

If SD (D) = + and no applicable procedure:


⟨B ,D \ { } , I ∪ I ' ,Act⟩


⟨B ,D \ { } , I ,Select⟩



If SI (I) is ⟨d, S, s1⟩ along with s1 → s2:

a) If s2 {∉s+,s}

b) If d = + and s2 { s+,s}:

⟨B ,D ,{},Act⟩

⟨B ,D ,{},Sense ⟩

c∣e

⟨B ,D , I ,Act⟩

⟨B ' ,D ' , I \ {⟨d ,S ,s1 ⟩ }∪{ ⟨d ,S , s2 ⟩ } ,Sense ⟩

⟨B ,D , I ,Act⟩

⟨B ' ,D ' , I \ { ⟨d ,S ,s1 ⟩ } ,Sense ⟩



c) If d = Desire(x) and s2 = s+

d) If d = Desire(x) and s2 = s

⟨B ,D , I ,Act ⟩

⟨B ' ∪{Success x } ,D ' , I \ {⟨d ,S ,s1 ⟩ },Sense⟩

⟨B ,D , I,Act ⟩

⟨B ' ∪{Fail x },D ' , I \ {⟨d ,S ,s1 ⟩ },Sense⟩


Programming in SPARK: Packages

Package statement package: sri.foo

Declarations

Definitions

Additional facts/beliefs for the knowledge base

Import statements importfrom: spark.lang.list Member importall: spark.lang.list

Export statements export: my_sym

File requirements requires: foo.bar

Comments # comment


Programming in SPARK: Declarations

Variables $foo

Strings “this is a string“

Lists [item1 item2 item3]

Actions {defaction (_myPrivateAction +$var1 $var2) doc: “_myPrivateAction is local to this file“}

Predicates {defpredicate (MyPred $var1 $var2) doc: “tests whether $var1 and $var2 are related“}

Functions {deffunction (myFun $var1 $var2) doc: “applies myFun to $var1 and $var2“}

Constants {defconstant person23}


Procedures (Example)

{defprocedure paintHouse_havePaint cue: [do: (paintHouse $color)] precondition: (HavePaint $color) body: [seq: [do: (placeDropCloths)] [do: (applyPaintCoat $color)] [do: (cleanUp)] ]

}


Procedures: Cue

Direct action request [do: (action_identifier variable*)]

New fact [newfact: (Happy $person)]

Achievement [achieve: (Happy $person)]

Indicating argument mode for calling a procedure: [do: (paintHouse +$color)] [do: (paintHouse +“blue“)] [do: (paintHouse “blue“)]

A procedure is relevant when its cue event occurs. There are 3 types of cues:


Procedures: Precondition

any declared predicate

(True) or (False)

Logically connected expressions (and (> 4 $x) (!= $x 2) $person)) (or (AtHome $person) (AtWork $person) (AtSchool $person))

Existential quantifier (exists [$person] (AtHome $person))

A procedure is applicable when its precondition logical expression is true. Logical expressions are


Procedures: Body (1)

Actions [do: (applyPaint wall red)]

Achievements [achieve: (ColorOf wall red)]

Noop [succeed:] or []

Failure [fail: outOfPaintError]

Variable binding [context: (HasParent $x $y)] [set: $x (+ 3 4)]

Sequence [seq: [context: (and (MyFavoriteColor $col1) (YourFavoriteColor $col2))] [do: (applyPaint wall $col1)] [do: (applyPaint door $col2)]

Parallel [parallel: [do: (rubStomach Bob)] [do: (patHead Bob)]]


Procedures: Body (2)

Select [select: (InCar Bob) [do: (drive Bob home)] (True) [do: (talkOnCellPhone Bob)]]

Wait [wait: (AtHome Bob) [do: (talkOnCellPhone Bob)]]

Loop [while: [$x] (and (MyPet $x) (Hungry $x)) [do: (feed $x)]]

Find all solutions [forall: [$p] (InCar $p) [do: (drive $p home)]]


Procedures: Body (3) – Special Effects

Add to knowledge base [conclude: (Happy Bill)]

Remove from knowledge base [retract: (Scared Bill)] [retractall: [$p] (Scared $p)]

Remove [while: [$x] (and (MyPet $x) (Hungry $x)) [do: (feed $x)]]

Programming in SPARK - TU Dresden · The SPARK System SPARK – Stanford Research Institute...

Documents

Transcript of Programming in SPARK - TU Dresden · The SPARK System SPARK – Stanford Research Institute...