Louise A. Dennis

Model checking agent programming languages

In this paper we describe a verification system for multi-agent programs. This is the first comprehensive approach to the verification of programs developed using programming languages based on the BDI (belief-desire-intention) model of agency. In particular, we have developed a specific layer of abstraction, sitting between the underlying verification system and the agent programming language, that maps the semantics of agent programs into the relevant model-checking framework. Crucially, this abstraction layer is both flexible and extensible; not only can a variety of different agent programming languages be implemented and verified, but even heterogeneous multi-agent programs can be captured semantically. In addition to describing this layer, and the semantic mapping inherent within it, we describe how the underlying model-checker is driven and how agent properties are checked. We also present several examples showing how the system can be used. As this is the first system of its kind, it is relatively slow, so we also indicate further work that needs to be tackled to improve performance.

The PROSPER Toolkit

The PROSPER (Proof andS pecification Assisted Design Environments) project advocates the use of toolkits which allow existing verification tools to be adapted to a more flexible format so that they may be treated as components. A system incorporating such tools becomes another component that can be embedded in an application. This paper describes the PROSPER Toolkit which enables this. The nature of communication between components is specifiedin a language-independent way. It is implemented in several common programming languages to allow a wide variety of tools to have access to the toolkit.

Predicting the metabolic energy costs of bipedalism using evolutionary robotics

SUMMARY To understand the evolution of bipedalism among the hominoids in an ecological context we need to be able to estimate the energetic cost of locomotion in fossil forms. Ideally such an estimate would be based entirely on morphology since, except for the rare instances where footprints are preserved, this is the only primary source of evidence available. In this paper we use evolutionary robotics techniques (genetic algorithms, pattern generators and mechanical modeling) to produce a biomimetic simulation of bipedalism based on human body dimensions. The mechanical simulation is a seven-segment, two-dimensional model with motive force provided by tension generators representing the major muscle groups acting around the lower-limb joints. Metabolic energy costs are calculated from the muscle model, and bipedal gait is generated using a finite-state pattern generator whose parameters are produced using a genetic algorithm with locomotor economy (maximum distance for a fixed energy cost) as the fitness criterion. The model is validated by comparing the values it generates with those for modern humans. The result (maximum efficiency of 200 J m–1) is within 15% of the experimentally derived value, which is very encouraging and suggests that this is a useful analytic technique for investigating the locomotor behaviour of fossil forms. Initial work suggests that in the future this technique could be used to estimate other locomotor parameters such as top speed. In addition, the animations produced by this technique are qualitatively very convincing, which suggests that this may also be a useful technique for visualizing bipedal locomotion.

A common semantic basis for BDI languages

We describe the design of an intermediate language (AIL) for BDIstyle programming languages. AIL is not intended as yet another programming language, but is meant to provide a common semantic basis for a number of BDI programming languages in order to support both formal verification and the transfer of concepts and developments. We examine some of the key features of AIL, unifying a wide variety of structures appearing in the operational semantics of BDI programming languages. In particular, we highlight issues in the treatment of events, goals, and intentions, which are central to the design of these languages.

Verifying autonomous systems

Exploring autonomous systems and the agents that control them.

Evaluating alternative gait strategies using evolutionary robotics

Evolutionary robotics is a branch of artificial intelligence concerned with the automatic generation of autonomous robots. Usually the form of the robot is predefined and various computational techniques are used to control the machines behaviour. One aspect is the spontaneous generation of walking in legged robots and this can be used to investigate the mechanical requirements for efficient walking in bipeds. This paper demonstrates a bipedal simulator that spontaneously generates walking and running gaits. The model can be customized to represent a range of hominoid morphologies and used to predict performance parameters such as preferred speed and metabolic energy cost. Because it does not require any motion capture data it is particularly suitable for investigating locomotion in fossil animals. The predictions for modern humans are highly accurate in terms of energy cost for a given speed and thus the values predicted for other bipeds are likely to be good estimates. To illustrate this the cost of transport is calculated for Australopithecus afarensis. The model allows the degree of maximum extension at the knee to be varied causing the model to adopt walking gaits varying from chimpanzee‐like to human‐like. The energy costs associated with these gait choices can thus be calculated and this information used to evaluate possible locomotor strategies in early hominids.

Automated Verification of Multi-Agent Programs

In this paper, we show that the flexible model-checking of multi-agent systems, implemented using agent-oriented programming languages, is viable thus paving the way for the construction of verifiably correct applications of autonomous agents and multi-agent systems. Model checking experiments were carried out on AJPF (agent JPF), our extension of Java PathFinder that incorporates the agent infrastructure layer, our unifying framework for agent programming languages. In our approach, properties are specified in a temporal language extended with (shallow) agent-related modalities. The framework then allows the verification of programs written in a variety of agent programming languages, thus removing the need for individual languages to implement their own verification framework. It even allows the verification of multi-agent systems comprised of agents developed in a variety of different (agent) programming languages. As an example, we also provide model checking results for the verification of a multi-agent system implementing a well-known task sharing protocol.

Practical verification of decision-making in agent-based autonomous systems

We present a verification methodology for analysing the decision-making component in agent-based hybrid systems. Traditionally hybrid automata have been used to both implement and verify such systems, but hybrid automata based modelling, programming and verification techniques scale poorly as the complexity of discrete decision-making increases making them unattractive in situations where complex logical reasoning is required. In the programming of complex systems it has, therefore, become common to separate out logical decision-making into a separate, discrete, component. However, verification techniques have failed to keep pace with this development. We are exploring agent-based logical components and have developed a model checking technique for such components which can then be composed with a separate analysis of the continuous part of the hybrid system. Among other things this allows program model checkers to be used to verify the actual implementation of the decision-making in hybrid autonomous systems.

Language Constructs for Multi-agent Programming

In this paper we are concerned with proposing, analyzing and implementing simple, yet flexible, constructs for multi-agent programming. In particular, we wish to extend programming languages based on the BDI style of logical agent model with two such constructs, namely constraints and content/context sets . These two aspects provide sufficient expressive power to allow us to represent, simply and with semantic clarity, a wide range of organisational structures for multi-agent systems. We not only introduce this approach, but provide its formal semantics, through modification of an operational semantics based on the core of AgentSpeak , 3APL and MetateM . In addition, we provide illustrative examples by simulating both constraints and content/context sets within the Jason interpreter for AgentSpeak . In summary, we advocate the use of these simple constructs in many logic-based BDI languages, by appealing to their applicability, simplicity and clear semantics.

A Common Basis for Agent Organisation in BDI Languages

Programming languages based on the BDI style of agent model are now common. Within these there appears to be some, limited, agreement on the core functionality of agents. However, when we come to multi-agent organisations, not only do many BDI languages have no specific organisational structures, but those that do exist are very diverse. In this paper, we aim to provide a unifying framework for the core aspects of agent organisation, covering groups, teams and roles, as well as organisations. Thus, we describe a simple organisational mechanism, and show how several well known approaches can be embedded within it. Although the mechanism we use is derived from the MetateM programming language, we do not assume any specific BDI language. The organisational mechanism is intended to be independent of the underlying agent language and so we aim to provide a common core for future developments in agent organisation.