Fariba Sadri

Ambient intelligence: A survey

In this article we survey ambient intelligence (AmI), including its applications, some of the technologies it uses, and its social and ethical implications. The applications include AmI at home, care of the elderly, healthcare, commerce, and business, recommender systems, museums and tourist scenarios, and group decision making. Among technologies, we focus on ambient data management and artificial intelligence; for example planning, learning, event-condition-action rules, temporal reasoning, and agent-oriented technologies. The survey is not intended to be exhaustive, but to convey a broad range of applications, technologies, and technical, social, and ethical challenges.

Computational Logic: Logic Programming and Beyond

In this paper we describe a distributed object oriented logic programming language in which an object is a collection of threads deductively accessing and updating a shared logic program. The key features of the language, such as static and dynamic object methods and multiple inheritance, are illustrated through a series of small examples. We show how we can implement object servers, allowing remote spawning of objects, which we can use as staging posts for mobile agents. We give as an example an information gathering mobile agent that can be queried about the information it has so far gathered whilst it is gathering new information. Finally we define a class of co-operative reasoning agents that can do resource bounded inference for full first order predicate logic, handling multiple queries and information updates concurrently. We believe that the combination of the concurrent OO and the LP programming paradigms produces a powerful tool for quickly implementing rational multi-agent applications on the internet.We present a new approach to termination analysis of logic programs. The essence of the approach is that we make use of general orderings (instead of level mappings), like it is done in transformational approaches to logic program termination analysis, but we apply these orderings directly to the logic program and not to the term-rewrite system obtained through some transformation. We define some variants of acceptability, based on general orderings, and show how they are equivalent to LD-termination. We develop a demand driven, constraint-based approach to verify these acceptability-variants. The advantage of the approach over standard acceptability is that in some cases, where complex level mappings are needed, fairly simple orderings may be easily generated. The advantage over transformational approaches is that it avoids the transformation step all together.

From logic programming towards multi-agent systems

In this paper we present an extension of logic programming (LP) that is suitable not only for the “rational” component of a single agent but also for the “reactive” component and that can encompass multi‐agent systems. We modify an earlier abductive proof procedure and embed it within an agent cycle. The proof procedure incorporates abduction, definitions and integrity constraints within a dynamic environment, where changes can be observed as inputs. The definitions allow rational planning behaviour and the integrity constraints allow reactive, condition‐action type behaviour. The agent cycle provides a resource‐bounded mechanism that allows the agent’s thinking to be interrupted for the agent to record and assimilate observations as input and execute actions as output, before resuming further thinking. We argue that these extensions of LP, accommodating multi‐theories embedded in a shared environment, provide the necessary multi‐agent functionality. We argue also that our work extends Shoham’s Agent0 and the BDI architecture.

Logic programs with exceptions

We extend logic programming to deal with default reasoning by allowing the explicit representation of exceptions in addition to general rules. To formalise this extension, we modify the answer set semantics of Gelfond and Lifschitz, which allows both classical negation and negation as failure.We also propose a transformation which eliminates exceptions by using negation by failure. The transformed program can be implemented by standard logic programming methods, such as SLDNF. The explicit representation of rules and exceptions has the virtue of greater naturalness of expression. The transformed program, however, is easier to implement.

Negotiating socially optimal allocations of resources

A multiagent system may be thought of as an artificial society of autonomous software agents and we can apply concepts borrowed from welfare economics and social choice theory to assess the social welfare of such an agent society. In this paper, we study an abstract negotiation framework where agents can agree on multilateral deals to exchange bundles of indivisible resources. We then analyse how these deals affect social welfare for different instances of the basic framework and different interpretations of the concept of social welfare itself. In particular, we show how certain classes of deals are both sufficient and necessary to guarantee that a socially optimal allocation of resources will be reached eventually.

Towards a Unified Agent Architecture that Combines Rationality with Reactivity

In this paper we analyse the differences between rational and reactive agent architectures, and propose a uniform agent architecture that aims to capture both as special cases. For this purpose we employ a proof procedure, to control the agents behaviour, which combines definitions with integrity constraints. The proof procedure is general, and has been shown elsewhere to unify abductive logic programming, constraint logic programming and semantic query optimisation. We also employ a resource-bounded formalisation of the proof procedure which allows the agents reasoning to be interrupted and resumed, so that observations and actions can be performed.

An Abductive Logic Programming Architecture for Negotiating Agents

In this paper, we present a framework for agent negotiation based on abductive logic programming. The framework is based on an existing architecture for logic-based agents, and extends it by accommodating dialogues for negotiation. As an application of negotiating agents, we propose a resource-exchanging problem. The innovative contribution of this work is in the definition of an operational model, including an agent cycle and dialogue cycle, and in the results that apply in the general case of abductive agents and in the specific case of a class of agent systems.

The CIFF Proof Procedure for Abductive Logic Programming with Constraints

We introduce a new proof procedure for abductive logic programming and present two soundness results. Our procedure extends that of Fung and Kowalski by integrating abductive reasoning with constraint solving and by relaxing the restrictions on allowed inputs for which the procedure can operate correctly. An implementation of our proof procedure is available and has been applied successfully in the context of multiagent systems.

On optimal outcomes of negotiations over resources

We analyse scenarios in which self-interested agents negotiate with each other in order to agree on deals to exchange resources. We consider two variants of the framework, one where agents can use money to compensate other agents for disadvantageous deals, and one where this is not possible. In both cases, we analyse what types of deals are necessary and sufficient to guarantee an optimal outcome of negotiation. To assess whether a given allocation of resources should be considered optimal we borrow two concepts from welfare economics: maximal social welfare in the case of the framework with money and Pareto optimality in the case of the framework without money. We also show how conditions for optimal outcomes can change depending on properties of the utility functions used by agents to represent the values they ascribe to certain sets of resources.

Reconciling the event calculus with the situation calculus

Abstract In this paper, to compare the situation calculus and event calculus we formulate both as logic programs and prove properties of these by reasoning with their completions augmented with induction. We thus show that the situation calculus and event calculus imply one another. Whereas our derivation of the event calculus from the situation calculus requires the use of induction, our derivation of the situation calculus from the event calculus does not. We also show that in certain concrete applications, such as the missing car example, conclusions that seem to require the use of induction in the situation calculus can be derived without induction in the event calculus. To compare the two calculi, we need to make a number of small modifications to both. As a by-product of these modifications, the resulting calculi can be used to reason about both actual and hypothetical states of affairs, including counterfactual ones. We further show how the core axioms of both calculi can be extended to deal with domain or state constraints and certain types of ramifications. We illustrate this by examples from legislation and the blocks world.