KGP A Computational Logic Based Model of Agency

1
KGP A Computational Logic Based Model of Agency

• Fariba Sadri
• Imperial College London
• ICCL Summer School Dresden
• August 2008

2
Outline

• KGP introduction
• KGP extension with normative concepts

3
KGP IntroductionThe SOCS Project

• The KGP model was initially developed within the
  EU SOCS project, 2002-2006.
• SOCS
• Societies of Computational Entities
• http//lia.deis.unibo.it/research/socs/
• SOCS Partners Imperial College, City, Cyprus,
  Pisa, Bologna, Ferrara

4
KGP Introduction

• KGP
• Knowledge Goals Plan
• Inspired by BDI!

5
KGP Introduction KGP integrates various
aspects of agency

• Autonomy
• Reasoning (e.g. for Planning/Proactivity)
• Reactivity
• Situatedness awareness of the environment/other
  agents
• Interaction amongst agents
• Goal introduction
• Declarative control
• (some) Belief revision

6
KGP Introduction

• General purpose
• Highly modular
• Based on computational logic
• Includes
• an abstract model (declarative semantics)
• a computational model (operational semantics)
• a prototype implementation (PROSOCS)

7
Modularity
8
KGP Introduction

• Heterogeneity
• Dynamic open environments
• Adaptability to changes in the environment
• Dynamic context-dependent control

9
KGP Introduction KGP agent Decides its goal
options
Write a paper
Attend to the garden
Book my travel
Make dinner
Repair the roof
10
KGP Introduction KGP agent Decides its goals
Write a paper
Attend to the garden
Book my travel
Make dinner
Repair the roof
11
KGP Introduction KGP agent Observes its
environment

• It is raining. Water is pouring in
  through the roof.

12
KGP Introduction KGP agent adjusts its goals
to the observations
Write a paper
Attend to the garden
Book my travel
Make dinner
Repair the roof
13
KGP Introduction KGP agent Plans (partially)
for its goals and executes actions
Repair the roof
Call roofer at T2, T2gtT1
Check bank balance at T1
Make domestic arrangements at T4, T4gtT2, T4gtT3
Call decorator at T3, T3gtT1
14
KGP Introduction KGP agent Adjusts its plans

• Bank balance very low

Additional Goal Find Money
15
KGP Introduction KGP agent Reacts to
information/interaction from the environment
What should my answer be?
Can you lend me money on the 10th?
Policies for communication and negotiation
16
KGP Architecture

• An agent is characterised by
• An internal mental state
• A set of reasoning capabilities with associated
  knowledge bases
• A set of physical and sensing capabilities
• A set of formal state transition rules
• A set of selection operators
• A control (cycle) theory

17
State
Environment
Agents activities
Other Conditions
Selection Operators
The Capabilities and Associated KBs
18
(No Transcript)
19
KGP Architecture Agent Internal Mental State

• lt KB0, F, C, ? gt
• KB0 a KB holding dynamic knowledge of the agent
• F a forest of trees representing the goal
  structure of the agent
• C the temporal constraint store
• ? a set of equalities instantiating time
  variables

20
KGP Architecture KB0in state lt KB0, F, C, ? gt

• KB0 of agent x records
• actions executed by x ( time of execution)
  executed(a, t)
• properties (fluent literals) observed by x (
  time of observation) observed(fl, t)
• actions x observes as being executed by other
  agents y ( time of execution by y time of
  observation by x) observed(y, at', t)

21
KGP Architecture KB0 cntd.

• KB0 is updated as the agent
• Observes the world
• (via its sensing capability)
• Executes actions
• (via its actuating capability)
• KB0 is contained within all the other KBs (and
  used by all the reasoning capabilities).

22
KGP Architecture Fin state lt KB0, F, C, ? gt

• F is a forest of trees
• Each tree represents a goal hierarchy
  (goal/subgoal relationships)
• Each node is a (timed) goal which is
• Non-exectuable (subgoal)
• Executable (action)
• The root nodes represent a conjunction of
  literals and the leaf nodes together represent a
  (partial) plan for the goal at the root

23
KGP Architecture Fin state lt KB0, F, C, ? gt

• G1 G2 .. Gn
• G11 G12 G21 An1 Gn1
• A11 A12
• The top level goals, Gi, are conceptually
  conjoined.

24
KGP Architecture F Informal example of a Tree
in F
G repair_roof(T), 5ltTlt20
G1 have_resource(r1,T1) 5ltT1lt18
A1 tell(a,b,request(assistance),T3) T3lt20,
T3gtT1, T3gtT2
G2 have_resource(r2,T) 5ltT2lt18
A2 tell(a,c,request(r1),T4) T4ltT1
25
KGP Architecture F cntd.

• Goals can be
• Mental (under the control of the agent) e.g.
  repair_roof(T)
• Sensing ( not under the control of the agent and
  observable by sensing the external environment)
• e.g. weather_is_dry(T)

26
KGP Architecture F cntd.

• Actions can be
• Physical
• e.g. clear_table(T) book_ticket(london,
  tokyo, T)
• Sensing (actively observe)
• e.g. sense(connection_on, T)
• Communicative
• e.g. tell(x, y, request(r1), d, T)

27
KGP Architecture C - Temporal Constraint Store

• C is the temporal constraints store.
• In the previous example C will include
• 5ltT1lt18, 5ltT2lt18
• T3lt20, T3gtT1, T3gtT2
• T4ltT1

28
KGP declarative modelReasoning Capabilities

• Planning generates partial plans for given sets
  of goals in the State
• Temporal reasoning reasons about the evolving
  environment, and makes predictions about
  properties holding in the environment
• Reactivity reacts to perceived changes in the
  environment by generating goals and actions to be
  added to the State

29
Reasoning Capabilities cntd.

• Identification of preconditions and effects of
  actions to determine appropriate sensing
  actions, to check if an action can be executed
  and if recently executed actions have been
  successful.
• Goal decision to revise the top-most level goals
  of the agent, adapting to the perceived changes
  in the environment and the agents preferences.

30
Reasoning Capabilities General

• Each reasoning capability
• uses a KB and
• is defined formally by means of an entailment
  wrt the KB (and, where appropriate, a time point,
  now)
• The knowledge bases are either abductive logic
  programs or logic programs with priorities.

31
Reasoning Capabilities Formal specifications

• Abductive logic programming for
• Planning
• Temporal reasoning
• Reactivity
• Identification of preconditions and effects of
  actions
• Logic programming with priorities for
• Goal decision

32
Reasoning Capabilities Planning

• KBplan Abductive Event Calculus for
  Planning
• KBplan lt Pplan, Aplan, Iplan gt
• Logic program Abducible Integrity
• with predicates constraints
• constraints

33
Reasoning CapabilitiesPlanning cntd.

• Formal specification of the Planning capability
• The idea is
• Planning is specified via the semantics of
  abductive logic programs
• To plan for a goal we take into account
• all dynamic information received via observations
  and
• all other partial plans already in the state.

34
Reasoning CapabilitiesPlanning cntd.

• Formal specification of the Planning capability
• Let KBnowplan be KBplan?time_now(now) .
• Let S ltKB0, F, C, ? gt .
• Let GgT be a mental goal in a leaf in F.
• Let ?0 be the set of all abducibles already in F.
• Let C 0 C ? ?.

35
Reasoning CapabilitiesPlanning cntd.

• Then S, G nowplan (?, Tc)
• where
• such that(? , Tc) is an abductive answer to the
  query holds_at(G, T) wrt (KBnowplan , ?0 , C0).
• To allow partial planning
• holds_at(F,T) ifassume_holds(F,T)

36
Reasoning Capabilities Underlying (C)LP-based
semantics

• The KGP model is parametric on
• ?ALP some semantics for ALPs
• ?pr some semantics for logic programs with
  priorities (and negation)
• ? some semantics for constraint satisfaction
• Operational model of the KGP assumes concrete
  instances of the above.

37
Reasoning Capabilities Reactivity

• In the KGP reactivity is used for
• To specify reactions to the environment, similar
  to condition-action rules
• To specify interaction policies
• To specify plan repair steps

38
Reasoning Capabilities Reactivity

• KBreact
• KBplan
• some additional integrity constraints we call
  Reactive Constraints

39
Reasoning Capabilities ReactivityFormal
Specification

• Reactivity computes all the necessary reactions
  to the current state of the agent, including its
  current goals and its observations recorded in
  KB0.
• Snowreact (Gs, Tc)
• where
• Gs is a set of assume_happens atoms and
  assume_holds atoms in some ? such that
• (? , Tc) is an abductive answer to the query true
  wrt (KBnowplan , ?0 , C0).

40
Reasoning Capabilities Goal Decision

• KBgd is an abductive logic program with
  priorities.
• Example
• Basic part
• gd(garden) garden(T) ? holds_at(finished_work,T)
  
• gd(repair) repair(T) ?holds_at(leaky_roof, T)
• Auxiliary part
• Typeof(garden,optional)
• typeof(repair,required)
• more-urgent-wrt-type(required, optional)
• Behaviour part
• gd_pref(X,Y)gd(Y)gtgd(X) ? typeof(X,TX),
  typeof(Y,TY),
• more-urgent-wrt-type(TY,TX)

41
Reasoning Capabilities Goal Decision cntd.

• Formal specification of GD
• SnowgdGs iff
• Gs is a maximal set G1, G2, , Gn of pairs
  Giltgi(Ti), TCigt such that
• KBnowgd pr ltg1(T1), TC1gt ?ltg2 (T2), TC2gt
  ?. ? ltgn (Tn), TCngt

42
Reasoning CapabilitiesSummary

• plan KBplan
• tr KBtr Abductive logic
• react KBreact prgogrammin
• gd KBgd Logic programming with priorities
• pre KBpre
• eff KBef Logic programming

43
Physical capabilities

• Sensing capability
• Links the agent to its environment, including
  other agents
• Allows agents to observe actions and fluents
• sensing(L, t) L
• E.g. sensing((rain, door-open, window-open), 10)
  ltrain, truegt, ltwindow-open, falsegt
• Actuating capability
• actuating(As, t) As

44
Transitions

• Transitions use the capabilities and change the
  state of the agent
• Transitions are of the form
• Slt KB0, F, C, ? gt, Input at time now
• S lt KB0, F, C, ? gt

45
Transitions Brief Descriptions

1. Goal Introduction - GI introduces new top level
   goals
2. Plan Introduction - PI performs partial planning
   for the selected set of goals and updates the
   state accordingly
3. Reactivity - RE extends the state with the
   generated reactions
4. Action Execution - AE executes the selected set
   of actions

46
Transitions Brief Descriptions cntd.

• Passive Observation Introduction - POI senses
  the environment and records whatever is observed
• Active Observation Introduction - AOI senses the
  environment for a specific set of fluents and
  records the result
• Sensing Introduction - SI introduces new actions
  in the state for sensing the preconditions of
  some existing actions in Plan

47
Transitions Brief Descriptions cntd.

• State Revision - SR revises the state by
  removing timed out goals/actions and
  goals/actions that are no longer needed.

48
Transitions an exampleAction Execution
(informally)

• AE lt KB0, F, C, ? gt, SAs now
• lt KB0, F, C, ? gt
• SAs will be a non-empty set of sensing and
  non-sensing actions.
• Then KB0 is updated by recording in it
• the non-sensing actions that were executed by the
  actuating capability, and
• any information that the sensing actions bring in
  about the environment.
• ? is updated by recording all the new time
  instantiations.

49
Example 1

• John is a businessman in Europe, and psa is his
  personal service agent.
• GI psa has the goal gain entry to museum
• PI buy a ticket
• POI psa hears that it is European Heritage
  day when all museums are free.
• SR goal and plan are deleted as the goal is
  already achieved and the plan is no longer
  needed.

50
Example 2

• psa has the goal to have a plane ticket for a
  trip from London to Madrid.
• PI Buy ticket online
• The action has pre-conditions
• -have internet connection sensing
  goals
• -destination available online
• SI Introduce sensing actions for these
  preconditions
• AE The sensing actions are executed first.
• Depending on their outcome
• Either AE To buy the ticket,
• Or SR and PI To revise the state and re-plan.

51
Cycle theories for declarative control

• Cycle theory determines the sequences of
  transitions dynamically and declaratively
  Allowing Flexible control, e.g. tailored to agent
  profile/environment/application
• Different cycle theories give rise to different
  profiles of agent behaviour
• Control via cycle theories can in principle be
  adopted by any agent architecture

52
Cycle theories
53
Cycle theories Introduction

• Idea
• To decide what the agent should do next
• Work out what the possibilities are
• Then choose one (or more) via the agents profile
  and preferences

54
Cycle theories Introduction

• A cycle theory is a (meta-)logic program with
  priorities Tcycle to reason about which
  transition should be chosen when
• It consists of
• a basic part Tbasic to reason about which
  transition could be next (in some state and at
  some time)- initially or after a transition that
  has just been executed
• a behaviour part Tbehaviour to decide which
  transition (amongst the many possible) will be
  next
• An auxiliary part

55
Selection Operators

• Recall input to transitions
• Slt KB0, F, C, ? gt, Input at time now
• S lt KB0, F, C, ? gt
• Selection operators compute these inputs and help
  cycle theories determine next transition
• 4 selection operators (used in Tbasic)
• Action selection (to execute)
• Goal selection (to plan for)
• Fluent selection (to sense)
• Precondition selection (to sense)

56
State
Environment
Agents activities
Other Conditions
Selection Operators
The Capabilities and Associated KBs
57
Predicative representation of transitions

• Within the cycle theory and
• the agent behaviour, a transition
• (T) SltKB0, F, C, ? gt, X ?
• S ltKB0, F, C, ? gt
• is represented as an atom in the predicate T
• T(S, X, S',?)
• (sometimes with some parameters omitted)
• An instance could be PI(s, (g1,g2), s, 1) .

58
Cycle Theories and Agent Behaviour

• Given an agents cycle theory Tcycle, the agent
• behaviour is a (possibly infinite) sequence of
• Transitions
• T1(S0,X1,S1,t1),.,Ti(Si-1,Xi,Si,ti),
  Ti1(Si,Xi1,Si1,ti1), .
• S0 is some initial state for the agent
• ti is given by some internal clock
• Tcycle , Ti(Si-1,Xi,Si,ti), time_now(T ) ?pr
  Ti1(Si,Xi1,Si1,ti1)

59
Cycle Theories and Agent Behaviour cntd.

• Here ?pr is entailment for logic programming with
  priorities
• (also underlying the Goal Decision reasoning
  capability).

60
Cycle theories syntax

• Tbasic contains rules of the form
• r T1 T2 (S',X') T2 (S',X') T1 (S,X,S'),
  EC(S', t, X'), time-now(t)
• S, S' states, X' input to T2, EC enabling
  conditions (core selection operator)
• Tbehaviour contains rules of the form
• RTN1N2 rTN1(S,X1 )gtr T N2(S,X2)
  BC(S,X1,X2,t), time-now(t)
• S state, X1 input to N1, X2 input to N2,
• BC behaviour conditions (heuristic selection
  operator)

61
Cycle theories example of Tbasic

• r PIAE(S',As)
• AE(S',As) PI(S,Gs,S'),
• Asfas(S',t), As ¹ , time_now(t )
• meaning a Plan Introduction transition may be
  followed by an Action Execution transition, if
  there are actions to be executed (identified by
  the core selection operator for action selection
  fas)

62
Cycle theories example of Tbasic

• r POIRE(S',_) RE(S',_) POI(S,_,S')
• meaning a Passive Observation Introduction
  transition may be followed by a Reactivity
  transition, unconditionally.

63
Cycle theories example of Tbehaviour

• r PIAE(S,As) gt rPIN(S,X)
• unreliable_pre(As)
• for all transitions N ? AE
• r PISI(S,Ps) gt r PIAE(S,As)
  unreliable_pre(As)
• meaning after Plan Introduction, the
  transition Action Execution should be given
  higher priority, unless there are actions amongst
  the actions selected for execution whose
  preconditions are unreliable and need checking,
  in which case Sensing Introduction will be given
  higher priority

64
Agent Profiles

• Different agent behaviours can be programmed by
  changing various modules of the model.
• For example, changing the
• Basic part of cycle theories
• Behaviour part of cycle theories
• Selection operators

65
Cycle Theories and Agent Profiles

• In Sadri-Toni paper in CLIMA 05
• Focussed
• agent remains committed to one goal (and its
  descendents) until it is either achieved or
  becomes infeasible.
• Obtainable via particular goal/action selection
  strategies.
• Careful (Common sense)
• agent never does anything unnecessary

66
The Careful Profile

• Profile Never does anything unnecessary
• Never plans for a goal that needs no plan
• Never reacts unnecessarily
• Never executes an action which is not needed
• How to achieve this?
• Write a cycle theory that ensures every other
  transition is SR.
• We can then formally prove, via the operation
  trace that the profile is achieved.

67
The Careful Profilecntd.

• Writing a cycle theory that ensures every other
  transition is SR
• Add to Tbasic
• r T SR (S',) SR (S', ) T(S,X,S't)
• for any T different from SR.
• Romove from Tbasic any rule that speaks of 2
  consecutive transitions both of which are
  different from SR.

68
The Careful Profilecntd.

• Looking at the trace of a careful agent
  T1(S0,X1,S1,t1),.,Ti(Si-1,Xi,Si,ti),
  Ti1(Si,Xi1,Si1,ti1),
• it will never be the case that
• For example
• If Ti is AE then, Xi,the set of actions to be
  executed, contains an action which has an
  ancestor that already holds.
• If Ti is RE then, the reaction is to a goal or an
  action which has an ancestor that already holds
  or is timed out.

69
Other profiles (in SOCS deliverables)

• Impatient
• Attempts an action a pre-specified number of
  times, and if it does not succeed it gives up.
• Cautious
• Before executing an action always checks the
  preconditions in its KB.
• Actively cautious
• Before executing an action always checks the
  preconditions in its KB, and if unknown senses
  the environment for them.
• Objective
• Immediately after executing actions it checks if
  the actions have succeeded.
• Punctual

70
Computational counterpart of the KGP model

• Computational counterpart exploits the modularity
  of the model
• Computational counterpart
• an abductive proof procedure (CIFF) for the
  components of the model based on abductive LP
• an argumentation-based proof procedure (Gorgias)
  for the components of the model based on LP with
  priorities

71
Modularity

• We can put together the components modularly. In
  the future we could add, for example
• A learning capability
• A belief revision capability

72
Formal Properties and Verification

• KGP declarative and computational models,
  including control component are formal and
  logic-based
• Facilitates formal specification and verification
  of properties

73
Some Formal Properties

• Coherence, e.g.
• agents never attempt to execute incompatible
  actions concurrently
• agents never waste time on solving goals that are
  descendents/siblings of other timed-out goals
• So, at least KGP agents do not do anything that
  is obviously useless!

74
Some Formal Propertiescntd.

• Effectiveness in goal achievement
• Progress towards achieving goals
• Various notions of preference between states,
  State2gtgtState1, and proofs of how the KGP
  transitions can lead to more preferred states.
• Reactive awareness
• Agents with fair control always reach a state in
  which they are fully aware of all necessary
  reactions.

75
More InformationSOCS Home

• http//lia.deis.unibo.it/research/socs/
• Includes deliverables with many details of
  design, implementation, properties and
  experimentation

76
More Information KGP

• A. Kakas, P. Mancarella, F. Sadri, K. Stathis, F.
  Toni, The KGP model of agency, ECAI04, General
  European Conference on Artificial Intelligence,
  August 23-27, 2004, Valencia, Spain, pp 33-37
• A. Bracciali, N. Demetriou, U. Endriss, A. Kakas,
  W. Lu, P. Mancarella, F. Sadri, K. Stathis, G.
  Terreni, F. Toni, A. Bracciali, N. Demetriou, U.
  Endriss, A. Kakas, W. Lu, P. Mancarella, F.
  Sadri, K. Stathis, G. Terreni, F. Toni, The KGP
  Model of Agency for Global Computing
  Computational Model and Prototype Implementation,
  Global Computing 2004 Workshop, Springer Verlag
  LNCS 3267, 2005, p. 342 (to appear), Global
  Computing 2004 Workshop, Springer Verlag LNCS
  3267, 2005, p. 342

77
More Information Cycle theories, Analysis

• A.C. Kakas, P.Mancarella, F.Sadri, K.Stathis, and
  F.Toni, Declarative agent control, 5th Workshop
  on Computational Logic in Multi-Agent
  Systems(CLIMA V), 29-30 September 2004, J.Leite
  and P.Torroni,eds
• Fariba Sadri and Francesca Toni,
• Profiles of behaviour for logic-based agents,
  CLIMA05
• F. Sadri, F. Toni,A formal analysis of KGP
  agents,Jelia 2006.

78
More InformationPROSOCS

• Kostas Stathis, Antonis C. Kakas, Wenjin Lu,
  Neophytos Demetriou, Ulle Endriss, and Andrea
  Bracciali. PROSOCS a platform for programming
  software agents in computational logic. In
  J. Müller and P. Petta, editors, Proceedings of
  the Fourth International Symposium From Agent
  Theory to Agent Implementation'' (AT2AI-4 -
  EMCSR'2004 Session M), pages 523-528, Vienna,
  Austria, April 13-16" 2004.
• Andrea Bracciali, Neophytos Demetriou, Ulle
  Endriss, Antonis Kakas, Wenjin Lu, and Kostas
  Stathis. Crafting the Mind of a PROSOCS Agent.
  Applied Artificial Intelligence, 2005. To
  appear.

79
More InformationPlanning, Proof Procedures

• P.Mancarella, F.Sadri, G.Terreni, and F.Toni,
• Planning partially for situated agents,
• 5th Workshop on Computational Logic in
  Multi-Agent Systems (CLIMA V), 29-30 September
  2004, J.Leite and P.Torroni, eds
• U. Endriss, P. Mancarella, F. Sadri, G. Terreni,
  F. Toni, The CIFF proof procedure for abductive
  logic programming with constraints, JELIA'2004,
  International Conference on Logics in AI, Lisbon,
  Portugal, September 2004, Springer Verlag LNAI

80
Extending the KGP with Normative Concepts

• A reference
• F. Sadri, K. Stathis, F. Toni,
• Normative KGP Agents, Journal of Computational
  and mathematical Organization Theory, 2006.

81
Extending the KGP with Normative Concepts

• Objectives
• Simple deontic theory in terms of obligations and
  prohibitions and permission
• Integration with the existing model and
  functionalities
• Allowing provable conformance of agents to the
  theory
• More generally, allowing agents to prioritise
  between their private and social goals and
  actions.
• Scenario artificial society relying on
  organisation and division of tasks

82
Approach

• Responsibility defined in terms of Roles.
• Roles associated with
• Obligations
• permissions
• prohibitions

83
Approach (cntd.)

• Adapting the event calculus used for planning and
  reactivity
• Reactivity
• Makes agents aware of their obligations and
  prohibitions depending on their observations
• Forces them to conform to their obligations and
  prohibitions
• Planning
• Allows agents to plan activities to conform to
  their obligations and prohibitions

84
Roles

• role(Agent, Role)
• Roles are initiated and terminated by actions of
  (authorised) agents
• initiates(assign(Y,X,traffic_warden(Area, Ts,
  Te)), T,
  role(X, traffic_warden(Area, Ts,
  Te))) ?
• authorised(act(assign(Y,X,traffic_warden(Area,Ts,T
  e),Y)),T).

85
Obligations

• obliged(act(ACT, Actor), T, TCs)
• obliged(fluent(Fluent, Actor), T, TCs)
• Obligations held by agents are generated by means
  of reactive rules in KBreact.

86
Obligations Reactive Rule specification

• holds_at(role(Actor, Role),T) Conditions(Actor,
  T) ?
• obliged(act(ACT, Actor),T,TCs).
• holds_at(role(Actor, Role),T) Conditions(Actor,
  T) ?
• obliged(fluent(Fluent, Actor),T,TCs).

87
Obligations Examples

• holds_at(role(X, traffic_warden(Area, STime,
  ETime)),T) observed(parked(Car,Area),T)
  STimeltTltETime ?
• obliged(act(issue_fine(Car),X), T, T T1)
• holds_at(role(X, owner(Car)),T)
  observed(issue_fine(Car),T) ?
• obliged(act(pay_fine(Car),X), T, T T5)

88
Prohibitions

• prohibited(act(ACT, Actor), T, TCs)
• prohibited(fluent(Fluent, Actor), T, TCs)
• Specification similar to obligations
• holds_at(role(Actor, Role),T) and
• Conditions(Actor, T) ?
• prohibited(act(ACT, Actor), T, TCs).
• Similarly for fluents.

89
Prohibitions Example

• holds_at(role(X, traffic_warden(Area,STime,
  ETime)),T) STimeltTltETime ?
• prohibited(act(leave(Area),X),T,T T)

90
Obligations and Agent Personalities

• Different agents can interpret obligations
  differently.
• Responsible agents will try to fulfil their
  obligations.

91
Obligations and Responsible Agents

• holds_at(responsible(Actor), T)
• obliged(act(ACT, Actor), T, TCs) ?
• happens(Act(Actor),T) TCs
• holds_at(responsible(Actor), T)
• obliged(fluent(Fluent, Actor), T, TCs)
  ?holds_at(Fluent(Actor),T) TCs

92
Prohibitions and Responsible Agents

• holds_at(responsible(Actor), T)
• prohibited(act(ACT, Actor), T, TCs)
• happens(Act(Actor),T) TCs ? false
• holds_at(responsible(Actor), T)
• prohibited(fluent(Fluent, Actor), T, TCs)
• holds_at(Fluent(Actor),T) and TCs ? false

93
Informal example of integration in KGP

• a1 Responsible Traffic Warden Agent for Chelsea
  from time 9 to 17, with reactive rules
• holds_at(role(X, traffic_warden(Area, STime,
  ETime)),T) observed(parked(Car,Area),T)
  STimeltTltETime ?
• obliged(act(issue_fine(Car),X), T, T T1)
• holds_at(responsible(Actor), T) and
• obliged(act(ACT, Actor), T, TCs) ?
• happens(Act(Actor),T) and TCs

94
Informal example of integration in KGP cntd.

• a1
• POI records observed(parked(w1,chelsea),10)
• RE triggers the reactive rule
• holds_at(role(X, traffic_warden(Area, STime,
  ETime)),T) observed(parked(Car,Area),T)
  STimeltTltETime ? obliged(act(issue_fine(Car),X),
  T, T T1)
• Generates
• obliged(act(issue_fine(w1), a1), T, T11)

95
Informal example of integration in KGP cntd.

• obliged(act(issue_fine(w1), a1), T, T11)
• in turn triggers
• holds_at(responsible(Actor), T)
• obliged(act(ACT, Actor), T, TCs) ?
• happens(Act(Actor),T) TCs
• and generates
• happens(issue_fine(a1,w1), T) T11.
• AE schedules this action for execution and
  executes it at time 11.

96
Informal example of integration in KGP cntd.

• If the obligation was to bring about a fluent
• obliged(fluent(report_filed(w1), a1),T,T11)
• RE will generate a goal
• holds_at(report_filed(w1,a1), T) T11
• PI will generate a (partial) plan for the goal
• AE starts executing the actions in that plan.

97
Further extension

• Obligations and prohibitions may be incompatible
  with the agents private goals and actions.
• So the KGP is modified
• Internal state of the agent is modified
• lt KB0, F, C, ? gt
• F is divideded into two parts
• Fs representing tree of all goals and actions
  resulting from obligations or prohibitions
• Fp representing tree of all other goals and
  actions

98
Further extension

• A new knowledge base is added that specifies the
  agents priorities allowing them to choose
  between incompatible social/private goals and
  actions.
• The state is always revised before any planning
  or action execution steps by removing all
  incompatibilities according to the agents
  priorities.

99
Conclusions of KGP Extension

• Study of how to incorporate normative concepts
  within the KGP model of agency
• Agents can reason about their obligations and
  prohibitions and integrate them with their
  activities
• Normative concepts can be communicated by one
  agent to another
• Suitable for building multi-agent system
  applications

100
Related Work

• SOCS-SI expectations
• IMPACT share abductive approach but they focus
  on legacy systems.
• Artikis et al birds eye view vs single agent
  view based on formal model.
• BOID focus on internal conflict and priorities
  rather than integration with plans and reactivity.