Anna Ciampolini

Cooperation and Competition in ALIAS: A Logic Framework for Agents that Negotiate

This paper presents ALIAS, an agent architecture based on intelligent logic agents, where the main form of agent reasoning is abduction. The system is particularly suited for solving problems where knowledge is incomplete, where agents may need to make reasonable hypotheses about the problem domain and other agents, and where the raised hypotheses have to be consistent for the overall set of agents. ALIAS agents are pro-active, exhibiting a goal-directed behavior, and autonomous, since each one can solve problems using its own private knowledge base. ALIAS agents are also social, because they are able to interact with other agents, in order to cooperatively solve problems. The coordination mechanisms are modeled by means of LAILA, a logic-based language which allows to express intra-agent reasoning and inter-agent coordination. As an application, we show how LAILA can be used to implement inter-agent dialogues, e.g., for negotiation. In particular, LAILA is well-suited to coordinate the process of negotiation aimed at exchanging resources between agents, thus allowing them to execute the plans to achieve their goals.

A social ACL semantics by deontic constraints

In most proposals for multi-agent systems, an Agent Communication Language (ACL) is the formalism designed to express knowledge exchange among agents. However, a universally accepted standard for ACLs is still missing. Among the different approaches to the definition of ACL semantics, the social approach seems the most appropriate to express semantics of communication in open societies of autonomous and heterogeneous agents. In this paper we propose a formalism (deontic constraints) to express social ACL semantics, which can be grounded on a computational logic framework, thus allowing automatic verification of compliance by means of appropriate proof procedures. We also show how several common communication performatives can be defined by means of deontic constraints.

LAILA: a language for coordinating abductive reasoning among logic agents

The last decade has seen the advent of the agent paradigm as a reference model in several fields of research, mainly but not limited to artificial intelligence and distributed systems. In open and distributed environments, where most facts are not known at all, the agent metaphor proves particularly useful if agents are able to autonomously perform some form of reasoning, possibly obviating knowledge incompleteness by means of hypotheses assumed on the unknown facts. A suitable mechanism to deal with incomplete and multiple knowledge is abductive reasoning. The aim of this paper is to describe LAILA, a language that can be used by logic-based agents capable of abductive reasoning, by enabling them to express at a high level several ways to join and coordinate with one another. In particular, we considered collaboration and competition as possible interaction patterns in the abductive reasoning that must be carried out by multiple agents. Syntax and operational semantics of the LAILA language are given along with a clarifying example; a section is also devoted to a brief description of the current LAILA implementation.

An hybrid architecture integrating forward rules with fuzzy ontological reasoning

In recent years there has been a growing interest in the combination of rules and ontologies Notably, many works have focused on the theoretical aspects of such integration, sometimes leading to concrete solutions However, solutions proposed so far typically reason upon crisp concepts, while concrete domains require also fuzzy expressiveness. In this work we combine mature technologies, namely the Drools business rule management system, the Pellet OWL Reasoner and the FuzzyDL system, to provide a unified framework for supporting fuzzy reasoning After extending the Drools framework (language and engine) to support uncertainty reasoning upon rules, we have integrated it with custom operators that (i) exploit Pellet to perform ontological reasoning, and (ii) exploit FuzzyDL to support fuzzy ontological reasoning. As a case study, we consider a decision-support system for the tourism domain, where ontologies are used to formally describe package tours, and rules are exploited to evaluate the consistency of such packages.

An Implementation for Abductive Logic Agents

This paper presents the distributed implementation of ALIAS, an architecture composed of several cooperating intelligent agents. This system is particularly suited to solve problems in cases where knowledge about the problem domain is incomplete and agents may need to form reasonable hypotheses. In ALIAS agents are equipped with hypothetical reasoning capabilities, performed by means of abduction: if the knowledge available to a logic agent is insufficient to solve a query, the agent could abduce new hypotheses. Each agent is characterized by a local knowledge base represented by an abductive logic program. Agents might differ in their knowledge bases, but must agree on assumed hypotheses. That global knowledge base is dynamically created and managed by means of a shared tuple space. The prototype, developed using Java and Prolog, can run on a TCP/IP network of computers. In the paper, we also discuss some experimental results to evaluate prototype efficiency.

Abductive coordination for logic agents

In this work, we introduce abduction in a (logic) multi-agent environment to achieve a basic coordination scheme among agents. In particular, we define and implement a distributed protocol to coordinate the reasoning of agents. Each agent performs hypothetical reasoning, achieved by means of abduction. To this purpose, each agent is character&d by a knowledge base represented by an abductive logic program. Agents coordinate themselves on the basis of knowledge represented by hypotheses posted into a tuple space. Agents might differ in their knowledge bases, but must agree on BS sumed hypotheses. We define a coordination protocol and tailor it for a basic abductive proof procedure. We also sketch an implementation, under development, obtained by using Java and SICStus Prolog.

The support for a dynamic parallel object model on a transputer-based architecture

It is shown how a parallel object model can be used as a support environment for massively parallel architectures based on transputer technology. The intention is to verify that parallelism integrates well with such properties of the object paradigm as abstraction, uniformity, and dynamicity. The authors also present the guidelines to build prototypes by an approach based on primitives. In particular, the implemented primitives make possible the creation and communication of objects for a massively parallel architecture. Finally, trends in future work-static and dynamic allocation, replication and persistency of objects-are outlined.<<ETX>>

The implementation of a distributed model for logic programming based on multiple-headed clauses

Abstract We present the the distributed implementation of a new communication model for concurrent logic programming. Tha main novelty with respect to STREAM-parallel logic languages is that inter-process communication is performed via multiple-headed clauses, rather that by variables shared among AND processes. We describe an abstract machine for the model which extend the Warren Abstract Machine.

Parallel object system support on transputer-based architectures

The paper describes a possible support to a parallel object model, called PO for a massively parrallel architecture. PO has been chosen as an example because of the degree of parallelism it introduces. The paper stresses the constraints that affect the support because of occam staticity. The PO support has been implemented in occam for an architecture based on several Transputers.

Distributed Compliance Monitoring of Business Processes over MapReduce Architectures

In the era of IoT, large volumes of event data from different sources are collected in the form of streams. As these logs need to be online processed to extract further knowledge about the underlying business process, it is becoming more and more important to give support to run-time monitoring. In particular, increasing attention has been turned to conformance checking as a way to identify when a sequence of events deviates from the expected behavior. Albeit rather straightforward on a small log file, conformance verification techniques may show poor performance when dealing with big data, making increasingly attractive the possibility to improve scalability through distributed computation. In this paper, we adopt a previously implemented framework for compliance verification (which provides a high-level logic-based notation for the monitoring specification) and we show how it can be efficiently distributed on a set of computing nodes to support scalable run-time monitoring when dealing with large volumes of event logs.