Alcohol consumption as a self-handicapping strategy in women.

Assessed whether women self-handicap with alcohol consumption prior to engaging in a social evaluation task, which may be more relevant to their self-esteem than the intellectual tasks used in past self-handicapping studies on substance use. 113 women (aged 19–32 yrs), who were evaluated as normal drinkers, performed either a solvable or an insolvable social judgment task and then received either success feedback or no feedback. Ss received access to alcoholic and nonalcoholic beverages while awaiting a retest. The study terminated before the retest. The self-handicapping hypothesis that noncontingent success would produce relatively greater alcohol consumption was not supported. Regardless of feedback, insolvable test Ss consumed more alcohol than did solvable test Ss. Findings suggest that the hypothesis may be limited as a general model of alcohol consumption in both sexes. (13 ref) (PsycINFO Database Record (c) 2010 APA, all rights reserved)     

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.     

Model checking rational agents

Agent-oriented programming techniques seem appropriate for developing systems that operate in complex, dynamic, and unpredictable environments. We aim to address this requirement by developing model-checking techniques for the (automatic or semiautomatic) verification of rational-agent systems written in a logic-based agent-oriented programming language. Typically, developers apply model-checking techniques to abstract models of a system rather than the system implementation. Although this is important for detecting design errors at an early stage, developers might still introduce errors during coding. In contrast, developers can directly apply our model-checking techniques to systems implemented in an agent-oriented programming language, automatically verifying agent systems without the usual gap between design and implementation. We developed our techniques for AgentSpeak, a rational-agent programming language based on the AgentSpeak (L) abstract agent-oriented programming language. AgentSpeak shares many features of the agent-oriented programming paradigm. Similarly, we've developed techniques for automatically translating AgentSpeak programs into the model specification language of existing model-checking systems. In this way, we reduce the problem of verifying that an AgentSpeak system has certain BDI logic properties to a conventional LTL model-checking problem.     

Preclinical assessment of the long-term endurance of cemented hip stems. Part 2: in-vitro and ex-vivo fatigue damage of the cement mantle

Fatigue damage in the cement mantle surrounding hip stems has been studied in the past. However, so far no quantitative method has been validated for assessing ex-vivo damage and for predicting the in-vitro risk of cement fracture. This work presents a method for measuring cement damage; the cement mantle was sliced and sections were inspected with dye penetrants and an optical microscope. Cracks were counted, measured, and classified by type in each region of the cement mantle. Statistical indicators (in total and per unit volume of cement) were proposed that allow quantitative comparison. The method was first validated on two implant types with known clinical success rate, which were tested in vitro using a physiological loading profile (described in Part 1 of this work). The most relevant indicators were able to detect statistical differences between the two designs. Retrieved cement mantles (the same design as one of the in-vitro stems) from revision surgery were also processed with the same inspection method. Excellent qualitative and quantitative agreement was found between the in-vitro generated fatigue damage and the cracking pattern found in the ex-vivo retrieved cement mantles. This demonstrated the effectiveness of the cement inspection protocol and provided a further validation to the in-vitro testing method.     

Proving the Asymmetry Thesis Principles for a BDI Agent-Oriented Programming Language

In this paper, we consider each of the nine principles of BDI logics as defined by Rao and Georgeff based on Bratman's asymmetry thesis, and we verify which ones are satisfied by Rao's AgentSpeak(L), a computable logic language inspired by the BDI architecture for cognitive agents. This is in line with Rao's original motivation for defining AgentSpeak(L): to bridge the gap between the theory and practice of BDI agent systems. In order to set the grounds for the proof, we first introduce a particular way in which to define the informational, motivational, and deliberative modalities of BDI logics for AgentSpeak(L) agents, according to its structural operational semantics (that we introduced in a recent paper). This provides a framework that can be used to investigate further properties of AgentSpeak(L) agents, contributing towards giving firm theoretical grounds for BDI agent programming.     

Allocating structured tasks in heterogeneous agent teams

Task allocation is an important aspect of multiagent coordination. However, there are many challenges in developing appropriate strategies for multiagent teams so that they operate efficiently. Real‐world scenarios such as flooding disasters usually require the use of heterogeneous robots and the execution of tasks with different structures and complexities. In this paper, we propose a decentralized task allocation mechanism considering different types of tasks for heterogeneous agent teams where agents play different roles and carry out tasks according to their own capabilities. We have run several experiments to evaluate the proposed mechanism. The results show that the proposed mechanism appears to scale well and provides near‐optimal allocations.     

SMART-JaCaMo: an organization-based team for the multi-agent programming contest

The Multi-Agent Programming Contest in 2017 expanded upon the Agents in the City scenario used in the 2016 edition of the contest. In the Agents in the City contest, two teams compete to accomplish logistic tasks in simulations using realistic city maps from OpenStreetMap. The new version of the scenario shifted emphasis to include jobs that require assembled items, new types of facilities, and larger teams, resulting in a significantly more complex scenario than before. In this paper, we describe the strategies used by our team, highlighting our adaptations and any new additions from our participation in the previous year. One such new addition, is that now we have fully explored the use of all three programming dimensions (agent, environment, and organization) found in JaCaMo, the multi-agent system development platform that we used to implement our team. We also provide some discussion and analysis on what we believe were some of our most influential matches.     

Verifying Multi-agent Programs by Model Checking

This paper gives an overview of our recent work on an approach to verifying multi-agent programs. We automatically translate multi-agent systems programmed in the logic-based agent-oriented programming language AgentSpeak into either Promela or Java, and then use the associated Spin and JPF model checkers to verify the resulting systems. We also describe the simplified BDI logical language that is used to write the properties we want the systems to satisfy. The approach is illustrated by means of a simple case study.