Reasoning about Actions and Change

In the last several years the computational complexity of classical planning and HTN planning have been studied. But in both cases it is assumed that the planner has complete knowledge about the initial state. Recently, there has been proposal to use 'sensing' actions to plan in presence of incompleteness. In this paper we study the complexity of planning in such cases. In our study we use the action description language proposed in 1993 by M. Gelfond and V. Lifschitz and its extensions. The language allows planning in the situations with complete information. It is known that, if we consider only plans of feasible (polynomial) length, the planning problem for such situations is NP-complete: even checking whether a given objective is attainable from a given initial state is NP-complete. In this paper, we show that the planning problem in presence of incompleteness is indeed harder: it belongs to the next level of complexity hierarchy (in precise terms, it is complete). To overcome the complexity of this problem, C. Baral and T. Son have proposed several approximations. We show that under certain conditions, one of these approximations -O-approximation -makes the problem NP-complete (thus indeed reducing its complexity).

We investigate three parameterized algorithmic schemes for graphical models that can accommodate trade-offs between time and space: 1) AND/OR Adaptive Caching (AOC(i)); 2) Variable Elimination and Conditioning (VEC(i)); and 3) Tree Decomposition with Conditioning (TDC(i)). We show that AOC(i) is better than the vanilla versions of both VEC(i) and TDC(i), and use the guiding principles of AOC(i) to improve the other two schemes. Finally, we show that the improved versions of VEC(i) and TDC(i) can be simulated by AOC(i), which emphasizes the unifying power of the AND/OR framework.

In this paper we develop a general framework that allows for both knowledge acquisition and forgetting in the Situation Calculus. Based on the Scherl and Levesque (Scherl and Levesque 1993) possible worlds approach to knowledge in the Situation Calculus, we allow for both sensing as well as explicit forgetting actions. This model of forgetting is then compared to existing frameworks. In particular we show that forgetting is well-behaved with respect to the contraction operator of the well-known AGM theory of belief revision (Al-chourron, Gardenfors, and Makinson 1985) but that knowledge forgetting is distinct from the more commonly known notion of logical forgetting (Lin and Reiter 1994).

FLUX belongs to the high-level programming lan­ guages for cognitive agents that have been devel­ oped in recent years. Based on the established, general action representation formalism of the Flu­ ent Calculus, FLUX allows to implement complex strategies in a concise and modular fashion. In this paper, we extend the FLUX language to reason about domains involving continuous change and where actions occur concurrently. Using constraint logic programming, we show that this reasoning is performed in an efficient way.

The Fluent Calculus has largely been focused on building agents that work individually. However, agents often need to interact with each other to learn more about their environment as well as to achieve their goals. One form of interaction is by means of communication. Effective, goal-oriented communication requires knowledge of other agents. This paper studies the problem of endowing agents with the ability to reason about the knowledge of other agents and with communication skills. Our formalism for the knowledge of other agents generalizes the existing notion of knowledge in the Fluent Calculus. Communication is treated as actions which are called communicative actions. The specification of communicative actions is based on the formalism for the knowledge of other agents. We have also developed an implementation of the theory as an extension to FLUX, which is a programming method that allows to design intelligent agents based on the Fluent Calculus.

This paper presents the ACE modular framework (Action-Causality-Ethics), a modular and declarative logic-based framework for representing and applying multiple ethical principles. We clearly separate modeling concerns about dynamics and ethics, using reification to explicitly represent generic meta-rules to be contrasted with specific domain knowledge. This allows us to formalize ethical principles as methods for ethical assessment of actions and plans and specify what additional domain information are needed for each of them in addition to the factual description of the unfolding of events. The architecture presented here is based on an action model allowing concurrency and multiple agents and we discuss how this affects the ethical assessment process and allows precise modelling of omission.

We present a generalisation of the Event Calculus, specified in classical logic and implemented in ASP, that facilitates reasoning about non-binary-valued fluents in domains with non-deterministic, triggered, concurrent, and possibly conflicting actions. We show via a case study how this framework may be used as a basis for a "possible-worlds" style approach to epistemic and causal reasoning in a narrative setting. In this framework an agent may gain knowledge about both fluent values and action occurrences through sensing actions, lose knowledge via non-deterministic actions, and represent plans that include conditional actions whose conditions may be initially unknown.

We present a generalization of classical-logic Event Calculus that facilitates reasoning about non-binary-valued fluents in domains with non-deterministic, triggered, concurrent, and possibly conflicting actions. We show how this framework may be used as a basis for a "possible-worlds" style approach to epistemic and causal reasoning in a narrative setting. In this framework an agent may gain knowledge about both fluent values and action occurrences through sensing actions, lose knowledge via non-deterministic actions, and represent plans that include conditional actions whose conditions may be initially unknown.

Forgetting is an important concept in knowledge representation and automated reasoning with widespread applications across a number of disciplines. A standard forgetting operator, characterized in [26] in terms of model-theoretic semantics and primarily focusing on the propositional case, opened up a new research subarea. In this paper, a new operator called weak forgetting, dual to standard forgetting, is introduced and both together are shown to offer a new more uniform perspective on forgetting operators in general. Both the weak and standard forgetting operators are characterized in terms of entailment and inference, rather than a model theoretic semantics. This naturally leads to a useful algorithmic perspective based on quantifier elimination and the use of Ackermman's Lemma and its fixpoint generalization. The strong formal relationship between standard forgetting and strongest necessary conditions and weak forgetting and weakest sufficient conditions is also characterized quite naturally through the entailment-based, inferential perspective used. The framework used to characterize the dual forgetting operators is also generalized to the first-order case and includes useful algorithms for computing first-order forgetting operators in special cases. Practical examples are also included to show the importance of both weak and standard forgetting in modeling and representation.

Golog is a language family with great untapped potential. We argue that it could become a practical and widely usable high-level control language, if only it had an implementation that is usable in a production environment. In this paper, we do not specify another Golog interpreter, but an extensible C++ framework that defines a coherent grammar, developer tool support, internal/external consistency checking with clean error handling, and a simple, portable platform interface. The framework specifically does not implement language semantics. For this purpose we can simply hook into any of the many existing implementations that do very well in implementing language semantics, but fall short in regards to interfacing, portability, usability and practicality in general.

In this paper we present an extension of the action language Golog that allows for using fuzzy notions in non-deterministic argument choices and the reward function in decision-theoretic planning. Often, in decision-theoretic planning, it is cumbersome to specify the set of values to pick from in the non-deterministic-choice-of-argument statement. Also, even for domain experts, it is not always easy to specify a reward function. Instead of providing a finite domain for values in the non-deterministic-choice-of-argument statement in Golog, we now allow for stating the argument domain by simply providing a formula over linguistic terms and fuzzy uents. In Golog’s forward-search DT planning algorithm, these formulas are evaluated in order to find the agent’s optimal policy. We illustrate this in the Diner Domain where the agent needs to calculate the optimal serving order.

In this paper, to overcome the controller singularity problems, a novel neural parameters adaptive law for on-line identification is proposed, such strategy avoid specific adaptive weights zero-crossing. Using a priori knowledge about the real plant, a recurrent neural network is proposed as identifier. Based on the neural identifier model, a discontinuous control law is derived, which combines Block Control and Sliding Modes. The proposed scheme is tested in a induction motor via simulations.

The property that the executability and the effects of an action are determined entirely by the current state or situation is known as the Markov property and is assumed in most formalizations of action. It is not difficult, however, to run into scenarios when the Markov property is not present. We consider removing this assumption from the situation calculus based formalization of actions of Reiter, which forms the basis of the programming language Golog, and define an operator for regressing formulas that quantify over past situations, with respect to such nonMarkovian basic action theories.

Autonomy and agency are a central property in robotic systems, human-machine interfaces, e-business, ambient intelligence and assisted living applications. As the complexity of the situations the autonomous agents may encounter in such contexts is increasing, the decisions those agents make must integrate new issues, e.g. decisions involving contextual ethical considerations. Consequently contributions have proposed recommendations, advice or hard-wired ethical principles for systems of autonomous agents. However, sociotechnical systems are more and more open and decentralized, and involve autonomous artificial agents interacting with other agents, human operators or users. For such systems, novel and original methods are needed to address contextual ethical decision-making, as decisions are likely to interfere with one another. This paper aims at presenting the ETHICAA project (Ethics and Autonomous Agents) whose objective is to define what should be an autonomous entity that could manage ethical conflicts. As a first proposal, we present various practical case studies of ethical conflicts and highlight what their main system and decision features are.

No manuscrito A76 do Mosteiro de Lavra (Monte Athos-f.71b) há uma micrografia com duas cenas. Na cena da parte superior é representada a chamada de Filipe. A interpretação da cena abaixo é difícil. O Sr. Weitzmann, em correlação com a cena acima, interpretou-a como sendo a chamada de Natanael. As dificuldades que enfrentou na interpretação de alguns dos elementos das imagens, deu terreno para um reexame da sua interpretação. A cena tem duas personagens principais: Jesus e um homem de meia-idade que se aproxima dele da direita. Atrás de Jesus estão dois apóstolos e, entre Ele e o homem desconhecido, há uma pequena figura segurando um véu sobre a cabeça, que deve ser interpretada como a personificação da noite. O pergaminho que a pessoa desconhecida está segurando em sua mão esquerda e o vestido que ele usa mostram que o ilustrador queria apresentar alguém pertencente ao Sinédrio Judaico. O fato de o ilustrador colocar entre essas duas personagens principais a personificação da noite,-uma característica incomum em cenas Nova Testamento-leva a pensar que a pessoa que se aproxima de Cristo deva ser Nicodemos, que O visita à noite (Jo 3.1-21).

We present a generalisation of the Event Calculus, specified in classical logic and implemented in ASP, that facilitates reasoning about non-binary-valued fluents in domains with non-deterministic, triggered, concurrent, and possibly conflicting actions. We show via a case study how this framework may be used as a basis for a "possible-worlds" style approach to epistemic and causal reasoning in a narrative setting. In this framework an agent may gain knowledge about both fluent values and action occurrences through sensing actions, lose knowledge via non-deterministic actions, and represent plans that include conditional actions whose conditions may be initially unknown.

We present a generalization of classical-logic Event Calculus that facilitates reasoning about non-binary-valued fluents in domains with non-deterministic, triggered, concurrent, and possibly conflicting actions. We show how this framework may be used as a basis for a "possible-worlds" style approach to epistemic and causal reasoning in a narrative setting. In this framework an agent may gain knowledge about both fluent values and action occurrences through sensing actions, lose knowledge via non-deterministic actions, and represent plans that include conditional actions whose conditions may be initially unknown.

Golog is a language family with great untapped potential. We argue that it could become a practical and widely usable high-level control language, if only it had an implementation that is usable in a production environment. In this paper, we do not specify another Golog interpreter, but an extensible C++ framework that defines a coherent grammar, developer tool support, internal/external consistency checking with clean error handling, and a simple, portable platform interface. The framework specifically does not implement language semantics. For this purpose we can simply hook into any of the many existing implementations that do very well in implementing language semantics, but fall short in regards to interfacing, portability, usability and practicality in general.

The field of Cognitive Robotics aims at intelligent decision making of autonomous robots. It has matured over the last 25 or so years quite a bit. That is, a number of high-level control languages and architectures have emerged from the field. One concern in this regard is the action language GOLOG. GOLOG has been used in a rather large number of applications as a high-level control language ranging from intelligent service robots to soccer robots. For the lower level robot software, the Robot Operating System (ROS) has been around for more than a decade now and it has developed into the standard middleware for robot applications. ROS provides a large number of packages for standard tasks in robotics like localisation, navigation, and object recognition. Interestingly enough, only little work within ROS has gone into the high-level control of robots. In this paper, we describe our approach to marry the GOLOG action language with ROS. In particular, we present our architecture on integrating golog++, which is based on the GOLOG dialect Readylog, with the Robot Operating System. With an example application on the Pepper service robot, we show how primitive actions can be easily mapped to the ROS ActionLib framework and present our control architecture in detail.

In this paper we present an extension of the action language Golog that allows for using fuzzy notions in non-deterministic argument choices and the reward function in decisiontheoretic planning. Often, in decision-theoretic planning, it is cumbersome to specify the set of values to pick from in the non-deterministic-choice-of-argument statement. Also, even for domain experts, it is not always easy to specify a reward function. Instead of providing a finite domain for values in the non-deterministic-choice-of-argument statement in Golog, we now allow for stating the argument domain by simply providing a formula over linguistic terms and fuzzy fluents. In Golog's forward-search DT planning algorithm, these formulas are evaluated in order to find the agent's optimal policy. We illustrate this in the Diner Domain where the agent needs to calculate the optimal serving order.

High-level behaviour specification of an intelligent autonomous agent or robot is a non-trivial task. Various approaches exist some of which try to combine different paradigms like programming and planning. In this paper, we show how to integrate fuzzy logic controllers into the logic-based programming language Golog. Golog already allows for combining programming and planning. By adding the instrument of fuzzy controllers we provide the means to have a natural specification of rules for tasks that require a high amount of reactivity. Since the facilities already present in Golog remain, we add to an already powerful framework thus expanding the applicability of Golog for high-level behaviour specification of a robot or agent.

To achieve any meaningful tasks, a robot needs some form of task-level executive which acquires knowledge, reasons or plans, and performs and monitors actions. A formal approach for such agent programming is the GOLOG agent programming language. GOLOG is based on a first-order logic representation, and a drawback of common implementations is that in order to program agents, also knowledge of Prolog functionality is typically needed. In this paper, we present a prototype implementation of YAGI, a language rooted in GOLOG that offers a practical subset of the rich GOLOG framework in a more familiar syntax. Bridging imperativestyle programming with an action-based specification, YAGI is more accessible to developers and provides a better ground for robot task-level executives. Moreover, we developed bindings for popular robotics frameworks such as ROS and Fawkes. As a proof of concept we present a YAGI-based agent for the RoboCup Logistics League which shows the expressiveness and the possibility to easily embed YAGI into robot applications.

Computer games and the accompanying entertainment industry branch has become a major market factor. AI techniques are successfully applied to tasks like path planning or intelligent swarm behavior. On the decision-making level the state of the art are state machines with a xed set of behaviors. The perception of the computer player is perfect. They exactly know where the other players are located, even if they cannot see them. This approach seems to be limited for intelligent decision making. Therefore, we propose another approach. We use a variant of the logic-based action language GOLOG for implementing so-called game bots in the UNREAL TOURNAMENT 2004 environment. First results show that we can compete with the omniscience game bots in the Unreal domain.

Among many approaches to address the high-level decision making problem for autonomous robots and agents, the robot program¬ming and plan language Golog follows a logic-based deliberative approach, and its successors were successfully deployed in a number of robotics applications over the past ten years. Usually, Golog interpreter are implemented in Prolog, which is not available for our target plat¬form, the bi-ped robot platform Nao. In this paper we sketch our first approach towards a prototype implementation of a Golog interpreter in the scripting language Lua. With the example of the elevator domain we discuss how the basic action theory is specified and how we implemented fluent regression in Lua. One possible advantage of the availability of a Non-Prolog implementation of Golog could be that Golog becomes avail¬able on a larger number of platforms, and also becomes more attractive for roboticists outside the Cognitive Robotics community.

The field of Cognitive Robotics aims at intelligent decision making of autonomous robots. It has matured over the last 25 or so years quite a bit. That is, a number of high-level control languages and architectures have emerged from the field. One concern in this regard is the action language GOLOG. GOLOG has been used in a rather large number of applications as a high-level control language ranging from intelligent service robots to soccer robots. For the lower level robot software, the Robot Operating System (ROS) has been around for more than a decade now and it has developed into the standard middleware for robot applications. ROS provides a large number of packages for standard tasks in robotics like localisation, navigation, and object recognition. Interestingly enough, only little work within ROS has gone into the high-level control of robots. In this paper, we describe our approach to marry the GOLOG action language with ROS. In particular, we present our architecture on integrating golog++, which is based on the GOLOG dialect Readylog, with the Robot Operating System. With an example application on the Pepper service robot, we show how primitive actions can be easily mapped to the ROS ActionLib framework and present our control architecture in detail.

Golog is a language family with great untapped potential. We argue that it could become a practical and widely usable high-level control language, if only it had an implementation that is usable in a production environment. In this paper, we do not specify another Golog interpreter, but an extensible C++ framework that defines a coherent grammar, developer tool support, internal/external consistency checking with clean error handling, and a simple, portable platform interface. The framework specifically does not implement language semantics. For this purpose we can simply hook into any of the many existing implementations that do very well in implementing language semantics, but fall short in regards to interfacing, portability, usability and practicality in general.

In this paper we present an extension of the action language Golog that allows for using fuzzy notions in non-deterministic argument choices and the reward function in decision-theoretic planning. Often, in decision-theoretic planning, it is cumbersome to specify the set of values to pick from in the non-deterministic-choice-of-argument statement. Also, even for domain experts, it is not always easy to specify a reward function. Instead of providing a finite domain for values in the non-deterministic-choice-of-argument statement in Golog, we now allow for stating the argument domain by simply providing a formula over linguistic terms and fuzzy uents. In Golog’s forward-search DT planning algorithm, these formulas are evaluated in order to find the agent’s optimal policy. We illustrate this in the Diner Domain where the agent needs to calculate the optimal serving order.

High-level behaviour specification of an intelligent autonomous agent or robot is a non-trivial task. Various approaches exist some of which try to combine different paradigms like programming and planning. In this paper, we show how to integrate fuzzy logic controllers into the logic-based programming language Golog. Golog already allows for combining programming and planning. By adding the instrument of fuzzy controllers we provide the means to have a natural specification of rules for tasks that require a high amount of reactivity. Since the facilities already present in Golog remain, we add to an already powerful framework thus expanding the applicability of Golog for high-level behaviour specification of a robot or agent.

We design a representation based on the situation calculus that facilitates development, maintenance and elaboration of very large taxonomies of actions. It leads to a modular basic action theories (BATs) for reasoning about actions more compact than Reiter's current representation ...

A rational agent exploring a complex and dynamic environment with incomplete information needs cognitive capabilities, e.g. planning, in addition to its perception and reaction for basic functionalities. However, mere planning, i.e., reasoning about sequences of actions, is not sufficient to solve problems in such complex environment. This is because (i) agents need to execute actions while they plan, (ii) they must gather and interpret sensor information, (iii) revise their world model, and (iv) adapt their own goals during a task. The knowledge representation and non monotonic reasoning area has shown the advantage of using logical formalisms to specify rational agents for complex robot applications, also called cognitive robotics applications. An example of such formalism is the Golog language and its different dialects. What those areas are still missing is implementational testbeds to evaluate existing theories. Since practical experimentation highlights the need for the improvement of existing formal theories at the ontological level. This work presents a logic-based implementation of an agent for the Wumpus World domain, which can be envisaged as a simplified model of an agent that reasons logically about its actions and sensor information in the presence of incomplete knowledge. Through a complete implementation of an agent in a real robot, the Lego R MindStorms TM robot, we show some experiments to verify that the Wumpus World can be an implementational testbed used to identify difficulties in transforming theory into operational solutions.

The study of drug metabolism is significant to establish the drug profile. The pharmacokinetics of the drug determines the concentration of the drug in enumerable parts of the human body. In this paper, we develop a relationship between such processes of Pharmacokinetics with mathematical formulations using the tools from fractional calculus. As per the literature, for treating a type-II diabetes mellitus, Metformin is being used extensively. The Metformin metabolism encompasses a large variety of metabolic processes in different parts of the body. In the present study, we formulate and analyze a model of the Metformin kinetics taking into account a homogenous dimensionality in Caputo sense. The Banach and Schauder fixed point theorems are employed to explore the uniqueness and existence results. The equilibrium point, asymptotic stability for the given parameters, and Lyapunov stable solutions are also discussed. Further, the Ulam's type stability is explored for generalized model. Finally, the Adam-Bashful-Mouton (A-B-M) method in generalized form is used to validate the conclusions.

DTGolog, a decision-theoretic agent programming language based on the situation calculus, was proposed to ease some of the computational difficulties associated with Markov Decision Processes (MDPs) by using natural ordering constraints on execution of actions. Using DTGolog, domain specific constraints on a set of policies can be expressed in a high-level program to reduce significantly computations required to find a policy optimal in this set. We explore whether the DTGolog framework can be used to evaluate different ...

Process Management Systems (PMSs) can be used not only in classical business scenarios, but also in highly dynamic and uncertain environments, for example, in supporting operators during Emergency Management for coordinating their activities. In such challenging situations, processes should be adapted in order to cope with anomalous situations, including connection anomalies and task faults. This requires the provision of intelligent support for the planning and enactment of complex processes, that allows to capture the knowledge about the dynamic context of a process. In this paper, we show how this knowledge, together with information about the capabilities of the available actors, may be specified and used to not only to support the selection of an appropriate set of agents to fill the roles in a given task, but also to solve the problem of adaptivity. The paper describes a first prototype of a PMS based on well-known Artificial Intelligence Techniques and how it can be extended to tackle adaptation.

Based on weighted possible-world semantics, Belle and Lakemeyer recently proposed the logic DS, a probabilistic extension of a modal variant of the situation calculus with a model of belief. The logic has many desirable properties like full introspection and it is able to precisely capture the beliefs of a probabilistic knowledge base in terms of the notion of only-believing. While the proposal is intuitively appealing, it is unclear how to do planning with such logic. The reason behind this is that the logic lacks projection reasoning mechanisms. Projection reasoning, in general, is to decide what holds after actions. Two main solutions to projection exist: regression and progression. Roughly, regression reduces a query about the future to a query about the initial state while progression, on the other hand, changes the initial state according to the effects of actions and then checks whether the formula holds in the updated state. In this paper, we study projection by progression ...

We present a control system for autonomous manipulators based on a theory of actions integrated with a theory of perception and failures. The theory of actions, perception and failures is defined in the Situation Calculus, a logical language that allows the representation of dynamic domains. We assume that an au- tonomous agent is provided with a set of possible goals.

Autonomy and agency are a central property in robotic systems, human-machine interfaces, e-business, ambient intelligence and assisted living applications. As the complexity of the situations the autonomous agents may encounter in such contexts is increasing, the decisions those agents make must integrate new issues, e.g. decisions involving contextual ethical considerations. Consequently contributions have proposed recommendations, advice or hard-wired ethical principles for systems of autonomous agents. However, sociotechnical systems are more and more open and decentralized, and involve autonomous artificial agents interacting with other agents, human operators or users. For such systems, novel and original methods are needed to address contextual ethical decision-making, as decisions are likely to interfere with one another. This paper aims at presenting the ETHICAA project (Ethics and Autonomous Agents) whose objective is to define what should be an autonomous entity that could manage ethical conflicts. As a first proposal, we present various practical case studies of ethical conflicts and highlight what their main system and decision features are.

We focus on a rich axiomatization for actions in the situation calculus that includes, among other features, a solution to the frame problem for deterministic actions. Our work is foundational in nature, directed at simplifying the entailment problem for these axioms. Specifically, we make four contributions to the metatheory of situation calculus axiomatizations of dynamical systems: (1) We prove that the above-mentioned axiomatization for actions has a relative satisfiability property; the full axiomatization is satisfiable iff the axioms for the initial state are. (2)We define the concept of regression relative to these axioms, and prove a soundness and completeness theorem for a regression-based approach to the entailment problem for a wide class of queries. (3) Our formalization of the situation calculus requires certain foundational axioms specifying the domain of situations. These include an induction axiom, whose presence complicates human and automated reasoning in the situ...

ABSTRACT. We propose a theory for reasoning about actions based on order-sorted predicate logic where one can consider an elaborate taxonomy of objects. We are interested in the projection problem: whether a statement is true after executing a sequence of actions. To solve it we design a regression operator takes advantage of well-sorted unification between terms. We show that answering projection queries in our logical theories is sound and complete wrt answering similar queries in Reiter’s basic action theories. This proves correctness of our approach. Moreover, we demonstrate that our regression operator based on order-sorted logic can provide significant computational advantages in comparison to Reiter’s regression operator. 1

We propose a theory for reasoning about actions based on order-so rt d predicate logic where one can consider an elaborate taxonomy of objects . We are interested in the projection problem: whether a statement is true after executing a sequence of actions. To solve it we design a regression operator takes advantage of well-sorted unification between terms. We show that answering projection queries in ou r logical theories is sound and complete wrt answering similar queries in Reiter’s ba sic action theories. This proves correctness of our approach. Moreover, we demonstrate that our regression operator based on order-sorted logic can provide signific ant computational advantages in comparison to Reiter’s regression operator.

Pearl's probabilistic causal model has been used in many domains to reason about causality. Pearl's treatment of actions is very different from the way actions are represented explicitly in action languages. In this paper we show how to encode Pearl's probabilistic causal model in the action language PAL thus relating this two distinct approaches to reasoning about actions.

In this paper, we discuss the weakness of current action languages for sensing actions with respect to modeling domains with multi-valued fluents. To address this problem, we propose a language with sensing actions and multi-valued fluents, called AMK , provide a transition function based semantics for the language, and demonstrate its use through several examples from the literature. We then define the entailment relationship between action theories and queries in AM K , denoted by |= AM K , and discuss some properties about AMK .

This diploma thesis is dealing with the design of caterpillar-shaped inflatable wings with supporting tethers based on the airfoil NACA4318, using Computational Fluid Dynamics (CFD) and Computational Solid Mechanics (CSM) software and Fluid Structure Interaction methods. The first goal of this thesis is the enrichment of the classic caterpillar-shaped wing's geometry with supports sewn to areas close to the leading and trailing edges of the wing where tethers would be attached. The key concept is that the structural loads exerted from the tether to the wing's fastening surface, would scatter to the fastening area, not only the junction points between tethers and wing. As a result, shape deformation caused by large aerodynamic loads, which might damage the aerodynamic performance of the airfoil is avoided, and the maximum wing deformation is reduced. Then, a new caterpillar-shaped wing geometry is designed and subjected to structural and aeroelastic analysis. This wing consists of an internal hollow inflatable bar which is sewn on the transversal baffles that separate the wing into multiple airtight compartments. This bar is inflated at a higher pressure than the wing compartments. This design variation, aims to use the inflatable bar as an extra structural reinforcement tool. Additionally, using thinner structural material and larger internal pressure value, an amount of the total weight can be counterbalanced by the extra inflation. In all the cases mentioned above, studies on the material properties, the internal pressure value and the material thickness are carried out. Then comparisons are performed based on the same structural data, between the cases with and without sewn tether overgrowth supports, using as criterion measures the maximum deformation and the aerodynamic behavior of the wing (lift) throughout the aeroelastic cycles. Additional comparisons are made among wings enhanced with and without the inflatable bar, with the overall wing's weight as an additional criterion. During the studies, full exploitation of the airfoil NACA4318 profile is made, since the circular profiles of the caterpillar-shaped vii wing make the wing's surface bumpy and affect the aerodynamic performance. In order to perform the aeroelastic analysis, the PUMA (Parallel solver, for Unstructured grids, for Multi-blade row computations, including Adjoint) GPU-enabled CFD solver by the Parallel CFD & Optimization Unit (PCOpt/NTUA) is used for the flow prediction and the aerodynamic load computation. For the structural analysis, the commercial s/w MAPDL (Mechanical ANSYS Parametric Design Language by ANSYS) is used, since this can be executed in batch mode from a script and can readily be integrated into an aeroelastic analysis loop.

In the last decade, many commercial video games have used planners instead of classical Behavior Trees or Finite State Machines to define agent behaviors. Planners allow looking ahead in time and can prevent some problems of purely reactive systems. Furthermore, some of them allow coordination of multiple agents. However, implementing a planner for highlydynamic environments like video games is a difficult task. This work aims to provide an overview of different elements of planners and the problems that developers might have when dealing with them. We identify the major areas of plan creation and execution, trying to guide developers through the process of implementing a planner and discuss possible solutions for problems that may arise in the following areas: environment, planning domain, goals, agents, actions, plan creation and plan execution processes. Giving insights into multiple commercial games, we show different possibilities of solving such problems and discuss which solutions are better suited under specific circumstances and why some academic approaches find a limited application in the context of commercial titles.

This paper investigates the use of high-level action languages for designing ethical autonomous agents. It proposes a novel and modular logic-based framework for representing and reasoning over a variety of ethical theories, based on a modified version of the Event Calculus and implemented in Answer Set Programming. The ethical decision-making process is conceived of as a multi-step procedure captured by four types of interdependent models which allow the agent to assess its environment, reason over its accountability and make ethically informed choices. The overarching ambition of the presented research is twofold. First, to allow the systematic representation of an unbounded number of ethical reasoning processes, through a framework that is adaptable and extensible by virtue of its designed hierarchisation and standard syntax. Second, to avoid the pitfall of much research in current computational ethics that too readily embed moral information within computational engines, thereby feeding agents with atomic answers that fail to truly represent underlying dynamics. We aim instead to comprehensively displace the burden of moral reasoning from the programmer to the program itself.

In this paper, 4 we investigate bounded action theories in the situation calculus. A bounded action theory is one which entails that, in every situation, the number of object tuples in the extension of fluents is bounded by a given constant, although such extensions are in general different across the infinitely many situations. We argue that such theories are common in applications, either because facts do not persist indefinitely or because the agent eventually forgets some facts, as new ones are learnt. We discuss various classes of bounded action theories. Then we show that verification of a powerful first-order variant of the µcalculus is decidable for such theories. Notably, this variant supports a controlled form of quantification across situations. We also show that through verification, we can actually check whether an arbitrary action theory maintains boundedness.

In this paper, 4 we investigate bounded action theories in the situation calculus. A bounded action theory is one which entails that, in every situation, the number of object tuples in the extension of fluents is bounded by a given constant, although such extensions are in general different across the infinitely many situations. We argue that such theories are common in applications, either because facts do not persist indefinitely or because the agent eventually forgets some facts, as new ones are learnt. We discuss various classes of bounded action theories. Then we show that verification of a powerful first-order variant of the µcalculus is decidable for such theories. Notably, this variant supports a controlled form of quantification across situations. We also show that through verification, we can actually check whether an arbitrary action theory maintains boundedness.

This paper proposes a new logic programming language called GOLOG whose interpreter automatically maintains an explicit representation of the dynamic world being modeled, on the basis of user supplied axioms about the preconditions and e ects of actions and the initial state of the world. This allows programs to reason about the state of the world and consider the e ects of various possible courses of action before committing to a particular behavior. The net e ect is that programs may be written at a much higher level of abstraction than is usually possible. The language appears well suited for applications in high level control of robots and industrial processes, intelligent software agents, discrete event simulation, etc. It is based on a formal theory of action speci ed in an extended version of the situation calculus. A prototype implementation in Prolog has been developed. / This research received nancial support from the Information Technology Research Center (Ontario, Canada), the Institute for Robotics and Intelligent Systems (Canada), and the Natural Science and Engineering Research Council (Canada). Levesque and Reiter are fellows of the Canadian Institute for Advanced Research.

A robot must often react to events in its environment and exceptional conditions by suspending or abandoning its current plan and selecting a new plan that is an appropriate response to the event. This paper describes how high-level controllers for robots that are reactive in this sense can conveniently be implemented in ConGolog, a new logic-based robot/agent programming language. Reactivity is achieved by exploiting ConGolog's prioritized concurrent processes and interrupts facilities. The language also provides nondeterministic constructs that support a form of planning. Program execution relies on a declarative domain theory to model the state of the robot and its environment. The approach is illustrated with a mail delivery application.