共查询到20条相似文献,搜索用时 15 毫秒
1.
We present a family of sound and complete logics for reasoning about deliberation strategies for SimpleAPL programs. SimpleAPL
is a fragment of the agent programming language 3APL designed for the implementation of cognitive agents with beliefs, goals
and plans. The logics are variants of PDL, and allow us to prove safety and liveness properties of SimpleAPL agent programs
under different deliberation strategies. We show how to axiomatise different deliberation strategies for SimpleAPL programs,
and, for each strategy we prove a correspondence between the operational semantics of SimpleAPL and the models of the corresponding
logic. We illustrate the utility of our approach with an example in which we show how to verify correctness properties for
a simple agent program under different deliberation strategies. 相似文献
2.
Agent Programming in 3APL 总被引:8,自引:3,他引:5
Koen V. Hindriks Frank S. De Boer Wiebe Van der Hoek John-Jules Ch. Meyer 《Autonomous Agents and Multi-Agent Systems》1999,2(4):357-401
An intriguing and relatively new metaphor in the programming community is that of an intelligent agent. The idea is to view programs as intelligent agents acting on our behalf. By using the metaphor of intelligent agents the programmer views programs as entities which have a mental state consisting of beliefs and goals. The computational behaviour of an agent is explained in terms of the decisions the agent makes on the basis of its mental state. It is assumed that this way of looking at programs may enhance the design and development of complex computational systems.To support this new style of programming, we propose the agent programming language 3APL. 3APL has a clear and formally defined semantics. The operational semantics of the language is defined by means of transition systems. 3APL is a combination of imperative and logic programming. From imperative programming the language inherits the full range of regular programming constructs, including recursive procedures, and a notion of state-based computation. States of agents, however, are belief or knowledge bases, which are different from the usual variable assignments of imperative programming. From logic programming, the language inherits the proof as computation model as a basic means of computation for querying the belief base of an agent. These features are well-understood and provide a solid basis for a structured agent programming language. Moreover, on top of that 3APL agents use so-called practical reasoning rules which extend the familiar recursive rules of imperative programming in several ways. Practical reasoning rules can be used to monitor and revise the goals of an agent, and provide an agent with reflective capabilities.Applying the metaphor of intelligent agents means taking a design stance. From this perspective, a program is taken as an entity with a mental state, which acts pro-actively and reactively, and has reflective capabilities. We illustrate how the metaphor of intelligent agents is supported by the programming language. We also discuss the design of control structures for rule-based agent languages. A control structure provides a solution to the problem of which goals and which rules an agent should select. We provide a concrete and intuitive ordering on the practical reasoning rules on which such a selection mechanism can be based. The ordering is based on the metaphor of intelligent agents. Furthermore, we provide a language with a formal semantics for programming control structures. The main idea is not to integrate this language into the agent language itself, but to provide the facilities for programming control structures at a meta level. The operational semantics is accordingly specified at the meta level, by means of a meta transition system. 相似文献
3.
One problem with debugging (committed choice) concurrent logic programs is that their behaviour may be non-deterministic, in that successive executions of the same program may produce different results. We describe a scheme, based on the ‘Instant Replay’ scheme developed for more conventional parallel languages, that allows us to reproduce the execution behaviour of a concurrent logic program on subsequent executions, so that the execution may be examined for debugging purposes. The properties of concurrent logic programming languages allow us to simplify our scheme greatly. We have demonstrated our scheme with KLIC, and KL1 on the PIM multiprocessors, but it can also be applied to other committed choice concurrent logic programming languages. 相似文献
4.
Robert Kowalski Fariba Sadri 《Annals of Mathematics and Artificial Intelligence》2011,62(1-2):129-158
In this paper we present an agent language that combines agent functionality with a state transition theory and model-theoretic semantics. The language is based on abductive logic programming (ALP), but employs a simplified state-free syntax, with an operational semantics that uses destructive updates to manipulate a database, which represents the current state of the environment. The language builds upon the ALP combination of logic programs, to represent an agent??s beliefs, and integrity constraints, to represent the agent??s goals. Logic programs are used to define macro-actions, intensional predicates, and plans to reduce goals to sub-goals including actions. Integrity constraints are used to represent reactive rules, which are triggered by the current state of the database and recent agent actions and external events. The execution of actions and the assimilation of observations generate a sequence of database states. In the case of the successful solution of all goals, this sequence, taken as a whole, determines a model that makes the agent??s goals and beliefs all true. 相似文献
5.
We present recent work on the development of Java PathExplorer (JPaX), a tool for monitoring the execution of Java programs. JPaX can be used during program testing to gain increased information about program executions, and can potentially furthermore be applied during operation to survey safety critical systems. The tool facilitates automated instrumentation of a program's byte code, which will then emit events to an observer during its execution. The observer checks the events against user provided high level requirement specifications, for example temporal logic formulae, and against lower level error detection procedures, usually concurrency related such as deadlock and data race algorithms. High level requirement specifications together with their underlying logics are defined in rewriting logic using Maude, and then can either be directly checked using Maude rewriting engine, or be first translated to efficient data structures and then checked in Java. 相似文献
6.
7.
Pierangelo Dell'Acqua Ulf Nilsson Luís Moniz Pereira 《Electronic Notes in Theoretical Computer Science》2002,70(5)
We present a logic programming based asynchronous multi-agent system in which agents can communicate with one another; update themselves and each other; abduce hypotheses to explain observations, and use them to generate actions. The knowledge base of the agents is comprised of generalized logic programs, integrity constraints, active rules, and of abducibles. We characterize the interaction among agents via an asynchronous transition rule system, and provide a stable models based semantics. An example is developed to illustrate how our approach works. 相似文献
8.
This paper presents an approach for the automated debugging of reactive and concurrent Java programs, combining model checking and runtime monitoring. Runtime monitoring is used to transform the Java execution traces into the input for the model checker, the purpose of which is twofold. First, it checks these execution traces against properties written in linear temporal logic (LTL), which represent desirable or undesirable behaviors. Second, it produces several execution traces for a single Java program by generating test inputs and exploring different schedulings in multithreaded programs. As state explosion is the main drawback to model checking, we propose two abstraction approaches to reduce the memory requirements when storing Java states. We also present the formal framework to clarify which kinds of LTL safety and liveness formulas can be correctly analysed with each abstraction for both finite and infinite program executions. A major advantage of our approach comes from the model checker, which stores the trace of each failed execution, allowing the programmer to replay these executions to locate the bugs. Our current implementation, the tool TJT, uses Spin as the model checker and the Java Debug Interface (JDI) for runtime monitoring. TJT is presented as an Eclipse plug-in and it has been successfully applied to debug complex public Java programs. 相似文献
9.
在面向对象程序设计中,软件测试的关键是设计程序运行状态及其使用方法。然而,状态图中的路径往往是部分重叠的。为此,研究一种改进的状态空间搜索的执行方法,该方法具有共享相同路径的特点。采用路径覆盖程序测试器模型测试提升执行方法的效率。实验结果显示,该执行方法可有效降低状态空间搜索的执行时间,提高搜索效率。 相似文献
10.
This paper investigates the advantages of reasoning on logic programs and queries that have only successful derivations. We consider an extension of the logic programming paradigm that combines guarded clauses and delay declarations. The main contribution of this paper consists of some general conditions for a class of programs and queries which imply that successful derivations only are present. A few practical instances of the method are studied, and their applicability demonstrated. The general conditions are derived extending proof methods originally developed for Prolog's programs. From the point of view of parallelism, the method is able to reason about termination (with success) of pipeline parallel executions of programs. In particular, we show some examples of parallelization of terminating Prolog programs. Moreover, from the point of view of nondeterminism, don't care nondeterminism can be safely adopted for the class of programs that have only successfull derivations. 相似文献
11.
In multi-agent domains, the generation and coordinated execution of plans in the presence of adversaries is a significant
challenge. In our research, a special “coach” agent works with a team of distributed agents. The coach has a global view of
the world, but has no actions other than occasionally communicating with the team over a limited bandwidth channel. Our coach
is given a set of predefined opponent models which predict future states of the world caused by the opponents’ actions. The
coach observes the world state changes resulting from the execution of its team and opponents and selects the best matched
opponent model based on its observations. The coach uses the recognized opponent model to predict the behavior of the opponent.
Upon opportunities to communicate, the coach generates a plan for the team, using the predictions of the opponent model. The
centralized coach generates a plan for distributed execution. We introduce (i) the probabilistic representation and recognition
algorithm for the opponent models; (ii) a multi-agent plan representation, Multi-Agent Simple Temporal Networks; and (iii)
a plan execution algorithm that allows the robust distributed execution in the presence of noisy perception and actions. The
complete approach is implemented in a complex simulated robot soccer environment. We present the contributions as developed
in this domain, carefully highlighting their generality along with a series of experiments validating the effectiveness of
our coach approach. 相似文献
12.
Matteo Baldoni Alberto Martelli Viviana Patti Laura Giordano 《Annals of Mathematics and Artificial Intelligence》2004,41(2-4):207-257
In this paper we describe a language for reasoning about actions that can be used for modelling and for programming rational agents. We propose a modal approach for reasoning about dynamic domains in a logic programming setting. Agent behavior is specified by means of complex actions which are defined using modal inclusion axioms. The language is able to handle knowledge producing actions as well as actions which remove information. The problem of reasoning about complex actions with incomplete knowledge is tackled and the temporal projection and planning problems is addressed; more specifically, a goal directed proof procedure is defined, which allows agents to reason about complex actions and to generate conditional plans. We give a non-monotonic solution for the frame problem by making use of persistency assumptions in the context of an abductive characterization. The language has been used for implementing an adaptive web-based system. 相似文献
13.
Primary and secondary diagnosis of multi-agent plan execution 总被引:1,自引:1,他引:0
Femke de Jonge Nico Roos Cees Witteveen 《Autonomous Agents and Multi-Agent Systems》2009,18(2):267-294
Diagnosis of plan failures is an important subject in both single- and multi-agent planning. Plan diagnosis can be used to
deal with plan failures in three ways: (i) to provide information necessary for the adjustment of the current plan or for
the development of a new plan, (ii) to point out which equipment and/or agents should be repaired or adjusted to avoid further
violation of the plan execution, and (iii) to identify the agents responsible for plan-execution failures. We introduce two
general types of plan diagnosis: primary plan diagnosis identifying the incorrect or failed execution of actions, and secondary plan diagnosis that identifies the underlying causes of the faulty actions. Furthermore, three special cases of secondary plan diagnosis
are distinguished, namely agent diagnosis, equipment diagnosis and environment diagnosis. 相似文献
14.
Emmanuel Melin Bruno Raffin Xavier Rebeuf Bernard Virot 《Journal of Parallel and Distributed Computing》1998,50(1-2)
In this paper, we present a parallel programming and execution model based on alogicalordering of control flows. We show that it is possible to provide a unifying framework consisting of a synchronous programming model, thereby facilitating the mastery of programs, and an asynchronous execution model yielding efficient executions. Our approach is based on a SPMD and task parallel programming language, called
–Chan. Communications take place through channels and rely on explicit send/receive instructions. In contrast to classical message passing models, synchronizations and communications are dissociated. We show that it is possible to perform a data-driven automatic translation of sequential and arbitrary DOACROSS loops into
–Chan, by using nonmatching send/receive instructions. Our parallelization technique allows us to handle irregular control and leads to optimizations of communications in irregular computations. 相似文献
15.
《IEEE transactions on pattern analysis and machine intelligence》2008,34(5):597-613
We present Delta Execution, a technique that speeds up state-space exploration of object-oriented programs. State-space exploration is the essence of model checking and an increasingly popular approach for automating test generation. A key issue in exploration of object-oriented programs is handling the program state, in particular the heap. We exploit the fact that many execution paths in state-space exploration partially overlap. Delta Execution simultaneously operates on several states/heaps and shares the common parts across the executions, separately executing only the "deltas" where the executions differ. We implemented Delta Execution in two model checkers: JPF, a popular general-purpose model checker for Java programs, and BOX, a specialized model checker that we developed for efficient exploration of sequential Java programs. The results for bounded-exhaustive exploration of ten basic subject programs and one larger case study show that Delta Execution reduces exploration time from 1.06x to 126.80x (with median 5.60x) in JPF and from 0.58x to 4.16x (with median 2.23x) in BOX. The results for a non-exhaustive exploration in JPF show that Delta Execution reduces exploration time from 0.92x to 6.28x (with median 4.52x). 相似文献
16.
17.
Sebastian Sardina Giuseppe De Giacomo Yves Lespérance Hector J. Levesque 《Annals of Mathematics and Artificial Intelligence》2004,41(2-4):259-299
We develop an account of the kind of deliberation that an agent that is doing planning or executing high-level programs under incomplete information must be able to perform. The deliberator's job is to produce a kind of plan that does not itself require deliberation to interpret. We characterize these as epistemically feasible programs: programs for which the executing agent, at every stage of execution, by virtue of what it knew initially and the subsequent readings of its sensors, always knows what step to take next towards the goal of completing the entire program. We formalize this notion and characterize deliberation in the situation calculus based IndiGolog agent programming language in terms of it. We also show that for certain classes of problems, which correspond to those with bounded solutions and those with solutions without sensing, the search for epistemically feasible programs can be limited to programs of a simple syntactic form. Finally, we discuss implementation issues and execution monitoring and replanning too. 相似文献
18.
Ariel MonteserinAuthor Vitae Analía Amandi Author Vitae 《Decision Support Systems》2011,51(3):532-548
When we negotiate, the arguments uttered to persuade the opponent are not the result of an isolated analysis, but of an integral view of the problem that we want to agree about. Before the negotiation starts, we have in mind what arguments we can utter, what opponent we can persuade, which negotiation can finish successfully and which cannot. Thus, we plan the negotiation, and in particular, the argumentation. This fact allows us to take decisions in advance and to start the negotiation more confidently. With this in mind, we claim that this planning can be exploited by an autonomous agent. Agents plan the actions that they should execute to achieve their goals. In these plans, some actions are under the agent's control, while some others are not. The latter must be negotiated with other agents. Negotiation is usually carried out during the plan execution. In our opinion, however, negotiation can be considered during the planning stage, as in real life. In this paper, we present a novel approach to integrate argumentation-based negotiation planning into the general planning process of an autonomous agent. This integration allows the agent to take key decisions in advance. We evaluated this proposal in a multiagent scenario by comparing the performance of agents that plan the argumentation and agents that do not. These evaluations demonstrated that performance improves when the argumentation is planned, specially, when the negotiation alternatives increase. 相似文献
19.
DECAF - A Flexible Multi Agent System Architecture 总被引:6,自引:0,他引:6
John R. Graham Keith S. Decker Michael Mersic 《Autonomous Agents and Multi-Agent Systems》2003,7(1-2):7-27
20.
Typically, program design involves constructing a program P that implements a given specification S; that is, the set
${\overline P}$ of executions of P is a subset of the set
${\overline S}$ of executions satisfying S. In many cases, we seek a program P that not only implements S, but for which
${\overline P}$ =
${\overline S}$. Then, every execution satisfying the specification is a possible execution of the program; we then call P maximal for the specification S. We argue that maximality is an important criterion in the context of designing concurrent programs because it disallows
implementations that do not exhibit enough concurrency. In addition, a maximal solution can serve as a basis for deriving
a variety of implementations, each appropriate for execution on a specific computing platform. This paper also describes a
method for proving the maximality of a program with respect to a given specification. Even though we prove facts about possible
executions of programs, there is no need to appeal to branching time logics; we employ a fragment of linear temporal logic
for our proofs. The method results in concise proofs of maximality for several non-trivial examples. The method may also serve
as a guide in constructing maximal programs.
Received September 1997 / Accepted in revised form May 2000 相似文献