Actilog: An agent activation language
Jacinto Dávila2003, Practical Aspects of Declarative Languages
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
ACTILOG is a language to write generalized condition → action activation rules. We propose it as an alternative and a complement to OPENLOG [6], another agent logic programming language for an abductive reasoner. We want to show how implications (conditional goals) can be used to state integrity contraints for an agent. These integrity contraints describe conditions under which the agent's goals must be reduced to plans that can be executed. For instance, a rule such as if A then B, will indicate to the agent that whenever it can prove that A is the case, it then should pursue goal B. B is normally the description of a task that must be reduced to a set of low-level, primitive actions that the agent can execute.
Related papers
IndiGolog: A High-Level Programming Language for Embedded Reasoning Agents
2009
IndiGolog isaprogramming languagefor autonomousagentsthat sense their environment anddo planning astheyoperate. Insteadof classical planning, it supports high-level program execution. The programmer provides a high-level nondeterministicprograminvolving domain-speci? c actions andteststo perform the agent’s tasks. The IndiGolog interpreterthenreasons aboutthepreconditions andeffectsofthe actionsintheprogramtonda legalterminatingexecution.To support this, the programmer provides a declarative specication of the domain (i.e.,primitive actions,preconditions andeffects, whatis known aboutthe initial state)inthe situation calculus. Theprogrammer can controlthe amountof non-determinism in the program and how muchof it is searched over. The language isrichand supports concurrentprogramming.Programsareexecuted onlinetogether withsensingthe environment and monitoringforevents,thus supporting thedevelopmentofreactiveagents.We discussthe language, itsimplementation, and applicationsthathave beenrealized withit.
CTL AgentSpeak(L): A specification language for agent programs
Journal of Algorithms, 2009
This work introduces CT L AgentSpeak(L) , a logic to specify and verify expected properties of rational agents implemented in the AgentSpeak(L) agent oriented programming language. Our approach is similar to the classic BDICT L modal logic, used to reason about agents modelled in terms of belief (BEL), desires (DES), intentions (INTEND). A new interpretation for the temporal operators in CT L: next ( ), eventually (♦), until(U), inevitable(A), etc., is proposed in terms of the transition system induced by the operational semantics of AgentSpeak(L). The main contribution of the approach is a better understanding of the relation between the programming language and its logical specification, enabling us to proof expected or desired properties for any agent programmed in AgentSpeak(L), e.g., commitment strategies.
A declarative agent programming language based on action theories
Frontiers of Combining Systems, 2009
We discuss a new concept of agent programs that combines logic programming with reasoning about actions. These agent logic programs are characterized by a clear separation between the specification of the agent's strategic behavior and the underlying theory about the agent's actions and their effects. This makes it a generic, declarative agent programming language, which can be combined with an action representation formalism of one's choice. We present a declarative semantics for agent logic programs along with (two versions of) a sound and complete operational semantics, which combines the standard inference mechanisms for (constraint) logic programs with reasoning about actions.
Verifiable agent interaction in abductive logic programming
ACM Transactions on Computational Logic, 2008
SCIFF is a framework thought to specify and verify interaction in open agent societies. The SCIFF language is equipped with a semantics based on abductive logic programming; SCIFF's operational component is a new abductive logic programming proof-procedure, also named SCIFF, for reasoning with expectations in dynamic environments. In this paper we present the declarative and operational semantics of the SCIFF language, the termination, soundness and completeness results of the SCIFF proof procedure, and we demonstrate SCIFF's possible application in the multi-agent domain. ]. Within SOCS, we have developed a declarative semantic characterization of open agent societies in ALP, and an operational framework centered around an ALP proof-procedure called SCIFF. 2 SCIFF aims to specify in a declarative but intensional way what are "admissible interactions" among agents, and to provide a computational tool to decide whether a given interaction is admissible or not, which we call verification of compliance.
AgentSpeak(L): BDI agents speak out in a logical computable language
Lecture Notes in Computer Science, 1996
Belief-Desire-Intention (BDI) agents have been investigated by many researchers from both a theoretical specification perspective and a practical design perspective. However, there still remains a large gap between theory and practice. The main reason for this has been the complexity of theorem-proving or modelchecking in these expressive specification logics. Hence, the implemented BDI systems have tended to use the three major attitudes as data structures, rather than as modal operators. In this paper, we provide an alternative formalization of BDI agents by providing an operational and proof-theoretic semantics of a language AgentSpeak(L). This language can be viewed as an abstraction of one of the implemented BDI systems (i.e., PRS) and allows agent programs to be written and interpreted in a manner similar to that of horn-clause logic programs. We show how to perform derivations in this logic using a simple example. These derivations can then be used to prove the properties satisfied by BDI agents.
Programming Cognitive Agents in Defeasible Logic
2005
Defeasible Logic is extended to programming languages for cognitive agents with preferences and actions for planning. We define rule-based agent theories that contain preferences and actions, together with inference procedures. We discuss patterns of agent types in this setting. Finally, we illustrate the language by an example of an agent reasoning about web-services.
A Logic programming theory of reasoning about actions
1998
Abstract In this paper we propose the language ofstate speci cations' to uniformly specify e ect of actions, executability condition of actions, and dynamic and static constraints. This language allows us to be able to express e ects of action and constraints with same rst order representation but di erent intuitive behavior to be speci ed di erently. We then discuss how we can use state speci cations to extend the action description languages A and L0.
Logic-based languages to model and program intelligent agents
APPIA-GULP-PRODE, 2002
Research on tools for modeling and specifying intelligent agents, namely computer systems situated in some environment and capable of flexible autonomous actions, is very lively. Due to the complexity of intelligent agents, the way they are modeled, specified and verified should greatly benefit by the adoption of formal methods. Logic-based languages can be a useful tool for engineering the development of a multi-agent system (MAS). This paper discusses six logic-based languages which have been used to model and specify agents, namely ConGolog, AGENT-0, the IMPACT specification language, Dylog, Concurrent METATEM and. To show their main features and to practically exemplify how they can be used, a common running example is provided. Besides this, a set of desirable features that languages should exhibit to prove useful in engineering a MAS have been identified. A comparison of the six languages with respect to the support given to these features is provided, as well as final considerations on the usefulness of logic-based languages for "agent oriented software engineering".
Agent oriented logic programming in Jinni 2004
Proceedings of the 2005 ACM symposium on Applied computing - SAC '05, 2005
We show that key agent programming patterns are well expressed in terms of an object oriented logic programming layer extended with a generalized inheritance mechanism and independent inference engines. Instead of proposing yet another agent programming "model" we derive key agent programming patterns as the natural result of a set of programming language constructs providing orthogonal agent composition mechanisms.
Argumentation Systems and Agent Programming Languages
In this work we will present an integration of a queryanswering argumentation approach with an abstract agent programming language. Agents will argumentatively reason via queries, using information of their mental components. Special context-based queries will be used to model the interaction between mental components. Deliberation and execution semantics of the proposed integration are presented.
Related topics
Related papers
Reasoning about Agent Programs Using ATL-Like Logics
Lecture Notes in Computer Science, 2012
We propose a variant of Alternating-time Temporal Logic (ATL) grounded in the agents' operational know-how, as defined by their libraries of abstract plans. Inspired by ATLES, a variant itself of ATL, it is possible in our logic to explicitly refer to "rational" strategies for agents developed under the Belief-Desire-Intention agent programming paradigm. This allows us to express and verify properties of BDI systems using ATL-type logical frameworks.
Programming Rational Agents in a Modal Action Logic
Annals of Mathematics and Artificial Intelligence, 2000
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.
The DALI Agent-Oriented Logic Programming Language: References
DALI is a logic programming agent-oriented language defined in [1,2,3,4], fully formalized in [5,6]. DALI is fully implemented, and has been used in practice in a variety of applications [7,8,9,10]. A stable release of the DALI interpreter is publicly available at [11]. For the definition of DALI we have built under many respects upon our past work about meta-reasoning and reflection in logic programming languages [12,13,14,15,16]. In this work in particular, issues related to meta-level representation of predicates, atoms and rules are discussed in depth.
Logic-Based Specification Languages for Intelligent Software Agents
Theory and Practice of Logic Programming - TPLP, 2004
The research field of Agent-Oriented Software Engineering (AOSE) aims to find abstractions, languages, methodologies and toolkits for modeling, verifying, validating and prototyping complex applications conceptualized as Multiagent Systems (MASs). A very lively research sub-field studies how formal methods can be used for AOSE. This paper presents a detailed survey of six logic-based executable agent specification languages that have been chosen for their potential to be integrated in our ARPEGGIO project, an open framework for specifying and prototyping a MAS. The six languages are ConGolog, AGENT-0, the IMPACT agent programming language, Dylog, Concurrent METATEM and E hhf . For each executable language, the logic foundations are described and an example of use is shown. A comparison of the six languages and a survey of similar approaches complete the paper, together with considerations of the advantages of using logic-based languages in MAS modeling and prototyping.
Declarative Agent Languages and Technologies VI
Lecture Notes in Computer Science, 2009
In order to facilitate the development of agent-based software, several agent programming languages and architectures, have been created. Plans in these architectures are often self-contained procedures with an associated triggering event and a context condition, while any further information about the consequences of executing a plan is absent. However, agents designed using such an approach have limited flexibility at runtime, and rely on the designer's ability to foresee all relevant situations an agent might have to handle. In order to overcome this limitation, we have created AgentSpeak(PL), an interpreter capable of performing state-space planning to generate new high-level plans. As the planning module creates new plans, the plan library is expanded, improving performance over time. However, for new plans to be useful in the long run, it is critical that the context conditions associated with new plans are carefully generated. In this paper we describe a plan reuse technique aimed at improving an agent's runtime performance by deriving optimal context conditions for new plans, allowing an agent to reuse generated plans as much as possible.
The DALI Logic Programming Agent-Oriented Language
Lecture Notes in Computer Science, 2004
We acknowledge support by the Information Society Technologies programme of the European Commission, Future and Emerging Technologies under the IST-2001-37004 WASP project.
On the formal semantics of speech-act based communication in an agent-oriented programming language
2007
Research on agent communication languages has typically taken the speech acts paradigm as its starting point. Despite their manifest attractions, speech-act models of communication have several serious disadvantages as a foundation for communication in artificial agent systems. In particular, it has proved to be extremely difficult to give a satisfactory semantics to speech-act based agent communication languages. In part, the problem is that speech-act semantics typically make reference to the "mental states" of agents (their beliefs, desires, and intentions), and there is in general no way to attribute such attitudes to arbitrary computational agents. In addition, agent programming languages have only had their semantics formalised for abstract, stand-alone versions, neglecting aspects such as communication primitives. With respect to communication, implemented agent programming languages have tended to be rather ad hoc. This paper addresses both of these problems, by giving semantics to speech-act based messages received by an AgentSpeak agent. AgentSpeak is a logic-based agent programming language which incorporates the main features of the PRS model of reactive planning systems. The paper builds upon a structural operational semantics to AgentSpeak that we developed in previous work. The main contributions of this paper are as follows: an extension of our earlier work on the theoretical foundations of AgentSpeak interpreters; a computationally grounded semantics for (the core) performatives used in speech-act based agent communication languages; and a well-defined extension of AgentSpeak that supports agent communication.
Agent Programming with Declarative Goals
Lecture Notes in Computer Science, 2001
A long and lasting problem in agent research has been to close the gap between agent logics and agent programming frameworks. The main reason for this problem of establishing a link between agent logics and agent programming frameworks is identified and explained by the fact that agent programming frameworks have not incorporated the concept of a declarative goal. Instead, such frameworks have focused mainly on plans or goals-to-do instead of the end goals to be realised which are also called goals-to-be. In this paper, a new programming language called GOAL is introduced which incorporates such declarative goals. The notion of a commitment strategy -one of the main theoretical insights due to agent logics, which explains the relation between beliefs and goals -is used to construct a computational semantics for GOAL. Finally, a proof theory for proving properties of GOAL agents is introduced. Thus, we offer a complete theory of agent programming in the sense that our theory provides both for a programming framework and a programming logic for such agents. An example program is proven correct by using this programming logic.
An argumentative formalism for implementing rational agents
2001
The design of intelligent agents is a key issue for many applications. Although there is no universally accepted de¯nition of intelligence, a notion of rational agency has been proposed as an alternative for the characterization of intelligent agency. Modeling the epistemic state of a rational agent is one of the most di±cult tasks to be addressed in the design process, and its complexity is directly related to the formalism used for representing the knowledge of the agent. This paper presents the main features of Observation-based Defeasible Logic Programming (ODeLP), a formalism tailored for agents that perform defeasible reasoning in dynamic domains. Most agents must have a timely interaction with their environment. Since the cognitive process of rational agents is complex and computationally expensive, this interaction is particularly hard to achieve. To solve this issue, we propose an optimization of the inference process in ODeLP based on the use of precompiled knowledge. This optimization can be e±ciently implemented using concepts from pattern matching algorithms.
Modelling agent interaction in logic programming
1998
We present a logic programming framework implemented over Prolog which is able to model an agent's mental state. An agent is modeled by a set of extended logic programming rules representing the agent's behavior, attitudes (beliefs, intentions, and goals), world knowledge, and temporal and reasoning procedures. At each stage the agents's mental state is defined by the well founded model of the extended logic program plus some constraints. Via this modeling an agent is able to interact with other agents, ...
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.