Jrgen Dix

1
IMPACT Agent Extensions

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

1
2
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)

3
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 As 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.

4
Belief/ Belief Semantics Table

• Belief Table of agent heli1
• Agent Formula
• heli2 in(pos2,heli2getPos())
• 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 Bs state the formula ?
  holds. (? is a belief formula).
• Belief Semantics Table of agent heli1
  heli2 acts according to Semfeas, tank1
  according to Semrat,

5
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.

6
Example Meta Agent Program

• If an enemy located at P2 threatens a
  friendly force at P1, the enemy should be
  attacked.
• Part of heli1s meta agent program
• O attack(P2) ? Belheli1(heli2,in(P1, heli2
  getPos() ) ),
• in(P1,
  trackingthreatened(P2) )
• where trackingthreatened(P2) gives all positions
  threatened
• by an enemy located in P2.

7
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.

8
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).

9
Checkpoint Expressions (cpe)

• Specify times when an actions 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.

• rel50 at time 50 from start
• time
• abs10,20,30 at times 10, 20
• and 30
• More complex abst
  in(t,clocktime())
• in(0,mathremaind(t,10))
• tgt100
  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. (abs10,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 TETs
• cpe determines duration
• if timepoint t is designated by the TETs then
• update the state by executing add/delete lists at
  times t.

• EXAMPLE climb(CurHt,ToHt,Angle,Speed
  )
• Pre in(CurHt,heliget_alt(Xnow))
• CPE relX in(X,mathcomp( ))
• TET (relt formula,Add,Del)
• Del in(Y,heliget_alt(Xnow -30))
• Add in(Y,heliget_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,6Y7
• Xnow-5,Xnow5

• Temporal annotated state condition (TASC) is of
  the form ?TA where
• ? is a conjunction of cccs 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,
  terrgetPlan(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
  cccs 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,t5
  ? 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,t20
  ? 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 t Set of objects of
  type t 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 t where t 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 actions
  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 ? cca1l1,u1 .. ccanln,un
  Op1 a1 Opn an
• where the l,us 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,us 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,autopilotgetLoc()),
• 
  Loc.zlt2000,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,autopilotgetLoc()),
• 
  Loc.zlt2000.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.