Jürgen Dix University of Maryland/University of Koblenz joint work with Sarit Kraus (Bar-Ilan), VS...

Jürgen Dix University of Maryland/University of Koblenz

joint work with

Sarit Kraus (Bar-Ilan),

VS Subrahmanian (Maryland)

1

IMPACT Agent Extensions

21999 IMPACT Workshop

Outline Meta Agents: Allow agents to

reason about the beliefs and actions of other agents.

Temporal Agents: Allow agents to execute actions that have temporal extent and to schedule actions for the future. Agents may reason about the past.

Probabilistic Agents: Allow the agent to reason about uncertainty in the world.

Motivating Example (RAMP)


Additional Data Structures Agent maintains two kinds of tables:

a belief table specifying the beliefs the agent has about other agents. This table contains information both about agent A’s beliefs about the state of another agent B, but also the actions of agent B, beliefs of agent B about other agents, ...

a belief semantics table specifying what the agent believes another agent uses for its own reasoning.


Belief/ Belief Semantics Table Belief Table of agent heli1: Agent Formula

heli2 in(pos2,heli2:getPos())

tank1 in(pos1,tank1 :getPos())

tank1 Beltank1(heli1, in(pos2,heli1 :getPos())),

Literals of the form BelA(B,), are called Belief literals:

this says (informally) that agent A believes that in agent B’s state the formula holds. ( is a belief formula).

Belief Semantics Table of agent heli1: heli2 acts according to Semfeas, tank1 according to Semrat,


Meta Agent Programs A meta-agent rule has the form

Op a L1 & … & Ln

where each Li is either a– code call literal– action literal or

– a belief literal of the form BelA(B,).

A meta-agent program is a finite set of meta-agent rules.


Example Meta Agent Program

If an enemy located at P2 threatens a friendly force at P1, the enemy should be attacked.

Part of heli1’s meta agent program:

O attack(P2) Belheli1(heli2,in(P1, heli2 :getPos() ) ),

in(P1, tracking:threatened(P2) )

where tracking:threatened(P2) gives all positions threatened

by an enemy located in P2.


Key Results Developed a formal semantics of meta-agent programs.

Key Theorem 1: Showed that when no beliefs are present, this semantics coincides with ordinary agent programs.

Key Theorem 2: Developed a transformation that takes as input, a MAP, and produces as output, an ordinary agent program with extended data structures such that the semantics of the MAP coincides with the semantics of the translated agent program (with extra data structures).

Above result provides a clean, efficient way of implementing MAPs within the AgentDE framework.


Temporal Agent Programs Ordinary agent programs:

Each action is assumed to be instantaneously executable. Not valid for many actions, e.g. drive_from_to(dc,ny).

Actions with temporal duration may have intermediate effects (e.g. driving a car from DC to NY, once started, constantly changes the location of the car).

At time t, an agent computes a new status set S, and immediately executes conc({ a : DO a in S }). No easy way for the agent to schedule actions for the future (though in fact this can be expressed via some additional data structures).


Checkpoint Expressions (cpe) Specify times when an action’s

effects should be incorporated into the state.

Two ways to do this relative checkpoints -

relative time-intervals since the start of the action

absolute checkpoints - specify absolute time points when the effects are to be incorporated.

rel:{50}: at time 50 from start

time

abs:{10,20,30}: at times 10, 20

and 30

More complex: abs:{t| in(t,clock:time()) &

in(0,math:remaind(t,10))

& t>100} meaning:

every 10 units from time 100 on

10


Timed Effect Triple

A timed effect triple (TET) consists of 3 components: a checkpoint expression

(cpe) (absolute or relative) an add list a delete list.

EXAMPLE:

Check at time 10, 20 and 30 some specified add and delete lists. (abs:{10,20,30} ,Add,Del).

Check from time 100 on in time intervalls of 10 the current altitude of the plane: (cpe ,Add,Del).

11


Timed Action Timed Action =

Name + Schema + Pre + cpe + set of TET’s cpe determines duration if timepoint t is designated by

the TET’s then– update the state by

executing add/delete lists at times t.

EXAMPLE: climb(CurHt,ToHt,Angle,Speed)

Pre: in(CurHt,heli:get_alt(Xnow)) CPE: rel:{X| in(X,math:comp( ))} TET: (rel:{t| formula},Add,Del)

Del: in(Y,heli:get_alt(Xnow -30))

Add: in(Y,heli:get_alt(Xnow))

12


Temporal Annotations/Conditions Temporal annotation (TA) is

a piece of syntax denoting a time interval: [ta1,ta2].

EXAMPLE: Expressions in a language [2,5] [3X,6Y+7] [Xnow-5,Xnow+5]

Temporal annotated state condition (TASC) is of the form :TA where is a conjunction of ccc’s

and/or action status atoms, TA is a temporal annotation.

Intuitive reading of :TA: is true at some time point that is a solution of TA.

EXAMPLE: in(RP, terr:getPlan(P1,P2,Veh)): [2,5]

13


Temporal agent program Consists of a set of rules of the form

Op a :TA F1 :TA1, F2 :TA2, … Fn :TAn,

where TA, TA2 , … TAn are temporal annotations and each Fi is a conjunction of ccc’s and/or action status.

Says: if Fi :TAi are all true, the Op a should hold at some time point that is true in the interval denoted by TA.

14


Example TAP If deciding at time t to adjust course, it may compute the

current location in the next 5 time units.

P compute_Loc() :[t,t+5] Do adjust_course(…) :[t,t]

If deciding at time t to adjust course, it must execute the corresponding flight plan in the next 20 time units.

O execute_flightplan() :[t,t+20] Do adjust_course(…) :[t,t]

15


Key Results Developed a formal semantics for TAPs.

Every TAP restricted to a single time point (Xnow) has the same semantics as an ordinary agent program.

Developed an iterative fixpoint computation procedure that computes the temporal status set of a temporal agent.

Procedure is provably sound, complete, and polynomial under appropriate conditions.

16


Probabilistic Agents Uncertainty is an essential part of any battlefield

application. What is true in the world? What actions can/cannot be performed in the current state? What will another agent do?

An agent infrastructure must support the creation and deployment of agents that can reason about uncertainty.

We have proposed the concept of a probabilistic agent defined how agents may act when the world is uncertain developed a formal semantics for such agents

17


Probabilistic Code Calls Random variable of type

Set of objects of type together with a probability distribution on the set.

Probabilistic Code Call pcc: Suppose cc is a code call. A probabilistic version of cc returns a set of random variables of type where is the output type of cc.

The probability that object a is in the answer of cc:

a is not in X for all (X,d) in pcc: 0 .

a is in X for some (X,d) in pcc: d(a).

EXAMPLE:

18


Satisfaction

Object state O satisfies in(a, pcc) with probability in [l,u] iff probability lies in the interval [l,u].

An action can be executed in O iff the action’s precondition is true in the state with probability 1.

EXAMPLE: Code Call: “Find all vehicles within 6 units of circle.”

Answer: 2 Random Variables.

We have to define what it means for in(answer, pcc) to be true!

19


Probabilistic agent program

Set of rules of the form Op a cca1:[l1,u1] & .. & ccan:[ln,un] & Op1 a1 & … & Opn an

where the [l,u]’s denote intervals.

Rules are read: if the code call atoms ccai are true with probabilities in the indicated ranges, then Op a is true.

The [l,u]’s can have variables in them.

20


Example of a Probabilistic Agent Program

If probability that plane is below 800 meters is low, agent is allowed to update estimate of current location.

P compute_Loc(….) in(Loc,autopilot:getLoc()),

Loc.z<200:[0,0.1]

If probability that plane is below 800 meters is high, agent is obliged to update estimate of current location.

O compute_Loc(….) in(Loc,autopilot:getLoc()),

Loc.z<200:[0.6,1]

21


Key Contributions

Defined the concept of an uncertain state over arbitrary data structures.

Defined probabilistic agent programs (PAPs). Developed a formal semantics for PAPs.

Showed that the formal semantics coincides with ordinary agent programs when no uncertainty occurs.

Developed sound and complete fixpoint computation algorithms.

22


Conclusions For any realistic application (battlespace), there is

uncertainty about various things involved.

For any realistic application (battlespace), actions and effects evolve over time.

Beliefs about other agents might also play a role.

Our extended frameworks address all these needs.

Jürgen Dix University of Maryland/University of Koblenz joint work with Sarit Kraus (Bar-Ilan), VS...

Documents

Transcript of Jürgen Dix University of Maryland/University of Koblenz joint work with Sarit Kraus (Bar-Ilan), VS...