The demo presents a tool that visualizes the acting of planning agents in dynamic environments that might be modified by "acts of nature'', The purpose of this tool is to better understand the behavior of the agent, debug agent's behavior, and for making the underlying planning concepts accessible to wider audience.

The increase in the urban population over the past decades led to an increase in the number of vehicles in urban road networks, especially in larger metropolitan areas. The problem is exacerbated during rush hours and when an unexpected or rare event occurs (e.g. accidents, concerts). Existing traffic routing methods, including those embedded in modern navigation systems, consider Dynamic User Optimal (DUO) traffic routing that generates routes in a decentralised fashion. Centralized traffic routing, which we consider in this paper, benefits from the global perspective of the situation that can utilise the road network more effectively. We propose a technique leveraging Mixed-Integer Programming (MIP) for distributing vehicles in the road network while minimizing traffic intensity on road segments. Our evaluation shows the potential of the proposed technique for centralized traffic routing.

Planning against nature is a recent concept describing planning and acting in environments in which nature can non-deterministically trigger exogenous events, where the agent has to consider that the state of the environment might change without its consent. Therefore, the agent has to make sure that it eventually achieves its goal (if possible) despite the acts of nature. In this paper, we leverage the recent concept of robust plans, which assumes that nature might act as an adversary, to design a method for generating linear execution strategies, which assume that nature acts randomly but fairly. In particular, we consider events that have to eventually occur and facts that even if deleted by events will be eventually reachieved by (other) events (because nature acts fairly). To improve the efficiency of both robust plan and linear execution strategy generation methods, we provide an approach allowing us to adopt delete-relaxed heuristics that are used in classical planning.

Automated planning requires explicit domain knowledge, typically represented in PDDL, to generate effective solutions. The process of formulating, maintaining, and validating this knowledge is the cornerstone of Knowledge Engineering for Planning and Scheduling (KEPS). Although Large Language Models (LLMs) have shown promise for automated planning tasks, and are gaining popularity in the field, their impact on KEPS remains unexplored. In this paper we investigate the potential of LLMs to streamline and enhance the KEPS field, by taking a close look at the processes used to develop explicit symbolic knowledge models in safety-related applications. The paper's findings are that while LLMs can assist in knowledge acquisition and formulation, human domain expertise and external symbolic validators remain indispensable for ensuring correctness, operationality and completeness of planning applications.

Transformer-based architectures have revolutionized natural language processing and represent a significant promise for advancing policy learning in generalized planning tasks. In particular, PlanGPT demonstrated remarkable results in generating solution plans in different planning domains. For each domain, it is trained on a domain-specific dataset composed of randomly generated planning problems and corresponding solution plans. This work proposes a novel extension to the PlanGPT framework by incorporating macro-actions, high-level actions that encapsulate sequences of primitive actions, which are a well-established technique in classical planning known to improve planning efficiency by guiding exploration through shortcuts. Leveraging this concept, we investigate the impact of macro-actions on the learning process of PlanGPT and whether they mitigate the occurrence of violated preconditions caused by complex object relationships, particularly in domains where these interactions frequently lead to invalid plans due to precondition violations. Experimental results indicate that integrating macroactions improves coverage in several challenging domains and reduces generation time, highlighting the enhanced learning capabilities of PlanGPT when supported by macro-actions.

In this demonstration, we present a system that automates regression testing for video games using automated planning techniques. Traditional test scripts are a common method for testing both video games and software in general. While effective, they require manual creation and frequent updates throughout development, making the process labor-intensive. Our system eliminates this burden by automatically generating and maintaining test scripts. The test engineer only needs to define the game’s rules using the Planning Domain Definition Language (PDDL) and specify initial states and goals for individual test cases. This significantly reduces human effort while ensuring test scripts remain up to date. Additionally, our system integrates with game engine editors—supporting both Unity and Unreal to execute and evaluate test cases directly within the game. It collects detailed logs, telemetry data, and video recordings, allowing users to review test results efficiently.

With the recent interest in the reversibility of action effects, i.e., whether the effects of the action can be undone by applying other actions, the question arose how hard it is to reverse an action in a non-deterministic domain. With the use of phi-reversibility, the paper investigates the computational complexity of weak and strong non-deterministic action reversibility in fully observable non-deterministic domains, showing PSPACE-completeness for all weak variants in question and EXP-hardness and EXP, or NEXP memberships for strong variants.

This extended abstract presents new empirical results of recently introduced Critical Section Macro-operators (CSMs) whose design is inspired by using lockable resources in critical sections in parallel computing. In particular, we provide results on the IPC-2023 learning track domains and four planners, including the winner of the agile track of the IPC-2023 and a lifted planner.

While planning and acting in environments in which nature can trigger non-deterministic events, the agent has to consider that the state of the environment might change without its consent. Practically, it means that the agent has to make sure that it eventually achieves its goal (if possible) despite the acts of nature. In this paper, we first formalize the semantics of such problems in Alternating-time Temporal Logic, which allows us to prove some theoretical properties of different types of solutions. Then, we focus on linear execution strategies, which resemble classical plans in that they follow a fixed sequence of actions. We show that any problem that can be solved by a linear execution strategy can be solved by a particular form of linear execution strategy which assigns wait-for preconditions to each action in the plan that specifies when to execute that action. Then, we propose a sound algorithm that verifies a sequence of actions and assigns wait-for preconditions to them by leveraging abstraction.

Classical planning looks for a sequence of actions that transform the initial state of the environment into a goal state. Studying whether the effects of an action can be undone by a sequence of other actions, that is, action reversibility, is beneficial, for example, in determining whether an action is safe to apply. This paper deals with action reversibility of non-deterministic actions, i.e., actions whose application might result in different outcomes. Inspired by the established notions of weak and strong plans in non-deterministic (or FOND) planning, we define the notions of weak and strong reversibility for non-deterministic actions. We then focus on the universality and uniformity of action reversibility, that is, whether we can always undo all possible effects of the action by the same means (i.e., policy), or whether some of the effects can never be undone. We show how these classes of problems can be solved via classical or FOND planning and evaluate our approaches on FOND benchmark domains.

Existing planning action domain model acquisition approaches consider different types of state traces from which they learn. The differences in state traces refer to the level of observability of state changes (from full to none) and whether the observations have some noise (the state changes might be inaccurately logged). However, to the best of our knowledge, all the existing approaches consider state traces in which each state change corresponds to an action specified by its name and all its parameters (all objects that are relevant to the action). Furthermore, the names and types of all the parameters of the actions to be learned are given. These assumptions are too strong. In this paper, we propose a method that learns action schema from state traces with fully observable state changes but without the parameters of actions responsible for the state changes (only action names are part of the state traces). Although we can easily deduce the number (and names) of the actions that will be in the learned domain model, we still need to deduce the number and types of the parameters of each action alongside its precondition and effects. We show that this task is at least as hard as graph isomorphism. However, our experimental evaluation on a large collection of IPC benchmarks shows that our approach is still practical as the number of required parameters is usually small. Compared to the state-of-the-art learning tools SAM and Extended SAM our new algorithm can provide better results in terms of learning action models more similar to reference models, even though it uses less information and has fewer restrictions on the input traces.

Planning and acting under the presence of exogenous events brings a number of challenges as events might modify the environment without the consent of the acting agent. Consequently, the agent's plan might get disrupted, agent's goals might no longer be achievable, or, worse, the agent might suffer some damage (e.g. damage to the robot). Although policies, mapping states to appropriate actions to take, can describe, in theory, how the agent should act, they might be difficult to explain and understand for humans in the loop. In this paper, we describe the concept of robust plans that are sequences of actions that can be successfully executed regardless of event occurrence. Robust plans are easier to understand (than policies). We present two methods for verifying whether a sequence of actions is a robust plan, one based on compilation to classical planning, and the other based on leveraging delete-relaxation. We also present a method for generating robust plans that is derived from the "relaxation" verification method. The methods are evaluated on three domains.

This extended abstract from the area of automated planning discusses work on Attributed Transition-Based Domain Control Knowledge (ATB-DCK). ATB-DCK, roughly speaking, represents the "grammar" of solution plans that guides the search. ATB-DCK is expressed by a finite state automaton with attributed states, referring to specific states of objects, connected by transitions imposing constraints on action applicability. This representation stays on side of the planning domain model, but it can be compiled into a classical planning task and thus it complements domain-independent planning techniques. Results on several benchmark domains from the International Planning Competitions show that the use of ATB-DCK often considerably improves efficiency of existing state-of-the-art planning engines.

In the light of revolutionary technologies such as connected autonomous vehicles, centralised vehicle (or traffic) routing is attracting a growing interest as an effective method to tackle traffic congestion in urban areas, which causes enormous economic losses. Whereas potential benefits of centralised vehicle routing techniques are huge, they are not yet mature enough to be deployed in (large) urban areas. The major issue preventing their deployment being the lack of scalability.This position paper provides an all encompassing discussion around how the scalability issue for centralised vehicle (traffic) routing approaches might be addressed. In particular, we elaborate on how the model of the environment (the road network and the traffic) can be reasonably abstracted to allow simplified yet meaningful reasoning. Then, we provide an overview of relevant classes of decision-making techniques and elaborate how they can be applied to tackle the problem. At the end, we present our perspective on how different types of decision-making techniques can be effectively combined such that they can deal with the scalability issue while maintaining reasonable quality of assigned routes.

In a nutshell, Automated Planning deals with finding sequences of actions that achieve a required goal while scheduling deals with allocating activities on (limited) resources meeting specified constraints. Activities, however, might resemble actions in planning as we might capture what they can produce and under what conditions. That said, the "planning'' part represents selecting proper activities as well as their ordering which the "scheduling'' part represents allocating the activities to the resources. This extended abstract formalises the concept of "combined" planning and scheduling tasks and proposes the idea how these tasks can be compiled to classical planning tasks. Our idea is evaluated on tasks involving scheduling activities on reconfigurable machines.

Effective planning while competing for limited resources is crucial in many real-world applications such as on-demand transport companies competing for passengers. Planning techniques therefore have to take into account possible actions of an adversarial agent. Such a challenge that can be tackled by leveraging game-theoretical methods such as Double Oracle. This paper aims at the scalability issues arising from combining planning techniques with Double Oracle. In particular, we propose an abstraction-based heuristic for deciding how resources will be collected (e.g. which car goes for which passenger and in which order) and we propose a method for decomposing planning tasks into smaller ones (e.g. generate plans for each car separately). Our empirical evaluation shows that our proposed approach considerably improves scalability compared to the state-of-the-art techniques.

Sampling-based motion planning algorithms such as Rapidly exploring Random Trees (RRTs) have been used in robotic applications for a long time. In this paper, we propose a method that combines deep learning with RRT* method. We use a neural network to learn a sample strategy for RRT*.We evaluate Deep RRT* in a collection of 2D scenarios. The results demonstrate that our algorithm could find collision-free paths efficiently and fast, and can be generalized to unseen environments.

Planning with global state constraints is an extension of classical planning such that some properties of each state are derived via a set of rules common to all states. This approach is important for the application of planning techniques in manipulating cyber-physical systems, and has been shown to be effective in practice. Urban Traffic Control (UTC) deals with the control and management of traffic in urban regions, and includes the optimisation of traffic signals configuration to minimise traffic congestion and travel delays. In this paper, we briefly introduce how to cast the UTC problem into the formalism of planning with global state constraints, and we perform a preliminary experimental evaluation considering significant scenarios taken from the literature, and a new one based on real-world data. The results show that the approach is feasible, and the quality of generated solutions has been confirmed in simulation using existing symbolic models.

Macro-operators (macros) are a well-known technique for enhancing performance of planning engines by providing “short-cuts” in the state space. Existing macro learning systems usually generate macros by considering most frequent action sequences in training plans. Unfortunately, frequent action sequences might not capture meaningful activities as a whole, leading to a limited beneficial impact for the planning process. In this paper, inspired by resource locking in critical sections in parallel computing, we propose a technique that generates macros able to capture whole activities in which limited resources (e.g., a robotic hand, or a truck) are used. Specifically, such a Critical Section macro starts by locking the resource (e.g., grabbing an object), continues by using the resource (e.g., manipulating the object) and finishes by releasing the resource (e.g., dropping the object). Hence, such a macro bridges states in which the resource is locked and cannot be used. We also introduce versions of Critical Section macros dealing with multiple resources and phased locks. Usefulness of macros is evaluated using a range of state-of-the-art planners, and a large number of benchmarks from the deterministic and learning tracks of recent editions of the International Planning Competition.

In dynamic environments, external events might occur and modify the environment without consent of intelligent agents. Plans of the agents might hence be disrupted and, worse, the agents might end up in dead-end states and no longer be able to achieve their goals. Hence, the agents should monitor the environment during plan execution and if they encounter a dangerous situation they should (reactively) act to escape from it.In this paper, we introduce the notion of dangerous states that the agent might encounter during its plan execution in dynamic environments. We present a method for computing lower bound of dangerousness of a state after applying a sequence of actions. That method is leveraged in identifying situations in which the agent has to start acting to avoid danger. We present two types of such behaviour – purely reactive and proactive (eliminating the source of danger). The introduced concepts for planning with dangerous states are implemented and tested in two scenarios – a simple RPG-like game, called Dark Dungeon, and a platform game inspired by the Perestroika video game. The results show that reasoning with dangerous states achieves better success rate (reaching the goals) than naive planning or rule-based techniques.

Domain-independent planning decouples a planning task specification from planning engines. As the specification is usually describing only the physics of the environment, actions and a goal, the planning engines being generic solvers designed to solve any planning task tend to struggle with tasks that can be easily solved by domain-specific algorithms. Additional control knowledge can, to large extent, bridge such a performance gap. Instead of providing a specific planner supporting a given form of control knowledge, control knowledge can be directly encoded within the planning task specification and thus can be exploited by generic planners. In this paper, we proposeAttributed Transition-Based Domain Control Knowledge (ATB-DCK)that is represented by a finite state automaton with attributed states, referring to specific states of objects, connected by transitions imposing constraints on action applicability. ATB-DCK, roughly speaking, represents the “grammar” of solution plans that guides the search. We show that ATB-DCK can be compiled into a classical planning task and thus it complements domain-independent planning techniques. Using several domains from the International Planning Competitions as benchmarks, we demonstrate that this approach often considerably improves efficiency of existing state-of-the-art planning engines.

The problem of action reversibility studies whether effects of a given action can be reversed (or undone) by a sequence of (other) actions. For example, actions whose effects can be reversed cannot lead to dead-ends. In the usual settings, the problem of action reversibility is PSPACE-complete, that is, as hard as deciding plan existence. In this paper, we focus on subclasses of the action reversibility problem, universal and uniform action reversibility, where the former considers all states in which the action in question is applicable, while the latter requires a single reverting action sequence, independent of the considered states. Specifically, we study the relations between projection abstractions and the subclasses of the action reversibility problem and we show that universal uniform reversibility of a given action can be decided on projection consisting of only the variables present in the schema of the action in question.

Planning and acting in dynamic environments deals with non-deterministic events that might change the state of the environment without consent of the agent. In the worst case, some events might cause the agent to become ``trapped'' in a dead-end state, which in practice might mean damage or destruction of the agent. Presence of non-deterministic events often considerably increases the number of alternatives that might occur in a single step and hence traditional non-deterministic planning techniques might not scale. In this paper, we address a class of problems where non-deterministic events represent ``cyclic phenomena''. If they interfere with the agent, they might be dangerous for it (e.g. ships cruising through the area of AUV operations). We present techniques that initially analyse the problem whether it falls within this class by considering the notion of event reversibility and if so, these techniques generate a plan such that encountered unsafe states, in which the ``cyclic phenomena'' might interfere with the agent, can be eventually crossed without any risk of ``falling'' into a dead-end state. Our approach is evaluated in the AUV and Perestroika domains.

Effective plan generation in adversarial environments has to take into account possible actions of adversary agents, i.e., the agent should know what the competitor will likely do. In this paper we propose a novel approach for estimating strategies of the adversary, sampling actions that interfere with the agent's ones. The estimated competitor strategies are used in plan generation by considering that agent's actions have to be applied prior to the ones of the competitor, whose estimated times dictate the agent's deadlines. Missing these deadlines entails additional plan cost.

Abstract In the context of planning and reasoning about actions and change, we call an action reversible when its effects can be reverted by applying other actions, returning to the original state. Renewed interest in this area has led to several results in the context of the PDDL language, widely used for describing planning tasks. In this paper, we propose several solutions to the computational problem of deciding the reversibility of an action. In particular, we leverage an existing translation from PDDL to Answer Set Programming (ASP), and then use several different encodings to tackle the problem of action reversibility for the STRIPS fragment of PDDL. For these, we use ASP, as well as Epistemic Logic Programming (ELP), an extension of ASP with epistemic operators, and compare and contrast their strengths and weaknesses.

Checking whether action effects can be undone is an important question for determining, for instance, whether a planning task has dead-ends. In this paper, we investigate the reversibility of actions, that is, when the effects of an action can be reverted by applying other actions, in order to return to the original state. We propose a broad notion of reversibility that generalizes previously defined versions and investigate interesting properties and relevant restrictions. In particular, we propose the concept of uniform reversibility that guarantees that an action can be reverted independently of the state in which the action was applied, using a so-called reverse plan. In addition, we perform an in-depth investigation of the computational complexity of deciding action reversibility. We show that reversibility checking with polynomial-length reverse plans is harder than polynomial-length planning and that, in case of unrestricted plan length, the PSPACE-hardness of planning is inherited. In order to deal with the high complexity of solving these tasks, we then propose several incomplete algorithms that may be used to compute reverse plans for a relevant subset of states.

Effective and efficient reasoning in adversarial environments is important for many real-world applications ranging from cybersecurity to military operations. Deliberative reasoning techniques, such as Automated Planning, often restrict to static environments where only an agent can make changes by its actions. On the other hand, such techniques are effective and can generate non-trivial solutions. To explicitly reason in environments with an active adversary such as zero-sum games, the game-theoretic framework such as the Double Oracle algorithm can be leveraged. In this paper, we leverage the notions of critical and adversary actions, where critical actions should be applied before the adversary ones. We propose heuristics that provide a guidance for planners about what (critical) actions and in which order have to be applied in a good plan. We empirically evaluate our approach in terms of quality of generated strategies (by leveraging Double Oracle) and CPU time required to generated such strategies.

In Automated Planning, generating macro-operators (macros) is a well-known reformulation approach that is used to speed-up the planning process. Nowadays, given the number of existing techniques, a large number of macros is already available or can be easily extracted. Most of the macro generation techniques aim for using the same set of generated macros for each planner and every problem instance in a given domain. Although they provide ‘general improvement’, the effect of macros might vary a lot for different planners. Moreover, the impact of macros on structurally different problem instances than the training ones can be potentially very detrimental. Evidently, this limits the exploitation of macros in real-world planning applications, where the structure of problem instances can often change as well as the exploited planning engine can change from time to time. In this paper, we propose the Macro sets Evolution (MEvo) approach. MEvo has been designed for overcoming the aforementioned issues in order to improve the performance of domain-independent planners by dynamically selecting promising macros – taken from a given pool – while solving continuous streams of problem instances. Our extensive empirical study, involving more than 1,000 planning problem instances and 8 state-of-the-art planning engines, demonstrates effectiveness and efficiency of MEvo.

Macro-operators, macros for short, are a well-known technique for enhancing performance of planning engines by providing “short-cuts” in the state space. Existing macro learning systems usually generate macros from most frequent sequences of actions in training plans. Such approach priorities frequently used sequences of actions over meaningful activities to be performed for solving planning tasks. This paper presents a technique that, inspired by resource locking in critical sections in parallel computing, learns macros capturing activities in which a limited resource (e.g., a robotic hand) is used. In particular, such macros capture the whole activity in which the resource is “locked” (e.g., the robotic hand is holding an object) and thus “bridge” states in which the resource is locked and cannot be used. We also introduce an “aggressive” variant of our technique that removes original operators superseded by macros from the domain model. Usefulness of macros is evaluated on several stateof-the-art planners, and a wide range of benchmarks from the learning tracks of the 2008 and 2011 editions of the International Planning Competition.

Many problems from classical planning are applied in the environment with other, possibly adversarial agents. However, plans found by classical planning algorithms lack the robustness against the actions of other agents - the quality of computed plans can be significantly worse compared to the model. To explicitly reason about other (adversarial) agents, the game-theoretic framework can be used. The scalability of game-theoretic algorithms, however, is limited and often insufficient for real-world problems. In this paper, we combine classical domain-independent planning algorithms and game-theoretic strategy-generation algorithm where plans form strategies in the game. Our contribution is threefold. First, we provide the methodology for using classical planning in this game-theoretic framework. Second, we analyze the trade-off between the quality of the planning algorithm and the robustness of final randomized plans and the computation time. Finally, we analyze different variants of integration of classical planning algorithms into the game-theoretic framework and show that at the cost a minor loss in the robustness of final plans, we can significantly reduce the computation time.

The level of expressiveness of planning domain models determines their accuracy in describing real-world domains as well as their efficiency in terms of performance of planners. More expressive models might be accurate but hard for planners while less expressive models might be easier for planners but not very accurate. In this paper, we consider a problem of efficient routing of vehicles in urban road networks. We propose three domain models with different level of expressiveness to address the problem. We investigate how the models differ in terms of accuracy (quality of plans they produce) and efficiency of plan generation.

Recent advances in automated planning are leading towards the use of planning engines in a wide range of real-world applications. As the exploitation of planning techniques in applications increases, it becomes imperative to assess the robustness of planning engines with regards to poorly-engineered (or maliciously modified) knowledge models provided as input for the reasoning process. In this work, to understand the impact of poorly-engineered knowledge on planning engines, we consider the perspective of a hypothetical attacker that is interested in subtly manipulating such knowledge to introduce unnecessary overheads that consequently slow down the planning process. This narrative ploy allows us to describe different types of knowledge engineering issues that cannot be detected via validation of the models, and to measure their impact on the performance of a range of planning engines exploiting very different approaches for steps like pre-processing and search.

Abstract Temporal planning is a research discipline that addresses the problem of generating a totally or a partially ordered sequence of actions that transform the environment from some initial state to a desired goal state, while taking into account time constraints and actions' duration. For its ability to describe and address temporal constraints, temporal planning is of critical importance for a wide range of real‐world applications. Predicting the performance of temporal planners can lead to significant improvements in the area, as planners can then be combined in order to boost the performance on a given set of problem instances. This paper investigates the predictability of the state‐of‐the‐art temporal planners by introducing a new set of temporal‐specific features and exploiting them for generating classification and regression empirical performance models (EPMs) of considered planners. EPMs are also tested with regard to their ability to select the most promising planner for efficiently solving a given temporal planning problem. Our extensive empirical analysis indicates that the introduced set of features allows to generate EPMs that can effectively perform algorithm selection, and the use of EPMs is therefore a promising direction for improving the state of the art of temporal planning, hence fostering the use of planning in real‐world applications.

Abstract In the field of automated planning, the central research focus is on domain‐independent planning engines that accept planning tasks (domain models and problem descriptions) in a description language, such as Planning Domain Definition Language, and return solution plans. The performance of planning engines can be improved by gathering additional knowledge about specific planning domain models/tasks (such as control rules) that can narrow the search for a solution plan. Such knowledge is often learned from training plans and solutions of simple tasks. Using techniques to reformulate the given planning task to incorporate additional knowledge, while keeping to the same input language, allows to exploit off‐the‐shelf planning engines. In this paper, we present inner entanglements that are relations between pairs of operators and predicates that represent the exclusivity of predicate achievement or requirement between the given operators. Inner entanglements can be encoded into a planner's input language by transforming the original planning task; hence, planning engines can exploit them. The contribution of this paper is to provide an in‐depth analysis and evaluation of inner entanglements, covering theoretical aspects such as complexity results, and an extensive empirical study using International Planning Competition benchmarks and state‐of‐the‐art planning engines.

Most learning for planning approaches rely on analysis of training plans. This is especially the case for one of the best-known learning approach: the generation of macro-operators (macros). These plans, usually generated from a very limited set of training tasks, must provide a ground to extract useful knowledge that can be fruitfully exploited by planning engines. In that, training tasks have to be representative of the larger class of planning tasks on which planning engines will then be run. A pivotal question is how such a set of training tasks can be selected. To address this question, here we introduce a notion of structural similarity of plans. We conjecture that if a class of planning tasks presents structurally similar plans, then a small subset of these tasks is representative enough to learn the same knowledge (macros) as could be learnt from a larger set of tasks of the same class. We have tested our conjecture by focusing on two state-of-the-art macro generation approaches. Our large empirical analysis considering seven state-of-the-art planners, and fourteen benchmark domains from the International Planning Competition, generally confirms our conjecture which can be exploited for selecting small-yet-informative training sets of tasks.

In sports, athletes need detailed and individualised training plans for maintaining and improving their skills in order to achieve their best performance in competitions. This presents a considerable workload for coaches, who besides setting objectives have to formulate extremely detailed training plans. Automated Planning, which has already been successfully deployed in many real-world applications such as space exploration, robotics, and manufacturing processes, embodies a useful mechanism that can be exploited for generating training plans for athletes. In this paper, we propose the use of Automated Planning techniques for generating individual training plans, which consist of exercises the athlete has to perform during training, given the athlete's current performance, period of time, and target performance that should be achieved. Our experimental analysis, which considers general training of kickboxers, shows that apart of considerable less planning time, training plans automatically generated by the proposed approach are more detailed and individualised than plans prepared manually by an expert coach.

Algorithm configuration tools have been successfully used to speed up local search satisfiability (SAT) solvers and other search algorithms by orders of magnitude. In this paper, we show that such tools are also very useful for generating hard SAT formulas with a planted solution, which is useful for benchmarking SAT solving algorithms and also has cryptographic applications. Our experiments with state-of-the-art local search SAT solvers show that by using this approach we can randomly generate satisfiable formulas that are considerably harder than uniform random formulas of the same size from the phase-transition region or formulas generated by state-of-the-art approaches. Additionally, we show how to generate small satisfiable formulas that are hard to solve by CDCL solvers.

Domain independent planning engines accept a planning task description in a language such as PDDL and return a solution plan. Performance of planning engines can be improved by gathering additional knowledge about a class of planning tasks. In this paper we present Outer Entanglements, relations between planning operators and predicates, that are used to restrict the number of operator instances. Outer Entanglements can be encoded within a planning task description, effectively reformulating it. We provide an in depth analysis and evaluation of outer entanglements illustrating the effectiveness of using them as generic heuristics for improving the efficiency of planning engines.

Acting of intelligent entities, or agents, is determined by their ability to deliberatively reason towards longer-term goals while being able to react to unexpected situations. In particular, the agent generates a plan and while the plan is being executed the agent monitors the environment and eventually reacts to avoid possibly dangerous situations. In this paper, we present a concept of "safe'' planning and execution framework that defines the notion of "dangerous'' states the agent should avoid and evaluates how agent's possible actions influence "dangerousness'' of its situation. In particular, we introduce three "clever'' agents accommodating such a framework providing three different strategies of handling "dangerous'' situations occurring during the plan execution.

We propose an approach to reason about agent planning programs with global information. Agent planning programs can be understood as a network of planning tasks, accommodating long-term goals, non-terminating behaviors, and interactive execution. We provide a technique that relies on reasoning about ``global" dead-ends and that can be incorporated to any planning-based approach to agent planning problems. In doing so, we also introduce the notion of online execution of such planning structures. We provide experimental evidence suggesting the technique yields significant benefits.

Mission planning and execution for autonomous vehicles is crucial for their effective and efficient operation during scientific exploration, or search and rescue missions, to mention a few. Automated Planning has shown to be a useful tool for “high level” mission planning, that is, allocating tasks to vehicles while following given constraints (e.g., energy, collision avoidance). In this paper, we focus on making mission planning flexible and robust. That is, a human mission coordinator can modify tasks during the mission execution, so the tasks have to be dynamically reallocated during the process. Moreover, we assume that communication might not be reliable when vehicles are “outside”, i.e., performing the tasks, and thus we enforce vehicles to come back to their safe spots regularly. To address these requirements, we have developed two models, namely “all tasks” and “one round”, and integrated them to the control software. We have evaluated our approach in a field experiment focused on a mine-hunting scenario.

The separation of planner logic from domain knowledge supports the use of reformulation and configuration techniques, such as macro-actions and entanglements, which transform the model representation in order to improve a planner’s performance. One drawback of such an approach is that it may require a potentially expensive training phase. In this paper, we introduce heuristic approaches for the online configuration of planning domain models. The proposed heuristics consider different aspects of PDDL-encoded operators for reordering such operators in the domain model, relying on the assumption that the way in which operators are encoded carries useful information about their expected use.

The global growth in urbanisation increases the demand for services including road transport infrastructure, presenting challenges in terms of mobility. In this scenario, optimising the exploitation of urban road networks is a pivotal challenge. Existing urban traffic control approaches, based on complex mathematical models, can effectively deal with planned-ahead events, but are not able to cope with unexpected situations --such as roads blocked due to car accidents or weather-related events-- because of their huge computational requirements. Therefore, such unexpected situations are mainly dealt with manually, or by exploiting pre-computed policies. Our goal is to show the feasibility of using mixed discrete-continuous planning to deal with unexpected circumstances in urban traffic control. We present a PDDL+ formulation of urban traffic control, where continuous processes are used to model flows of cars, and show how planning can be used to efficiently reduce congestion of specified roads by controlling traffic light green phases. We present simulation results on two networks (one of them considers Manchester city centre) that demonstrate the effectiveness of the approach, compared with fixed-time and reactive techniques.

Supervision and control of Autonomous underwater vehicles (AUVs) has traditionally been focused on an operator determining a priori the sequence of waypoints of a single vehicle for a mission. As AUVs become more ubiquitous as a scientific tool, we envision the need for controlling multiple vehicles which would impose less cognitive burden on the operator with a more abstract form of human-in-the-loop control. Such mixed-initiative methods in goal-oriented commanding are new for the oceanographic domain and we describe the motivations and preliminary experiments with multiple vehicles operating simultaneously in the water, using a shore-based automated planner.

Restricting the search space has shown to be an effective approach for improving the performance of automated planning systems. A planner-independent technique for pruning the search space is domain and problem reformulation. Recently, Outer Entanglements, which are relations between planning operators and initial or goal predicates, have been introduced as a reformulation technique for eliminating potential undesirable instances of planning operators, and thus restricting the search space. Reformulation techniques, however, have been mainly applied in classical planning, although many real-world planning applications require to deal with numerical information. In this paper, we investigate the usefulness of reformulation approaches in planning with numerical fluents. In particular, we propose and extension of the notion of outer entanglements for handling numeric fluents. An empirical evaluation, which involves 150 instances from 5 domains, shows promising results.

In the last decade the emphasis on improving the operational performance of domain independent automated planners has been in developing complex techniques which merge a range of different strategies. This quest for operational advantage, driven by the regular international planning competitions, has not made it easy to study, understand and predict what combinations of techniques will have what effect on a planner’s behaviour in a particular application domain. In this paper, we consider two machine learning techniques for planner performance improvement, and exploit a modular approach to their combination in order to facilitate the analysis of the impact of each individual component. We believe this can contribute to the development of more transparent planning engines, which are designed using modular, interchangeable, and well-founded components. Specifically, we combined two previously unrelated learning techniques, entanglements and relational decision trees, to guide a “vanilla” search algorithm. We report on a large experimental analysis which demonstrates the effectiveness of the approach in terms of performance improvements, resulting in a very competitive planning configuration despite the use of a more modular and transparent architecture. This gives insights on the strengths and weaknesses of the considered approaches, that will help their future exploitation.

Abstract: This paper introduces the Knowledge Engineering Web Interface (KEWI) which primarily aims to be used for modelling automated planning tasks in a semi-formal framework. The conceptual model used to represent the declarative and procedural knowledge in KEWI is described formally. The model consists of three layers: a rich ontology, a model of basic actions, and more complex methods. It is this structured conceptual model based on the rich ontology that facilitates knowledge engineering. The focus of this paper is to show how the central knowledge model used in KEWI differs from a model directly encoded in PDDL, the language accepted by most existing planning engines. Specifically, the rich ontology enables a more concise and natural style of representation. For operational use, KEWI automatically generates PDDL. Initial experiments show that the generated PDDL can be processed by a planner without incurring significant drawbacks. 1

Satisficing planning engines are often able to generate plans in a reasonable time, however, plans are often far from optimal. Such plans often contain a high number of redundant actions, that are actions, which can be removed without affecting the validity of the plans. Existing approaches for determining and eliminating redundant actions work in polynomial time, however, do not guarantee eliminating the "best" set of redundant actions, since such a problem is NP-complete. We introduce an approach which encodes the problem of determining the "best" set of redundant actions (i.e. having the maximum total-cost) as a weighted MaxSAT problem. Moreover, we adapt the existing polynomial technique which greedily tries to eliminate an action and its dependants from the plan in order to eliminate more expensive redundant actions. The proposed approaches are empirically compared to existing approaches on plans generated by state-of-the-art planning engines on standard planning benchmarks.

In Automated planning, learning and exploiting additional knowledge within a domain model, in order to improve the performance of domain-independent planners, has attracted much research. Reformulation techniques such as those based on macro-operators or entanglements are very promising because they are, to some extent, domain model and planning engine independent. Despite the significant amount of work that has been done for designing techniques aimed at extracting this additional knowledge in this form, no methodological analysis has been performed for a better comprehension of their learning process. In this paper, we focus on studying learnability of entanglements in planning, in terms of how the learning process can be influenced by the quantity and the quality of the training data. So, we aim to investigate whether a small number of training planning problems is sufficient for learning a good quality set of (compatible) entanglements. Quality of the training data refers to situations where (suboptimal) plans often consist of 'flaws' (e.g. unnecessary actions). Therefore, we will investigate how the current entanglement learning approach handles such 'flaws' in training plans. Also, we will investigate whether training plans generated by different planners lead to different results of the learning process.

Despite the advances made in the last decade in automated planning, no planner outperforms all the others in every known benchmark domain. This observation motivates the idea of selecting different planning algorithms for different domains. Moreover, the planners' performances are affected by the structure of the search space, which depends on the encoding of the considered domain. In many domains, the performance of a planner can be improved by exploiting additional knowledge, extracted in the form of macro-operators or entanglements. In this paper we propose ASAP, an automatic Algorithm Selection Approach for Planning that: (i) for a given domain initially learns additional knowledge, in the form of macro-operators and entanglements, which is used for creating different encodings of the given planning domain and problems, and (ii) explores the 2 dimensional space of available algorithms, defined as encodings -- planners couples, and then (iii) selects the most promising algorithm for optimising either the runtimes or the quality of the solution plans.

Automated planning even in its simplest form, classical planning, is a computationally hard problem. With the increasing involvement of intelligent systems in everyday life there is a need for more and more advanced planning techniques able to solve planning problems in little (or real) time. However, planners designed to solve planning problems as fast as possible often provide solution plans of low quality. The quality of solution plans can be improved by their post-planning analysis by which redundant actions or optimizable sub plans can be identified. In this paper, we present techniques for determining redundancy of actions in plans. Especially, we present techniques for efficient redundancy checking of pairs of inverse actions. These techniques are accompanied with necessary theoretical foundations and are also empirically evaluated using existing planning systems and standard planning benchmarks.

Planning techniques recorded a significant progress during recent years. However, many planning problems remain still hard even for modern planners. One of the most promising approaches is gathering additional knowledge by using learning techniques. Well known sort of knowledge - macro-operators, formalized like `normal` planning operators, represent a sequence of primitive planning operators. The other sort of knowledge consists of pruning unnecessary operators' instances (actions) by investigating connections (entanglements) between operators and initial or goal predicates. Advantageously, macro-operators and entanglements can be encoded directly in planning domains (or problems) and common planning systems can be applied on them. In this paper, we will show how we can put these approaches together. We will provide an experimental evaluation showing that combining these learning techniques can improve the planning process.