In the examples so far, the focus has been on agent architectures to support the design of agent-based systems. Another approach to building agents is to design a programming language with semantics based on some theory of rational or intentional agency, such as the BDI model, and to program the desired behavior of individual agents directly using mental attitudes. Such a technique is referred to as agent-oriented programming (AOP). An agent-oriented program comprises a set of transition rules that specify how an agent in a given mental state will respond to an input, which may be a set of messages from other agents, by defining its new mental state and any outputs.
The language we describe here is PLACA [44], which extends the expressive power of AGENTO [45] developed by Shoham, who introduced the concept of agent-oriented programs. We do not describe PLACA in detail, but include it simply as an example of an alternative approach, especially because of its formal nature, which provides a counterpoint to the earlier architectures in this chapter. This section thus only includes brief summaries, and the interested reader can explore further through the references.
When it was first introduced, AGENTO (and later its successor, PLACA) represented a new programming paradigm that supported the notion of a societal view of computation in which agents would interact with each other in order to achieve their individual goals. Shoham asserted that an approach that could enable a system of agents to be built in this way needs three particular elements, as follows:
It requires a formal logical language to describe the mental state of each agent. Such mental state consists of beliefs and intentions, as we have seen in other systems described in this chapter.
It also needs a programming language with which to specify the agents and their behavior.
Finally, it needs a method for adapting nonagent legacy systems so that they can be incorporated into an agent system, thereby allowing agents to communicate with them by attributing beliefs and intentions.
A program in PLACA is defined by an initial mental state and a set of mental-state rules specifying how the mental state changes in various scenarios. At run time, an agent's state consists of capabilities and its mental state, which comprises beliefs, intentions, and plans (where plans, and possibly intentions, are initially empty). At every step, an agent collects messages that have been received from others from the input buffer, clears this buffer, and updates its mental state according to its defining program.
At the beginning of each execution step, those transition rules that are satisfied in the current state are identified, and applied to the current mental state and messages collected from the input buffer. Once the mental state is updated, messages that need to be sent are placed in the output buffer, and actions that need to be performed are recorded and executed in the next step. If there is sufficient time before the next tick of the clock, the planner may construct and refine current plans for satisfying intentions. A basic representation of the PLACA interpreter is shown in Figure 2.7.
Figure 2.7: The PLACA interpreter. (After: [44].)
PLACA is based on a modal logic specification of the relationship between the mental-state components. Its designers claim that PLACA agents satisfy all the axioms provided, but the relationship between the logic and the programming language is not well-defined. This is a persistent problem in the agent field: how to determine the correspondence between computational systems on the one hand, and formal models, typically constructed in modal logic, on the other. One approach to this problem is to carefully design temporal logics so that agents can be described using logic formulas that are directly executable, as we will see next.
2.6.2 Concurrent METATEM
The same societal view of computation as in AOP is also present in Concurrent METATEM [46], a programming language in which each agent is defined as a concurrently executing process, communicating with other such processes via message-passing. The distinct characteristic of this work is that agents are specified using a temporal logic that is directly executable. To directly execute a specification written in a temporal logic formula, the interpreter attempts to construct a model structure in which the agent specification is satisfied. However, since the environment is dynamic, it may constantly be altering that model, so that responses must be made to what has just become true or untrue because of this dynamism.
The way in which the model is constructed in a dynamic environment is referred to as the execution strategy. When a Concurrent METATEM program is executed, it produces a sequence of temporally ordered states, each labeled with a model structure stating those propositions that are true. This trace provides Concurrent METATEM specifications with a concrete computational interpretation.
The basic form of a specification in Concurrent METATEM is as follows: "on the basis of what has happened in the past do something in the future." Thus, each agent is specified by a set of rules of the form:
and at each cycle, the precedent of each rule is matched against an internal history, firing if a match can be found. Once a rule fires, the agent is committed to the antecedent, which typically involves trying to make some predicate true.
As an example, consider the following Concurrent METATEM program, specifying the behavior of a controller agent solely responsible for supplying an infinitely renewable resource [47]. While the resource cannot be used by two agents at the same time, it is possible that the controller may be asked by two different agents for the resource simultaneously. The predicates ask(x) and give(x) mean that agent x has been asked for the resource, and that agent x has been given the resource, respectively.
In temporal logic, the formula, ○Form, is satisfied at present if Form is satisfied at the next time moment. Similarly, ◊Form is satisfied at present if Form is true at some time in the future, and FG is satisfied if F is true since G has been true.
The specification of the controller agent is defined in Concurrent METATEM as follows:
These three formulas can be interpreted in English as follows:
If an agent asks, then eventually give the resource to that agent;
Do not give to anyone unless they have asked since you last gave to them;
If you give to two people, then they must be the same person.
Concurrent METATEM is attractive because it is directly executable so that no time-consuming and error-prone refinement is required in the process from specification to implementation. In addition, specifications have a concrete computational semantics defined by the sequence of models that arise through the constant interplay of the dynamic environment and the action of the agent. However, since the execution of Concurrent METATEM is based on theorem-proving, some standard problems arise such as the undecidability of first-order logic and the complexity involved in simple propositional logic. In addition, it is not clear how other modal operators commonly associated with agents such as belief, desire, and intention could be incorporated into the language while maintaining its directly executable property.
No comments:
Post a Comment