Risultati finali
In this work, we extend the architecture of agents based upon fixed, one-size-fits-all cycles of operation, by providing a framework of declarative specification of agents control.
Control is given in terms of cycle theories, which define in a declarative way the possible alternative behaviours of agents depending on the particular circumstances of the (perceived) external environment in which they are situated and of the internal state of the agents at the time of operation.
We also show how, via cycle theories, we can characterise agents with heterogeneous patterns of behaviour and formally verify properties of their behaviour.
A proof procedure for Logic programming with Priorities (specifically in the framework of LPwNF) and its integration with abduction has been studied and implemented in a met interpreter, called GORGIAS, for argumentative deliberation.
GORGIAS is a general system for argumentation in that combines preference reasoning and abduction.
It can form the basis for reasoning about adaptable preference policies in the face of incomplete information from dynamic and evolving environments.
Gorgias has been ported to work both with SICSTUS and SWI-Prolog. It has been tested with examples from various domains like legal reasoning, inheritance theory, and autonomous agent deliberation. The experiments have shown the flexibility of the system, and its ability to be specialized to additional or changing needs.
In particular, GORGIAS is the basis on which the cycle theories of KGP computess are implemented.
As such it is one of the basis frameworks and systems on which the PROSOCS platform is build.
A suite of different behaviour profiles for computes is defined and studied with respect to their suitability under different conditions of the environment in which the computes operate.
The aim is then to identify a correspondence between profiles of computes and application domains for which the operation of the computes will be more successful.
PROSOCS is a platform that allows a developer to build computational logic agents interacting in a global computing environment.
PROSOCS results from the integration of two main components: SOCS-iC - which allows the programming of agents as intelligent computes, and SOCS-SI - which is a social infrastructure that allows social interactions to be verified.
Agents programmed using SOCS-iC can be deployed in a network using PROSOCS and be discovered dynamically by other PROSOCS agents, while their interactions can be verified and tested for conformance, according to rules that the developer can specify in SOCS-SI.
PROSOCS offers a number of advantages in the building of a global computing application. The logic-based development of PROSOCS agents makes the resulting application more transparent, and as a result, closer to the people who will use it. In addition, the social infrastructure of PROSOCS can test for unwanted interactions, according to formally specified rules.
The transparent and socially aware features, combined with the dynamic discovery of agents, gives PROSOCS an enormous potential for a range of applications, ranging from building flexible and smart services over ad-hoc networks (or the web) to more demanding applications such as those exemplified by ambient intelligence.
All the components of the current PROSOCS prototype have been developed using Prolog - to program the functionality of the mind and the proof-procedures that support individual and social reasoning, Java - to program the functionality of the body and the user interfaces, and the Peer-to-Peer system JXTA - to provide the functionality required for instances of components developed in SOCS-iC and SOCS-SI, to communicate and interact in an open distributed environment.
This work has developed a framework for temporal reasoning of an agent allowing it to draw conclusions about properties of its world from known events and observations, as it perceives them.
This framework is based on an extended version of the Abductive Event Calculus drawn from the Language E. A computational model for this is developed based on the standard computational model of abduction in Abductive Logic Programming and can be implemented by any sound and complete proof procedure for ALP theories.
SOCS-iC is a generic software component that suports the programming of intelligent software agents (computees) that have a "mind" and a "body".
The mind reasons autonomously and logically via a collection of logic theories with generic functionality, developed using various extensions of logic programming.
These theories are interpreted through formal proof-procedures and allow the agent to reason autonomously and select goals and actions according to the agent's knowledge, policies, and the current external environment in which the agent finds itself. The overall behaviour of the agent is controlled via a "cycle theory" that specifies preferred patterns of operation.
The body provides sensors and effectors for the mind to be able to access and change the environment in which the agent is situated. In this context, SOCS-iC relies upon the existence of a set of primitives for accessing the environment.
gSCIFF is a proof procedure, extension of the SCIFF abductive proof procedure, which is able to generate a history that is compliant to a given protocol and achieves a given goal, i.e., the description of an agent interaction which respects a given specification.
The main intended use for gSCIFF is the proof of protocol properties. Properties of a protocol can be divided into two categories: existential properties (which hold for at least one history compliant to the protocol) and universal properties (which hold for all histories compliant to the protocol).
Assuming results of soundness and completeness for gSCIFF, it is possible to prove both existential properties (by expressing them as gSCIFF goals) and universal properties (by expressing their negation as gSCIFF goals).
The ability to prove protocol properties makes gSCIFF a valuable tool for protocol engineering, letting the designer check if the protocol being designed exhibits desirable properties. For example, it is possible to check the well-definedness of a protocol (i.e., the existence of a history that is compliant to the protocol) by checking with gSCIFF if 'true' is an existential property of the protocol.
So far, a soundness result has been proved for gSCIFF, while completeness is still open. This makes gSCIFF suitable for proving existential properties and refuting universal properties, but not yet for refuting existential properties or proving universal properties.
The design and implementation of the PROSOCS platform has been extended in order to allow the introduction of objects in the platform. A new component, which we call the object template, is introduced to allow instances of PROSOCS objects to be created, so that agents can interact with objects, or objects can interact between them.
To accommodate this, we have rationalised the communication component in the old version of the reference model with what we call the interaction component in the new version. This component is essentially a component that allows us to enable interaction between agents and objects (or between objects), and communicative interactions in terms of exchanges of different types of messages. In other words, we assume that we can translate interaction into some form of (low-level) communication via message passing.
Finally, we have rationalised the agent management component in the old version, with an environment component in the new version, which keeps a record of the existence of agents and objects, as well as allow an agent to perform physical actions on objects or other agents.
The formal, logic-based model for a society of agents (named computes) focuses on the interactions among computes, and leads to the definition of a Computational Logic-based architecture for compute interactions.
In particular, a layered architecture has been proposed, where the society defines the allowed interaction protocols, which determine the socially allowed compute interaction patterns. The semantics of protocols and of the Agent Communication Language (ACL) are defined in a uniform way by means of Social Integrity Constraints.
The main advantages of this formal approach are in the design of societies of computes, in the possibility to detect undesirable behaviour, and in the possibility to formally reason upon the specifications of such a framework, and to understand its own limits and potential.
The KGP model for agency provides a highly 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.
KGP is motivated, on the one hand, by the existing gap between modal logic specifications of BDI agents and their implementation and, on the other, to make available and extend many useful computational logic tools and techniques whose synthesis can produce executable specifications of agents. The model synthesises Abductive Logic Programming and Logic Programming with Priorities, both extended to deal with constraint solving as in Constraint Logic Programming.
Computational Logic is used in KGP to specify the individual state of the agent, its reasoning capabilities, state transitions, and its control. Using these components, an agent maintains a view of the environment, decides what its goals should be, depending on the current circumstances, plans (incrementally) for these chosen goals and interleaves this with incremental execution of the plan, reacts to information received from the environment or communication received from other agents, re-evaluates previous decisions in the light of the new information and adapts as necessary by changing or augmenting its goals and plan. The control component of this complex behaviour is regulated by a cycle theory, which also allows us to design agents with a wide range of heterogeneous behaviour suitable for different practical applications.
This result (SOCS-SI, SOCS Social Infrastructure) is a Java-Prolog software component which can be used to verify compliance of agent interaction to protocols written in a logic-based formalism (Social Integrity Constraints).
In open societies of agents, where agents are autonomous and heterogeneous, it is not realistic to assume that agents will always act so as to comply to interaction protocols. Thus, the need for a social infrastructure like this arises for being able to observe and check for agent compliance to interaction protocols.
SOCS-SI implements the SCIFF proof procedure (result 14298 of this project) by exploiting the Constraint Handling Rules library of SICStus Prolog and equip it with a Java-based user interface for loading protocol specifications, interacting with the environment by receiving socially relevant events generated by society members and also capable of showing generated expectations, their fulfilment or violation.
The SOCS-SI software application is composed by a set of modules. All the components except one (the SCIFF proof-procedure) are implemented in the Java language.
The core of SOCS-SI is composed by three main modules, namely:
- Event Recorder: fetches events from different sources and stores them inside the History Manager.
- History Manager: receives events from the Event Recorder and composes them into an event history.
- Social Compliance Verifier: fetches events from the History Manager and passes them to the CHR implementation of the SCIFF proof-procedure in order to check the compliance of the history to the specification.
In our model, agents communicate by exchanging messages, which are then translated into events. The Event Recorder fetches events and records them into the History Manager, where they become available to the proof procedure. As soon as the proof procedure is ready to process a new event, it fetches one from the History Manager.
The event is processed and the results of the computation are returned to the GUI. The proof-procedure then continues its computation by fetching another event if there is any available, otherwise it suspends, waiting for new events. A fourth module, named Init&Control Module provides for initialisation of all the components in the proper order. It receives as initial input a defined by the user, which will be used by the CHR implementation of the SCIFF proof-procedure in order to check the compliance of agents to the protocol specification.
For the implementation of the SCIFF proof procedure, SICStus Prolog has been chosen, for the following reasons:
- The Prolog language offers built-in facilities for the implementation of dynamic data structures and (customizable) search strategies;
- SICStus Prolog allows for state-of-the-art CLP; in particular, the CLPB, CLPFD and
CHR libraries have been exploited;
- SICStus Prolog features a bidirectional Java- Prolog interface (Jasper), which has been necessary to interface the proof-procedure with the other modules of the social demonstrator.
As the IFF proof-procedure, SCIFF specifies the proof tree, leaving the search strategy to be defined at implementation level. The implementation is based on a depth-first strategy. This choice, enabling us to tailor the implementation for the built-in computational features of Prolog, allows for a simple and efficient implementation of the proof. The Prolog-CHR module implements the transitions of the proof procedure. CHR is a rewriting system for implementing new constraints. It is based on forward rules that rewrite constraints into other constraints. By implementing the data structures of the SCIFF proof procedure as CHR constraints, SCIFF transitions can be implemented as CHR rules.
The result is the definition of a set of Interaction Protocols (library). For each protocol a description in natural language is given. The protocols are expressed using the logic-based formalism SIC (Social Integrity Constraint) defined in the project result n.14299. Each protocol definition is composed of at least two files: a first file contains the "protocol rules", while a second file contains the knowledge base related to the specific protocol.
For each protocol a set of interaction examples is given, equipped with explanations and with the results obtained by verifying the conformance of such examples to the protocol specification. Such conformance verification has been done using SOCS-SI, a tool defined in the project result n. 14352.
The library contains several different protocols: amongst them it is worthy to mention the description of several auction protocols (English, First Price Sealed Bid, Combinatorial and some variation of Combinatorial Auction), as well as some standard protocols defined by the FIPA consortium. Besides protocols for interaction between intelligent agents, also some protocols for interaction between peers have been defined and tested: just to mention, the Needham-Schroeder Public Key Protocol is specified, along with the specification of the opening phase of the TCP/IP protocol. Finally, the library contains also the description of a protocol for medical guidelines and interaction rules between peers involved in treatment of medical patients.
This result is available as a set of documents along with the SOCS-SI (result n. 14352), as well as a stand-alone library accessible via a web server, at the url http://www.lia.deis.unibo.it/Research/Projects/SOCS/partners/societies/protocols.html
SCIFF represents the operational support, as a proof system based on transitions, for the society model developed within the SOCS project. SCIFF is an abductive proof procedure ispired by the IFF proof procedure by Fung and Kowalsk. In particular, SCIFF is able to check the compliance to the protocols specified at society level of (agents') interactions. Such protocols are expressed as integrity constraints relating socially relevant events to expected behaviour of members.
The main application SCIFF was developed for is to verify (on-the-fly) the compliance of agents to interaction protocols. In order to allow such application, SCIFF extends IFF in several respects:
- Abducibles represent hypotheses about agent behaviour;
- SCIFF deals with the concept of fulfilment, i.e., the correspondence of abduced atoms with events recorded in a history
- CLP constraints can be imposed over variables;
- SCIFF deals with existentially quantified variables in integrity constraints.
SCIFF is being developed at Dipartimento di Ingegneria, University of Ferrara and at DEIS, University of Bologna, and it has been proved sound with respect to a declarative, 3-valued abductive semantics. Moreover some syntactical conditions on Social Integrity Constraints have been introduced in order to guarantee SCIFF termination.
CIFF is a novel extension of Fung and Kowalski's IFF abductive proof procedure, dealing with constraint predicates and dealing with non-allowed abductive logic programs.
We have applied CIFF to realise intelligent agents that can construct (partial or complete) plans and react to changes in the environment. We have implemented CIFF in Sicstus Prolog.
È in corso la ricerca di dati su OpenAIRE...
Si è verificato un errore durante la ricerca dei dati su OpenAIRE
Nessun risultato disponibile