Viene descritto l’utilizzo della logica computazionale a supporto della formalizzazione ed implementazione di agenti in sistemi multi-agente. In questo ambito e` necessario l’uso di varie forme di logica computazionale, tra le quali abduzione, argomentazione e sistemi basati su preferenze. Viene presentato a grandi linee il modello per agenti denominato KGP, nonche´ una sua estensione in corso di definizione per la modellazione di agenti in ambienti distribuiti quali il Grid e piu` in generale architetture service-oriented We describe recent work on the deployment of computational logic to support the formalisation and implementation of agents in multi-agent systems. Several forms of computational logic systems are needed in this setting, including abductive, argumentative and preference-based systems. We briefly sketch the agent model called KGP, and an ongoing extension of it which is needed to model agents in distributed settings such as the Grid and, more generally, Service-oriented architectures. 1
Computational Logic (CL) has been successfully adopted, in recent years, in modelling agents within agent based systems. The adoption of CL techniques has the advantage that formal specifications come along with their computational counterparts in the form of provably correct and executable proof procedures. The formal and computational models needed in the agent based settings require an integrated treatment of different features, which can be handled within various extensions of the basic logic programming framework, including abduction, argumentation and constraint logic programming. In this short paper we briefly summarize one such approach which has lead to the defnition of the KGP model for agency, and which is being further developed to cope with the specification of agents in service-oriented applications. 2
KGP is an acronym for Knowledge, Goals and Plan. The
model is intended to provide a modular and hierarchical
specification of agents equipped with a variety of advanced
reasoning features to allow intelligent decision making and
behaviour. KGP agents are particularly suited to open
dynamic environments where they have to adapt to changes
in their environment and they have to function in
circumstances where they have incomplete information. Here we
give an overview of the KGP agent model and its
components [
This is a tuple hKB0, F , C, Σi, where: • KB0 holds the (dynamic) beliefs of the agent about the external world in which it is situated, as well as a record of the actions it has already executed. • F is a forest of trees whose nodes are goals, which may be executable or not. Each tree in the forest gives a hierachical presentation of goals, in that the tree represents the construction of a plan for the root of the tree. The set of leaves of any tree in F forms a currently chosen plan for achieving the root of the tree. Executable goals are actions which may be physical, communicative, or sensing. Non-executable goals may be mental or sensing. Only non-executable mental goals may have children, forming (partial) plans for them. Actions have no children in any trees in F . The roots of trees in F are referred to as top-level goals , the executable goals are referred to as actions, and non-executable goals which are not top-level goals are referred to as sub-goals . Toplevel goals are classified as reactive or non-reactive . Roughly speaking, reactive goals are generated in response to observations, e.g. communications received from other agents and changes in the environment, for example to repair plans that have already been generated. Non-reactive goals, on the other hand, are the chosen desires of the agent. Note that some top-level (reactive) goals may be actions. • C is the Temporal Constraint Store, namely a set of constraint atoms in some given underlying constraint language. These basically constrain the time variables of the goals in F . For example, they may specify a time window over which the time of an action can be instantiated, at execution time. • Σ is a set of equalities instantiating time variables with time constants. For example, when the time variables of actions are instantiated at action execution time, records of the instantiations are kept in Σ.
These are: strained sub-goals and actions designed for achieving the input goals. • Reactivity, which is used to provide new reactive toplevel goals, as a reaction to perceived changes in the environment and the current plans held by the agent. • Goal Decision, which is used to revise the nonreactive top-level goals, adapting the agent’s state to changes in its own preferences and in the environment. • Identification of Preconditions and Identification of Effects for actions, which are used to determine appropriate sensing actions for checking whether actions may be safely executed (if their preconditions are known to hold) and whether recently executed actions have been successful (by checking that some of their known effects hold). • Temporal Reasoning, which allows the agent to reason about the evolving environment, and to make predictions about properties, including non-executable goals, holding in the environment, based on the (partial) information the agent acquires over its life-time. • Constraint Solving, which allows the agent to reason about the satisfiability of the temporal constraints in C and Σ.
In the concrete realisation of the KGP model, we have chosen to realise the above capabilities in various extensions of the logic programming paradigm. In particular, we use (conventional) logic programming for Identification of Preconditions and Effects, abductive logic programming with constraints for Planning, Reactivity and Temporal Reasoning, and logic programming with priorities for Goal Decision.
Physical capabilities. In addition to the reasoning capabilities, the agent is equipped with “physical” capabilities, linking the agent to its environment, consisting of • A Sensing capability, allowing the agent to observe that properties hold or do not hold, and that other agents have executed actions. • An Actuating capability, for executing (physical and communicative) actions.
Transitions. The state hKB0, F , C, Σi of an agent evolves by applying transition rules, which employ the capabilities as follows: • Goal Introduction (GI), possibly changing the toplevel goals in F , and using Goal Decision. • Planning, which generates plans for mental goals given as input. These plans consist of temporally con• Plan Introduction (PI), possibly changing F and C and using Planning. • Reactivity (RE), possibly changing the reactive toplevel goals in F and possibly C, and using the Reactivity capability. • Sensing Introduction (SI), possibly introducing new sensing actions in F for checking the preconditions of actions already in F . • Passive Observation Introduction (POI), changing KB0 by recording unsolicited information coming from the environment, and using Sensing. • Active Observation Introduction (AOI), possibly changing Σ and KB0, by recording the outcome of (actively sought) sensing actions, and using Sensing. • Action Execution (AE), executing all types of actions and as a consequence changing KB0 and Σ, and using Actuating. • State Revision (SR), possibly revising F , and using
Temporal Reasoning and Constraint Solving.
Cycle and Selection operators. The behaviour of an agent is given by the application of transitions in sequences, repeatedly changing the state of the agent. These sequences are not determined by fixed cycles of behaviour, as in conventional agent architectures, but rather by reasoning with cycle theories. Cycle theories define preference policies over the order of application of transitions, which may depend on the environment and the internal state of an agent. They rely upon the use of selection operators for detecting which transitions are enabled and what their inputs should be, as follows: −action selection for inputs to AE; this selection operator uses the Temporal Reasoning and Constraint Solving capabilities; − goal selection for inputs to PI; this selection operator uses the Temporal Reasoning and Constraint Solving capabilities; − effect selection for inputs to AOI; this selection operator uses the Identification of Effect reasoning capability; − precondition selection for inputs to SI; this selection operator uses the Identification of Preconditions, Temporal Reasoning and Constraint Solving capabilities. The provision of a declarative control for agents in the form of cycle theories is a highly novel feature of the model, which could, in principle, be imported into other agent systems. In the concrete realisation of the KGP model, we have chosen to realise cycle theories in the same framework of logic programming with priorities and constraints that we also use for Goal Decision. 2.1
One central distinguishing feature of the KGP model, in
comparison with other models for agency, including those
based on logic programming, is its modular integration
within a single framework of abductive logic
programming, temporal reasoning, constraint logic programming,
and preference reasoning based on argumentation in order
to support a diverse collection of capabilities. Each one of
these is specified declaratively and equipped with its own
provably correct computational counterpart. These
computational models are heavily based upon proof procedures
for (various extensions of) logic programming. In
particular, the operational model for KGP agents relies upon CIFF
[
The use of agent technology offers a solution to dynamic
service composition in distributed settings such as the Grid
and more generally Service-Oriented Architectures.
Different services can be associated with autonomous agents
that can identify and negotiate, on behalf of service
requestors and providers, implementation plans that take into
account the requirements of both sides. The ARGUGRID
project1 aims at defining and deploying
argumentationbased agents to support the selection and composition of
services over the Grid and Service-Oriented Architectures
[
Here, the consulting capability is intended for accessing
information in registries. The reasoning capabilities
correspond to the IDM (individual decision-making), SDM
(social decision making), and SI (social interaction) modules
in [
We have briefly described work carried out in recent years and still ongoing, which aims at adopting computational logic for the description of agents in agent based systems. The use of computational logic allows us, on one hand to partially fill the gap between agent models and their computational realization. Indeed, the specification of KGP agent is a sort of executable specification due to the fact that the computational logic tools adopted in this setting are equipped with suitable concrete proof procedures. On teh other hand, the modularity of the KGP model allows one to extend it naturally to support new forms of reasoning, such as the ones needed in order to model the type of agents needed in service-oriented applications. Again, computational logic tools, based on various forms of argumentation, can be adopted in these settings to support the new type of capabilities needed, such as decision making and negotiation. This is still ongoing work we are carrying out within the ARGUGRID project.