On Ability to Autonomously Execute Agent Programs with Sensing

Transcription

1 On Ability to Autonomously Execute Agent Programs with Sensing Sebastian Sardiña Dept. of Computer Science University of Toronto Yves Lespérance Dept. of Computer Science York University Giuseppe De Giacomo Dip. Informatica e Sistemistica Univer. di Roma La Sapienza degiacomo@dis.uniroma1.it Hector J. Levesque Dept. of Computer Science University of Toronto hector@cs.toronto.edu cogrobo

2 Motivation Agent programming languages should support planning/deliberation under incomplete information with sensing actions. Need a spec. for this. Most existing formal models of deliberation are epistemic, while agent programming languages have transition system semantics. Hard to relate. Here, develop new non-epistemic formal model of deliberation. Set within situation calculus and IndiGolog. But important lessons for agent programming languages in general. 1

3 Situation Calculus A dialect of the predicate calculus with sorts for actions and situations Actions: open, look, dial(14), go(airport), check departures,... Situations: S 0 the initial situation do(a, s) where a is an action term and s is a situation Fluents: predicates/functions whose value changes from situation to situation: Locked(S 0 ) Locked(do(dial(2), S 0 )) Use a distinguished predicate P oss(a, s) to assert that it is possible to execute action a in situation s 2

4 High-Level Deterministic Programs a, primitive action δ 1 ; δ 2, sequence if φ then δ 1 else δ 2 endif, conditional while φ do δ endwhile, while loop 3

5 High-Level Deterministic Programs a, primitive action δ 1 ; δ 2, sequence if φ then δ 1 else δ 2 endif, conditional while φ do δ endwhile, while loop GetOnF light Detailed def = go(airport); check departures; % sensing action if P arked(f light123, GateA) then go(gatea); board plane(f light123) else go(gateb); board plane(f light123) endif Without sensing, goal cannot be achieved! 3

6 High-Level Programs and Histories A history σ = (a 1, µ 1 ), (a 2, µ 2 ),..., (a n, µ n ) describes a run with actions and their sensing results; e.g.: (go(airport), 1) (check departures, 0) (go(gateb), 1). A configuration is a pair (δ, σ) with a program δ and a history σ specifying the actions performed so far and the sensing results obtained. 4

7 High-Level Programs and Histories A history σ = (a 1, µ 1 ), (a 2, µ 2 ),..., (a n, µ n ) describes a run with actions and their sensing results; e.g.: (go(airport), 1) (check departures, 0) (go(gateb), 1). A configuration is a pair (δ, σ) with a program δ and a history σ specifying the actions performed so far and the sensing results obtained. Sensed[σ] stands for formula specifying the sensing results of history σ, e.g.: SF (go(airport), S 0 ) SF (check departures, do(go(airport), S 0 )) SF (go(gateb), do(check departures, do(go(airport), S 0 ))) end[σ] stands for the situation term of history, σ, e.g.: end[ɛ] = S 0 and end[(go(airport), 1)] = do(go(airport), S 0 ) 4

8 IndiGolog Semantics for Online Executions Two relations in the object language: T rans(δ, s, δ, s ): means that it can make transition (δ, s) (δ, s ) by executing a single primitive action or test. F inal(δ, s): means that computation can be terminated in (δ, s) 5

9 IndiGolog Semantics for Online Executions Two relations in the object language: T rans(δ, s, δ, s ): means that it can make transition (δ, s) (δ, s ) by executing a single primitive action or test. F inal(δ, s): means that computation can be terminated in (δ, s) Semantics based on two notions (relative to an underlying theory of action D): Configuration (δ, σ) may evolve to (δ, σ ) w.r.t. a model M. A configuration (δ, σ) is final, i.e. may legally terminate. 5

10 IndiGolog Semantics for Online Executions Two relations in the object language: T rans(δ, s, δ, s ): means that it can make transition (δ, s) (δ, s ) by executing a single primitive action or test. F inal(δ, s): means that computation can be terminated in (δ, s) Semantics based on two notions (relative to an underlying theory of action D): Configuration (δ, σ) may evolve to (δ, σ ) w.r.t. a model M. A configuration (δ, σ) is final, i.e. may legally terminate. The theory D, augmented with the sensing results in σ, must entail that the transition is possible. Model M above represents a possible environment (generate sensing results.) 5

11 IndiGolog Semantics for Online Executions Formal Details Configuration (δ, σ) may evolve to (δ, σ ) w.r.t. a model M (relative to an underlying theory of action D) iff (i) M is a model of D {Sensed[σ]}, and (ii) D T {Sensed[σ]} = T rans(δ, s, δ, s ), and (iii) σ = σ (a, 1) if s = do(a, s) and M = SF (a, s), σ (a, 0) if s = do(a, s) and M = SF (a, s), σ if s = s, where s = end[σ] and s = end[σ ]. Configuration (δ, σ) is final when: D T {Sensed[σ]} = F inal(δ, end[σ]) 6

12 Deliberation: An EC-based Account The idea: An agent can/knows how to execute program δ in history σ iff he can always choose a next action/transition and eventually reach a terminating configuration no matter what sensing results are obtained. Agent must know that the chosen action/transition is allowed by the program and is executable. In what follows, we we will define KHow EC (δ, σ) using both entailment and consistency. 7

13 Deliberation: An EC-based Account (cont.) We define KHow EC (δ, σ) to be the smallest relation R(δ, σ) such that: 8

14 Deliberation: An EC-based Account (cont.) We define KHow EC (δ, σ) to be the smallest relation R(δ, σ) such that: (E1) if (δ, σ) is final, then R(δ, σ); 8

15 Deliberation: An EC-based Account (cont.) We define KHow EC (δ, σ) to be the smallest relation R(δ, σ) such that: (E1) if (δ, σ) is final, then R(δ, σ); (E2) if (δ, σ) may evolve to configurations (δ, σ (a, µ i )) w.r.t. some models M i with i = 1..k for some k 1, and R(δ, σ (a, µ i )) holds for all i = 1..k, then R(δ, σ). Obs.: always consider the underlying theory plus the observations in history σ. 8

16 E.g. Tree Chopping Problem Agent wants to cut down a tree. Possible actions are: chop, take one chop at the tree, and look, which tells the agent whether the tree has fallen (i.e., senses fluent Down). It is known that tree will eventually fall, but number of chops needed is not bounded. 9

17 E.g. Tree Chopping Problem Agent wants to cut down a tree. Possible actions are: chop, take one chop at the tree, and look, which tells the agent whether the tree has fallen (i.e., senses fluent Down). It is known that tree will eventually fall, but number of chops needed is not bounded. Intuitively, the following program δ tc : solves the problem. But... while Down do chop; look endwhile 9

18 Formalizing the Tree Chopping E.g.: D tc D ss contains the following successor state axiom: RemainingChops(do(a, s)) = n a = chop RemainingChops(s) = n + 1 a chop RemainingChops(s) = n. D ap contains the following 2 precondition axioms: P oss(chop, s) (RemainingChops(s) > 0), P oss(look, s) T rue. D sf contains the following sensing axiom: SF (look, s) (RemainingChops(s) = 0). D S0 = {RemainingChops(S 0 ) > 0} (initial situation). Down(s) def = (RemainingChops(s) = 0). 10

19 Tree Chopping E.g. (cont.) Intuitively, the following program δ tc : while Down do chop; look endwhile solves the problem. But... 11

20 Tree Chopping E.g. (cont.) Intuitively, the following program δ tc : while Down do chop; look endwhile solves the problem. But... Theorem 1. For all k N, KHow EC (δ tc, [(chop, 1) (look, 0)] k ) does not hold. In particular, when k = 0, KHow EC (δ tc, ɛ) does not hold. In fact,... 11

21 Tree Chopping E.g. (cont.) Intuitively, the following program δ tc : while Down do chop; look endwhile solves the problem. But... Theorem 1. For all k N, KHow EC (δ tc, [(chop, 1) (look, 0)] k ) does not hold. In particular, when k = 0, KHow EC (δ tc, ɛ) does not hold. In fact,... Theorem 2. Whenever KHow EC (δ, σ) holds, there is simple kind of conditional plan, a TREE program, that can be followed to execute δ in σ. which means that... 11

22 Tree Chopping E.g. (cont.) Intuitively, the following program δ tc : while Down do chop; look endwhile solves the problem. But... Theorem 1. For all k N, KHow EC (δ tc, [(chop, 1) (look, 0)] k ) does not hold. In particular, when k = 0, KHow EC (δ tc, ɛ) does not hold. In fact,... Theorem 2. Whenever KHow EC (δ, σ) holds, there is simple kind of conditional plan, a TREE program, that can be followed to execute δ in σ. which means that... Corollary 1. KHow EC is only correct when problem has a bounded solution 11

23 Why does KHow EC Fail? ents δ tc [ ] chop δ tc look ; δ tc 0 look ; δ tc 0 (chop, 1) (chop, 1) (chop, 1) (chop, 1) (look, 0) chop (look, 0) look (look, 0) chop look (look, 0) (chop, 1) (chop, 1) (chop, 1) (look, 0) 0 (look, 0) look ; δ tc 1 (chop, 1) 1 look (chop, 1) 1 δ tc (chop, 1) (look, 1) δ tc (chop, 1) (look, 0) (chop, 1) (look, 1) δ tc δ tc def = while Down do chop; look endwhile δ tc (chop, 1) (look, 0) (chop, 1) (look, 0) (chop, 1) (look, 1) 12

24 Why does KHow EC Fail? If KHow EC (δ tc, ɛ), then for all j N: KHow EC (δ tc, ((chop, 1) (look, 0)) j ) and KHow EC (look; δ tc, ((chop, 1) (look, 0)) j (chop, 1)). δ tc chop look; δ tc KHow EC is taking into account the execution where three never comes down! Every finite prefix of the execution is consistent with D tc. But, the set of all of them together is not! 13

25 Why does KHow EC Fail? If KHow EC (δ tc, ɛ), then for all j N: δ tc chop look; δ tc δ tc KHow EC (δ tc, ((chop, 1) (look, 0)) j ) and KHow EC (look; δ tc, ((chop, 1) (look, 0)) j (chop, 1)). KHow EC is taking into account the execution where three never comes down! look, 0 look, 1 Every finite prefix of the execution is consistent with D tc. But, the set of all of them together is not! 13

26 Why does KHow EC Fail? If KHow EC (δ tc, ɛ), then for all j N: δ tc chop look; δ tc δ tc look, 0 look, 1 KHow EC (δ tc, ((chop, 1) (look, 0)) j ) and KHow EC (look; δ tc, ((chop, 1) (look, 0)) j (chop, 1)). KHow EC is taking into account the execution where three never comes down! δ tc chop Every finite prefix of the execution is consistent with D tc. But, the set of all of them together is not! 13

27 Why does KHow EC Fail? δ tc chop look; δ tc δ tc look, 0 look, 1 δ tc chop look; δ tc δ tc look, 0 look, 1 If KHow EC (δ tc, ɛ), then for all j N: KHow EC (δ tc, ((chop, 1) (look, 0)) j ) and KHow EC (look; δ tc, ((chop, 1) (look, 0)) j (chop, 1)). KHow EC is taking into account the execution where three never comes down! Every finite prefix of the execution is consistent with D tc. But, the set of all of them together is not!... 13

28 Why does KHow EC Fail? δ tc chop look; δ tc δ tc look, 0 look, 1 δ tc chop look; δ tc δ tc look, 0 look, 1 If KHow EC (δ tc, ɛ), then for all j N: KHow EC (δ tc, ((chop, 1) (look, 0)) j ) and KHow EC (look; δ tc, ((chop, 1) (look, 0)) j (chop, 1)). KHow EC is taking into account the execution where three never comes down! Every finite prefix of the execution is consistent with D tc. But, the set of all of them together is not!... 13

29 Deliberation: ET-based Account To solve the problem, we consider each environment/model individually. We define KHowInM(δ, σ, M) to be the smallest relation R(δ, σ) such that: 14

30 Deliberation: ET-based Account To solve the problem, we consider each environment/model individually. We define KHowInM(δ, σ, M) to be the smallest relation R(δ, σ) such that: (T1) if (δ, σ) is final, then R(δ, σ); 14

31 Deliberation: ET-based Account To solve the problem, we consider each environment/model individually. We define KHowInM(δ, σ, M) to be the smallest relation R(δ, σ) such that: (T1) if (δ, σ) is final, then R(δ, σ); (T2) if (δ, σ) may evolve to (δ, σ (a, µ)) w.r.t. M and R(δ, σ (a, µ)), then R(δ, σ). Uses truth in a model! 14

32 Deliberation: ET-based Account (cont.) KHow ET (δ, σ): iff it knows how to execute it in every model of the history (i.e., in every possible environment). Formally: KHow ET (δ, σ) iff for every model M such that M = D {Sensed[σ]}, KHowInM(δ, σ, M) holds. 15

33 Deliberation: ET-based Account (cont.) KHow ET (δ, σ): iff it knows how to execute it in every model of the history (i.e., in every possible environment). Formally: KHow ET (δ, σ) iff for every model M such that M = D {Sensed[σ]}, KHowInM(δ, σ, M) holds. KHow ET handles the tree chopping example: KHow ET (δ tc, ɛ) holds! 15

34 Generalizing to Non-deterministic Programs Two possible approaches: Angelic: choices are under the control of the agent (deliberation); Demoniac: choices are not under the control of the agent (execution). KHow Ang ET nd (δ, σ) iff there is a deterministic program δ d such that KHow ET (δ d, σ) holds, and D T {Sensed[σ]} = s.do(δ d, end[σ], s) Do(δ, end[σ], s). 16

35 Further Issues KHow X can be used to define agent ability Can X (φ, σ). Angelic version for nondeterministic programs can be used to define a metatheoretic account of deliberation (i.e., search construct in IndiGolog). Relation KHow ET corresponds exactly to effective controllers and robot programs as described in [Lin and Levesque 1998]. Hence, it is both sound and complete w.r.t. robot achievability. 17

36 Lessons for Agent Programming Languages Most agent programming languages have transition semantics and use entailment to evaluate tests and action preconditions (e.g., ConGolog, 3APL, FLUX, etc.). Most agent programming languages only do on-line reactive execution; no deliberation/lookahead. Deliberation is only a different control regime involving search over the agent program s transition tree. With sensing, need to find more than just a path to a final configuration, need a plan/subtree with branches for all possible sensing results. Can determine possible sensing results by checking consistency with KB. Essentially an EC-based approach. 18

37 Lessons for Agent Programming Languages (cont.) As methods for implementing deliberation in restricted cases, approaches are fine. EC-based But as a semantics or specification, we claim they are wrong. 19

38 Lessons for Agent Programming Languages (cont.) As methods for implementing deliberation in restricted cases, approaches are fine. EC-based But as a semantics or specification, we claim they are wrong. KHow EC gives the wrong results on problems that can t be solved in a bounded number of actions. What s required is something like our ET-based account. 19

39 Summary Agent programming languages should support planning/deliberation under incomplete information with sensing actions. We develop some non-epistemic formal models of deliberation. The obvious model is one where agent makes decisions about what to do in terms of what is entailed by or consistent with his KB. This model doesn t work properly for problems that have no bounded solution and require iteration. We propose an alternative entailment and truth-based model that works. There are important lessons for agent programming languages in general. 20

40 Further Research Relate this metatheoretic account of deliberation to epistemic ones. Re-state everything in terms of other agent formalisms: 3APL, AgentSpeak, FLUX, etc. Implementation of search/planning with non-binary sensing actions. More general accounts of sensing and knowledge change. Multiagent planning. Etc. 21

41 Related Work [Moore 1985]: knowledge and plans. [Davis 1994]: Knowledge precondition for plans (executable plans). [Davis & Morgenstern 2004]: A First-Order Theory of Communication and Multi-Agent Plans. [Mc Illraith & Son 2002]: self-sufficient programs. Lin & Levesque 1998]: robot programs and effective controllers. 22