Gerald Steinbauer Institute for Software Technology

Size: px

Start display at page:

Download "Gerald Steinbauer Institute for Software Technology"

Francine Walton
5 years ago
Views:

1 Situation ti Calculus l and Golog Institute for Software Technology 1

2 Recap Situation Calculus Situation Calculus allows for reasoning about change and actions a dialect of the second-orderorder logic uses the concept of situations allows for proving properties solves the frame problem Basic Action Theory implements the situation calculus Foundation Axioms & Action Precondition & Successor Sate Ai Axioms &Ui Unique Name Assumption 2

3 Sates versus Situations situations are different to states they contain a history of what happened so far snapshots of properties of the world are retrieved by fluents, i.e. what predicates hold in a situation two situations are different if their sequence is different the state of fluents may be the same 3

4 Situation Tree do(a n,s 0 ) a n a 3 a 2 a n a 1 S 0 a 3 a 2 do(a n,do(a 1,S 0 )) a 1 do(a 1,S 0 ) a n a 3 a 2 a 1 4

5 Regression related to the projection problem does a sentence hold for some future situation used for automated reasoning and planning in the SC sketch: prove if sentence W is entailed by BAT W mention a relational fluent F(x1,,xn,do(a,σ)) xn successor state axiom F(x 1,,x n,do(a,s)) F (x 1,,x n,a,s) obtain W by substituting F by F eliminating complex situation do(a, σ) from W W is closer to S 0 as W repeat the substitution until W 0 uniform in S 0 now one can prove W in the initial database 5

6 Regressable Formulas a formula W in the situation calculus is regressable iff 1. situation terms mentioned in W are of the form do([α 1,,α n ],S 0 ) 2. for atoms of form Poss(α,s) mentioned in W α has the form A(t 1,,t n ) and is an action function 3. W does not quantify over situations 4. W does not mention the predicate symbol nor any equality atom σ=σ for situations 6

7 Examples for Regressable Formulas 1. Poss(walk(A,B)S 0 ) Poss(enter(office(Sue)),do(walk(A,B),S 0 )) Poss(giveCoffee(Sue),do([walk(A,B),enter(Office(Sue))],S enter(office(sue))] S 0 ) 2. ( a,a ).ontable(a,do(a,s 0 )) ( x).x A ontable(x,do([a,a ],S 0 )) Regressable? Poss(a,S 0 ) holding(x,do(pickup(a),s)) NO NO 7

8 Regression Operator 1. if W is situation-independent or a relational fluent F(τ,S 0 ) [W]=W 2. if W is a regressable Poss(A(t),α) atom and Poss(A(x),s) A (x,s) [W]= [ [ A (x,s)] 3. if W is a relational fluent F(t,do(α,σ)) and F(x,do(a,s)) (, F F( (x,a,s), [W]= [ F (x,a,s)] 4. [ W]= [W] [W 1 W 2 ]= [W 1 ] [W 2 ] [( v)w]=( v) [W] 8

9 Some Results from Regression if D is a basic action theory and W is a regressable sentence then, D W iff D D S 0 una [W] executable(s)= a,s s*.do(a,s s*) s Poss(a,s s*) D executable(do([a1,,an],s 0 )) iff D D S α ]S 0 una [Poss(αi,do([α 1,,α i-1 ],S 0 ))] [Poss(α 1,do([],S 0 ))] 9

10 Planning yet we cannot derive in which situation s a goal sentence G(s) holds s can be seen as a plan (a sequence of actions) started in situation S 0 iff D G(do([α 1,, α 1 ],S 0 ) we looking for an appropriate situation s a planning algorithm is needed 10

11 A very simple (naive) planner 1. test if goal G holds in initial situation S 0, if so return empty sequence of actions 2. if not set n=1 3. generate all sequences of actions of length n where the preconditions are satisfied 4. test if goal G holds in any of the situation generated by the sequences, if so return appropriate sequence of actions 5. if not increment n and continue with 3 11

12 coffee delivery robot go to a person serve a person S 0 : person(alice), person(bob) Lets Plan G(s)=served(Alice,s) 12

13 Golog 13

14 Golog Situation Calculus is yet only a theoretical construct Golog (algol for Logic) is based on the Situation Calculus it is a program language for dynamic systems it allows a balance between reasoning/planning i and imperative programming (i.e., planning is expensive) it allows complex actions there exist Prolog interpreters for Golog 14

15 Golog a Golog program is based SC it uses the macro Do(,s,s ) Do(,s,s ) will be macro-expand to a SC formula the formula Do states that s is reachable from s by executing the program the syntax supports primitive and complex actions 15

16 Primitive Action: a Golog Syntax (1) has a precondition Poss and the effects are modeled in the successor state axioms walk(r,l) Test action: φ?? tests if φ holds in a situation, does not change the situation ( ( x,y).nextto(x,y))? ( x,y).nextto(x,y))? Sequence: 1 ; 2 executes 1 and 2 one after each other walk(r,l);pickup(r,k) 16

17 Golog Syntax (2) Non-deterministic Choice of Actions: 1 2 (randomly) action 1 or 2 will be executed walk(r,a) walk(r,b) Non-deterministic Choice of Arguments: (π x) (x) (randomly) choose an argument x for the action (π x)pickup(r,x) Non-deterministic Iteration: * executes for a not defined number of times (n 0) (pickup(r,l);drop(r,l))* 17

18 Golog Syntax (3) Conditionals: if then 1 else 2 endif based on the truth value of either 1 or 2 is executed if low_battery(r) then recharge(r) else walk(r,party) endif Loops: while do endwhile as long as is true repeat action while low_battery(r) do pickup(r,l);drop(r,l) endwhile Procedures: proc P(x) endproc defines the procedure P with the parameters x proc d(n) (n=0)? d(n-1) endproc 18

19 On the Semantics of Golog Golog programs are macro-expanded to Situation Calculus formulas using the macro Do(,s,s ) what is the meaning of Golog and a program D (,s).do(,s S 0,s) Goals(s) the Basic Action Theory entails some program leads to the situation s from S 0 that satisfied the goals drawback: the macros are less expressive a program trace can be obtained by a constructive ti proof of the above sentence some properties are provable: e.g., termination 19

20 Semantics of Golog Parts (1) Primitive Action: a Do(a,s,s )=Poss(a[s],s) s =do(a[s],s) a[s] denotes restoring of all situation arguments in the functional fluents mentioned in a a=goto(location(sam)), a[s]=goto(location(sam,s)) Test action: φ? Do(?,s,s )= [s] s=s [s] denotes restoring of all situation arguments in the fluents mentioned in =( x).ontable(x), [s]=( x).ontable(x,s) Sequence: 1 ; 2 Do( 1 ; 2,s,s) ss )=( s ) ). Do( 1,s,s ss ) Do( 2,s s,s) s ) 20

21 Semantics of Golog Parts (2) Non-deterministic Choice of Actions: 1 2 Do(( 1 2 ),s,s )=Do( 1,s,s ) Do( 2,s,s ) Non-deterministic Choice of Arguments: (π x) (x) Do((π x) (x),s,s )=( x)do( (x),s,s )) Non-deterministic Iteration: * Do( *,s,s )=( P).{ s1.p(s 1,s 1 ) s 1,s 2,s 3.[P(s 1,s 2 ) Do(,s 2,s 3 ) P(s 1,s 3 )]} P(s,s ) 21

22 Semantics of Golog Parts (3) Conditionals: if then 1 else 2 endif expressed by the previous constructs Do(if then 1 else 2 endif)=do([?: 1?: 2 ],s,s) ss ) Loops: while do endwhile expressed by the previous constructs Do(while do endwhile,s,s )=Do(((?; )*;?),s,s ) 22

23 Semantics of Golog Parts (4) A Program: proc P 1 (x 1 ) 1 endproc; ;proc P n (x n ) n endproc; 0 a sequence of procedure declarations plus a main program a sequence of procedure declarations plus a main program 0 we define Do(P(t 1,,t n )ss )=P(t ),s,s)=p(t 1 [s],,t n [s],s,s) s s ) defines a procedure call t i [s] denotes the evaluation of t i in situation s before passing to P represents a call by value Do({ proc P1 ( v1) 1 endproc; ; proc Pn ( vn) n endproc; 0}, s, s ) n ( P1,, Pn ). ( s1, s2, vi ). Do( i, s1, s2) Pi ( vi, s1, s2 i 1 Do ( 0, s, s ) ) 23

24 =(π x)a(x);?;[b(x) C(x);?] Do(,S 0,s)? A Simple Example ( x).( s 1 ).Poss(A(x),S 0 ) s1=do(a(x),s 0 ) ( s 2 ). [s 1 ] s 1 =s 2 [Poss(B(x),s 2 ) s=do(b(x),s 2 ) ( s 3 ).Poss(C(x),s s 2 ) s 3 =do(c(x),s 2 ) [s 3 ] s 3 =s] ( x).poss(a(x),s 0 ) [do(a(x),s 0 )] [Poss(B(x), do(a(x),s 0 )) s=do(b(x),do(a(x),s 0 )) Poss(C(x), do(a(x),s 0 )) [do(c(x),do(a(x),s 0 ))] s=do(c(x) do(c(x),do(a(x),sdo(a(x) 0 ))] two possible traces: do(b(x),do(a(x),s 0 )), do(c(x),do(a(x),s 0 )) assuming and holds in the related situations 24

25 Situation Calculus vs. Golog Programs Situation Calculus and Golog Programs are related macro expansion uses the basic action theory (e.g., preconditions and successor state axioms) Golog is not a classical program language there are no side effects or states t program traces come from theorem proving Axioms ( s).do(,s S 0,s) allows for proving of properties of the program 25

26 Executing a Golog Program Golog Program Macro Expansion Logic Sentence in s and S 0 Theorem Prover Basic Action Theory Situation ti s Constructive Proof 26

27 proc toh() Planning versus Programming while solved do ( o) ( d) move(o,d) endwhile endproc do(toh(),s0) proc toh(n,o,d,h) toh(n-1,o,h,d) move(o,d) toh(n-1,h,d,o) endproc do(toh(3,a,b,c),s0) a b c

28 The famous Elevator Example Elevator several floors each floor has a door each floor has a call button Possible Actions up(n) down(n) trunoff(n) open close Task serve all requests 28

29 Fluents Elevator Part 1 currentfloor(s)=n, elevator is on floor n on(n,s), call button is on at floor n Primitive Action Preconditions Poss(up(n),s) currentfloor(s)<n Poss(down(n),s) currentfloor(s)>n Poss(open,s) s) true Poss(close,s) true Poss(turnoff(n),s) on(n,s) 29

30 Successor State Axioms Elevator Part 2 currentfloor(do(a,s))=m a=up(m) a=down(m) currentfloor(s)=m ( n).a=up(n) ( n).a=down(n) ( ) ) ( ) ( ) on(m,do(a,s)) on(m,s) a turnoff(m) Initial Situation currentfloor(s 0 )=4, on(3,s 0 ), on(5,s 0 ) A Litte Helper (a definition) nextfloor(n,s)=on(n,s) ( ) ( m).on(m,s) m-currentfloor(s) n-currentfloor(s) 30

31 Golog Procedures Elevator Part 3 proc serve(n) gofloor(n); turnoff(n);open;close ; endproc proc gofloor(n) (currentfloor=n)? up(n) down(n) endproc proc serveafloor (π n)[nextfloor(n)?;serve(n)] endproc proc control [while ( n)on(n) do serveafloor endwhile]; park endproc proc park if currentfloor=1 then open else down(0);open endproc 31

32 Running the Program Elevator Part 4 prove the following entailment : Axioms ( s).do(,s 0,s) s=do(open do(open,do(down(0),do(close,do(open,do(turnoff(5), do(down(0) do(close do(turnoff(5) do(up(5),do(close,do(open,do(turnoff(3),do(down(3,s 0 )))))))))) action sequence: down(3),turnoff(3),open,close,up(5), turnoff(5),open,close,down(0),openopen open there are multiple solutions 32

33 Golog - Summary Golog is logic program language Golog is based on Situation Calculus axioms its interpreter is a general purpose theorem prover Golog programs are executed for their side effects Golog programs are executed off-line 33

34 Implementation of Golog 34

35 Prolog as Implementation of Logic Prolog is a logic program language Prolog allows for declarative programming (i.e., concentrates on the problem formulation) Prolog can be used to implement a logical theory if some properties hold there is mapping between Prolog and the logical theory behind use a definitional theory use a proper Prolog interpreter Theorem of Clark 35

36 Definitional Theory definition axioms have the following form ( x 1,,x n ).P(x 1,,x n ), P is a predicate other the equality, is a FOL sentence can also be written as ( x 1,,x n ). P(x 1,,x n ) a set of definition axioms form a definitional theory an atom A is a formula of the form P(x 1,,x n ) a literal L is an atom or its negation a clause C has the form L 1 L m A, m 0 ( x,y).p(x,y) P(A,x) ( z)q(x,yz) ( x,y).q(a,f(x),y) y) 36

37 Prolog Interpreter Prolog represents a clause as A:-L 1,,L m. Prolog represents a goal as L 1,,L k. a proper Prolog interpreter has the following properties it interprets the negation not A as negation as failure it does so only if A is a ground literal if A is not ground the interpreter suspend the evaluation until A become ground or it may abort the computation the Clark s Theorem guarantees the right return value of a Prolog program 37

38 Clark s Theorem suppose T is a set of definitions for every predicate except equality if the following properties hold for two distinct function symbols: f(x) g(y) for a function symbol: f(x 1,,x, n )= f(y 1,,y,y n ) x 1= y 1 x 1 n = y n for every term t[x] that mentions the variable x t[x] x when a proper Prolog interpreter succeeds on a goal G then T ( )G when a proper Prolog interpreter fails on a goal G then T ( )G 38

39 Negation as Failure Prolog implements negation as negation as failure for not(p) Prolog tries to prove p, if p can be proved return false otherwise return true P(x) x=a, Q(x) x=b P(B) Q(B)? YES p(a). q(b). not p(x),q(x)? NO q(x),not p(x)? YES Prolog usually does no NAF on non-ground atoms 39

40 Lloyd-Topor Transformation Problem: ( x,y).subset(x,y) ( z).member(z,x) member(z,y) ( x,y).( z)[member(z,x) member(z,y)] subset(x,y) y)( z)[member(z x) member(z y)] subset(x is not a Prolog compatible clause the LT Transformation transforms a sentence W A in a clause suitable for Prolog there are 12 (syntactic) rules (e.g., replace (W 1 W 2 ) A with W 1 A, W 1 A p(x,y) subset(x,y), member(z,x) member(z,y) p(x,y) 40

41 an initial database D S 0 Closed Initial Database is closed iff for every relation fluent F there is only on sentence in the form F(x 1,,x, n,s 0 0) ) F F( (x 1,,x, n,s 0 0) for every non-fluent predicate P there is only on sentence in the form P(x 1,,x n ) P (x 1,,x n ) where P is situation independent for two distinct function symbols: f(x) g(y) for a function symbol: f(x 1,,x n )= f(y 1,,y n ) x 1 = y 1 x n = y n for every term t[x] that mentions the variable x t[x] x (objects) for every term [a] that mentions the variable a [a] a (actions) a restriction on the expressiveness, not allowed: F(A,S 0 ) F(B,S 0 ) ( x) F(x,S 0 ) murderer(caesar)=brutus 41

42 Implementation Theorem Let D be a basic action theory and P a Prolog program obtained by Lloyd-Topor rules for each non-fluent predicate of D S of form 0 P(x 1,,x n ) P (x 1,,x n ) : P (x 1,,x n ) P(x 1,,x n ) for each relational fluent predicate of D S of form 0 F(x 1,,x n,s 0 ) F (x 1,,x n,s 0 ) : F (x 1,,x n,s 0 ) F(x 1,,x n,s 0 ) for each action precondition axiom of D ap of form Poss(A(x 1,,x n ),s) A (x 1,,x n,s) : A (x 1,,x n,s) Poss(A(x 1,,x n )s) ),s) for each successor state axiom of D ssa of form F(x 1,,x n,do(a,s)) F (x 1,,x n,a,s) : F (x 1,,x n,a,s) F(x 1,,x n,do(a,s)) then P provides a correct Prolog implementation of D 42

43 A Golog Interpreter we will show a simple reference implementation (Raymond Reiter) it is based on Prolog for theorem proving the Situation Calculus is based on second-order logic Prolog does not support the whole power of secondorder logic the interpreter use some assumptions there are no functional fluents the initial database is closed special assumptions for of action preconditions and relational fluents 43

44 Directives and Definitions :- dynamic proc/2, restoresitarg/3. /* Compiler directives. Be sure some SWI Prolog related directives :- op(800, xfy, [&]). % Conjunction :- op(850, xfy, [v]). % Disjunction :- op(870, xfy, [=>]). % Implication :- op(880, xfy, [<=>]). % Equivalence :- op(950, xfy, [:]). % Action sequence :- op(960, xfy, [#]). % Nondeterministic action choice definition of operators 44

45 Definition of the do Function do(e1 : E2,S,S1) S1) :- do(e1,s,s2), S2) do(e2,s2,s1). S1) do(?(p),s,s) :- holds(p,s). do(e1 # E2,S,S1) :- do(e1,s,s1) ; do(e2,s,s1). do(if(p,e1,e2),s,s1) :- do((?(p) : E1) # (?(-P) : E2),S,S1). do(star(e),s,s1) :- S1 = S ; do(e : star(e),s,s1). do(while(p,e),s,s1): S1):- do(star(?(p) : E) :?(-P) P),S,S1). S1) do(pi(v,e),s,s1) :- sub(v,_,e,e1), do(e1,s,s1). do(e,s,s1) :- proc(e,e1), do(e1,s,s1). do(e,s,do(e,s)) :- primitive_action(e), poss(e,s). a query of the form do(e,s 0,S) will be answered ed by binding the final situation S 45

46 Definition of Substitution sub(x1,x2,t1,t2) X2 T2) :- var(t1), T2 = T1. sub(x1,x2,t1,t2) :- \+ var(t1), T1 = X1, T2 = X2. sub(x1,x2,t1,t2) :- \+ T1 = X1, T1 =..[F L1], sub_list(x1,x2,l1,l2), T2 =..[F L2]. sub_ list(x1,x2,[],[]).,[],[]) sub_list(x1,x2,[t1 L1],[T2 L2]) :- sub(x1,x2,t1,t2), sub_list(x1,x2,l1,l2). sub(name,new,term1,term2) Term2 is Term1 with name replaced by new 46

47 Test Conditions (Lloyd-Topor Transformation) holds(p & Q,S) :- holds(p,s), holds(q,s). holds(p v Q,S) :- holds(p,s); holds(q,s). holds(p => Q,S) :- holds(-p v Q,S). holds(p <=> Q,S) :- holds((p => Q) & (Q => P),S). holds(-(-p),s) :- holds(p,s). holds(-(p (P & Q),S) :- holds(-p v -Q,S). holds(-(p v Q),S) :- holds(-p & -Q,S). holds(-(p => Q),S) :- holds(-(-p v Q),S). holds(-(p <=> Q),S) :- holds(-((p => Q) & (Q => P)),S). holds(-all(v,p),s) :- holds(some(v,-p),s). holds(-some(v,p),s) ( ) :- \+ holds(some(v,p),s). ( ) holds(-p,s) :- isatom(p), \+ holds(p,s). holds(all(v,p),s) :- holds(-some(v,-p),s). holds(some(v,p),s) (V :- sub(v,_,p,p1), P1) holds(p1,s). 47

48 Treatment of the hold Predicate holds(a,s) :- restoresitarg(a,s,f), S F ; \+ restoresitarg(a,s,f), isatom(a), A. isatom(a) :- \+ (A = -W ; A = (W1 & W2) ; A = (W1 => W2) ; A = (W1 <=> W2) ; A = (W1 v W2) ; A = some(x,w) ; A = all(x,w)). restoresitarg(poss(a),s,poss(a,s)). RestoreSitArg have to be defined for all atoms taking a situation argument (i.e., action preconditions and fluents) 48

49 The famous Elevator Example Again A Demo in SWI Prolog 49

50 Golog Summary Golog is a program language for dynamic systems Golog used the principles of the Situation Calculus execution of a Golog program is related to theorem proving there exists a reference Golog interpreter t for Prolog if some assumptions hold the interpreter correctly executes the program 50

51 Questions? 51

Situation Calculus and Golog

Situation Calculus and Golog Institute for Software Technology 1 Recap Situation Calculus Situation Calculus allows for reasoning about change and actions a dialect of the second-order logic uses the concept